¿Cómo escribir un programa en lenguaje C en imagen?
//09/10/24
//lcd1602 muestra hora, fecha, semana y temperatura
//Ajusta la hora mediante el botón: K10--hora , K11--Minutos, K12--segundos (restablecido a cero), K13--semana, BR1--año, RB2--mes, RB3--día.
//Requisitos del chip: PIC16F877A
#includelt; pic.hgt; //Contiene recursos internos del microcontrolador predefinidos
__CONFIG(0x1832
);//Palabra de configuración del chip, vigilancia desactivada, retardo de encendido activado, detección de apagado desactivada, programación de bajo voltaje desactivada, cifrado, oscilación HS de cristal de 4M
#define i_o RB4 //Definición Puerto de datos de DS1302
#define sclk RB0 //Definir el puerto de reloj de DS1302
#define rst RB5 //Definir el puerto de reinicio de DS1302
# define rs RA1 //1602
#define rw RA2
#define e RA3
# define DQ RA0 //Define puerto de datos 18B20
unsigned char TLV=0; //Los 8 bits superiores de la temperatura recopilada
unsigned char THV=0; //Los 8 bits inferiores de la temperatura recopilada
unsigned char bai;
p>unsigned char shi; //dígito entero de decenas
unsigned char ge; //dígito entero de unidades
unsigned char shifen; dígito
float temp;
void display();
//Definir la tabla de almacenamiento de fecha y hora de lectura
char table1[ 7];
p>//Defina el código de visualización de 0-9
const char table2[]={0xc0, 0xf9, 0xa4, 0xb0, 0x99, 0x92, 0x82, 0xf8, 0x80, 0x90};
unsigned char rx_data, read_data, recuento, segundos, min, hora, día, lunes, semana, año, hora
//--- -------- ----------------------------------
/ /ds18b20 parte
//-------------------------------------- ---------- ---
//Función de retardo
void delay1(unsigned int x)
{
unsigned int i;
p>for(i=x;igt;0;i--);
}
//-- ----------- ----------------------------------
//Función de retardo
vo
id retraso2(char x, char y)
{
char z
hacer{
z=y; >
do{;} while(--z);
} while(--x);
}
//El tiempo del comando Es: 7 (3*(Y-1) 7)*(X-1) Si agrega la instrucción de llamada de función, configuración de página y 7 instrucciones dedicadas a pasar parámetros.
//Es: 14 (3*(Y-1) 7)*(X-1).
//****************************************** * p>
//Inicializar ds18b20
void ds18b20_init()
{
char presencia=1;
while(presencia)
{
TRISA0=0; //El host lo lleva al nivel bajo
DQ=0; delay2(2, 99); //Retraso 503us
TRISA0=1; //Libera el bus y otras resistencias para elevar el bus y mantenerlo durante 15~60us
delay2 (2, 8); // Retraso 70us
if(DQ==1) presencia=1; //No se recibe señal de respuesta, continúa reiniciando
else presencia=0; //Señal de respuesta recibida
delay2(2, 60); //Retraso 430us
}
}
//** ***** ********************************************** ***
//Escribir ds18b20
void ds18b20_write_byte(código de carácter sin firmar)
{
carácter sin firmar i, k <; /p>
for (i=8;igt;0;i--)
{
k=codeamp;0x01;
TRISA0= 0;
DQ=0; //La línea de datos se baja para generar un intervalo de tiempo
asm("nop");
asm(" nop");
if(k) DQ=1; //Escribe 1 para elevar el nivel de datos
delay1(3); //Retraso 42us, ds18b20 muestra la línea de datos
asm( "nop");
TRISA0=1; //El muestreo finaliza, libera el bus, sube el nivel
code=codegt;gt ;1;
demora1(7); //Retraso 82us
}
}
//****** ********** *************************************
//Leer ds18b20 p>
carácter sin firmar ds18b20_read_byte()
{
carácter sin firmar i
, k;
for (i=8; igt; 0; i--)
{
k=gt
TRISA0=0;
DQ=0; // Tire de la línea de datos hacia abajo y luego hacia arriba para generar un intervalo de tiempo de lectura
asm("nop");
asm("nop");
TRISA0=1;
asm("nop");
asm("nop"); );
if(DQ) k=k|0x80; //La lectura de bits debe completarse dentro de 15us
delay1(6); 72us
}
devolución (k);
}
//************ ********** *************************
//Iniciar la función de conversión de temperatura
void get_temp()
{
int i
firmado int
TRISA0=1;
ds18b20_init(); //Restablecer y esperar la respuesta del esclavo
ds18b20_write_byte(0XCC); //Ignorar la coincidencia de ROM
ds18b20_write_byte(0X44); Enviar comando de conversión de temperatura
for (i=2; igt; 0; i--)
{
display() //Llamar a la función de visualización varias veces para garantizar el tiempo necesario para completar la conversión de temperatura p>
}
ds18b20_init(); //Restablecer nuevamente y esperar la respuesta del esclavo
ds18b20_write_byte(0XCC ); //Ignorar coincidencia de ROM
ds18b20_write_byte(0XBE); //Enviar comando de lectura de temperatura
TLV=ds18b20_read_byte() //La temperatura de lectura es baja 8
THV=ds18b20_read_byte(); //La temperatura de lectura es alta 8 bits
TRISA0=1; //Libera el bus
t=THVlt;lt;8;
t=t|TLV;
if(tlt; 0) //Temperatura negativa
{
temp=(~t 1)* 0.0625*10 0.5; // Cuando la temperatura es negativa, suma 1 a la inversa. Luego multiplica por 0.0625 para obtener la temperatura real, multiplica por 1.
0 0.5 muestra un punto decimal y se redondea
}
else
temp=t*0.0625*10 0.5 //Temperatura positiva
if(tlt; 0)
bai='-'; //Cuando la temperatura es negativa, el dígito de las centenas muestra un signo negativo
else
bai=(const ) temp/1000 0x30; //Dígito de las centenas
shi=((const) temp1000)/100; //Dígito de las decenas
ge=((const) temp1000)100/10 ; //Décimo lugar
shifen=((const) temp1000)10010; //Décimo lugar
NOP();
}
//----------------------------------------- -------
//------------Parte DS1303-------------------- ---
//-------------------------------- ----------
//Programa de retraso
void delay() //Programa de retraso
{
int i; //Definir variable entera
for(i=0x64;i--;); //Retraso
}
//Escribir un función de datos de bytes
void write_byte(datos de caracteres sin firmar)
{
int j; //Establece la variable de bucle
for( j=0; jlt; 8; j) // Escribe continuamente 8 bits
{
i_o=0 //Establece los datos en 0 primero
sclk=0; //Pulsa la señal del reloj baja
if(dataamp; 0x01) //Determina si el bit de datos a enviar es 0 o 1
{
i_o=1; //El bit de datos a enviar es 1
}
data=datagt;gt;1; hacia la derecha en 1 bit
sclk=1; // Extrae la señal de reloj alta
}
sclk=0 // Después de escribir un byte, baja hacia abajo; la señal del reloj
}
// ------------------------------ ----------
--------
//Leer una función de byte
unsigned char read_byte()
{
int j ; //Establecer la variable de bucle
TRISB4=1; //Establecer la dirección del puerto de datos como entrada
for(j=8;j--;) //Leer continuamente 8 bits
{
sclk=0; //Bajar la señal del reloj
rx_data=rx_datagt;gt;1 //Desplazar el registro de recepción hacia la derecha 1 bit
p>
if(i_o==1) rx_data=rx_data|0x80;
sclk=1 //Sube la señal del reloj
<; p> }TRISB4=0; // Restaura la dirección del puerto de datos a la salida
sclk=0; // Baja la señal del reloj
return( rx_data); //Devuelve los datos leídos
}
//------------------------ ---------- ------------
//Escribir DS1302
void write_ds1302(dirección de caracteres sin firmar, código de caracteres sin firmar )
{
primero=0
sclk=0
primero=1
escribir_byte; (dirección);
write_byte(código);
sclk=0
primero=1;
//----- -------------------------------------
//Leer DS1302
void read_ds1302(dirección de caracteres sin firmar)
{
rst=0
sclk=; 0;
primero=1;
write_byte(addr);
read_data=read_byte();
}
//--------------------------------- --------------- ---
//Función de tiempo de lectura
void get_time()
{
int i; //Establecer variable de bucle
rst=1 //Habilitar DS1
302
write_byte(0xbf); //Enviar comando de lectura multibyte
for(i=0;ilt;7;i) //Leer continuamente 7 bytes de datos
{
table1[i]=read_byte(); //Llama a la función para leer 1 byte de datos
}
rst=0 ; //Restablecer DS1302
}
//Función de inicialización de DS1302
void ds1302_init()
{
sclk=0; //Bajar la señal del reloj
rst =0; //Restablecer DS1302
rst=1 //Habilitar DS1302
write_ds1302 (0x8e, 0); //Enviar comando de control
rst=0; //Restablecer
}
//--- ----- -------------------------------
/ /Establecer función de hora
void set_time()
{
//Definir el tiempo a configurar: segundos, minutos, horas, días, meses, semanas, año, palabra de control
const char table[]={0x00, 0x00, 0x12, 0x23, 0x10, 0x05, 0x09, 0x00};
int i;
rst=1; //Habilitar DS1302
write_byte(0xbe); //Relojar comando de escritura multibyte
for(i=0; ilt ;8;i) //Escribe 8 bytes de datos continuamente
{
write_byte(table[i]); //Llama a la función de escritura de un byte
}
primero=0; //Restablecer
}
//---------------- ------ --------------------
//Convierte un número binario de 8 bits en un número decimal
void two_to_ten(unsigned char i)
{
tiempo=(tabla1[i]amp; 0x0f) (tabla1[i]gt; gt; 4)*0
p; >
}
//---------------------
------------------
//Convertir número decimal a código BCD
void ten_to_bcd(unsigned char i) p >
{
tiempo=((i/0)lt;lt;4)|(i0);
}
//- - -------------------------------------------------
// Programa de ajuste de tiempo
void change_time()
{
if(RC0==0) //Cambiar la semana- --k13
{
retraso();
si(RC0==0)
{
if(count==0)
{
count=1
two_to_ten(5);
semana=tiempo;
semana ;
if(weekgt;=8)
{
semana==1; write_ds1302(0x8A, 1);
p>
}
else
write_ds1302(0x8A, semana
}
}
}
else if(RC1==0) //Restablece los segundos a cero--k12
{ p>
demora();
si(RC1==0)
{
si(cuenta==0)
{
count=1;
write_ds1302(0x80, 0,
}
}
}
else if(RC2== 0) //Cambiar cuantil--k11
{
retraso();
if(RC2==0)
{
if(count==0)
{
count=1; p>
dos_a
_ten(1); //Convierte código BCD a número decimal
min=time;
min;
if(mingt;=60)
{
min=0;
write_ds1302(0x82, min
}
más
);{
ten_to_bcd(min); //Convierte el número decimal a código BCD y lo almacena en DS1302
write_ds1302(0x82, time);
}
}
}
}
else if(RC3==0) //Cambiar dígito de hora--k10
{
retraso();
si(RC3==0)
{
si(cuenta ==0 )
{
count=1;
two_to_ten(2); //Convierte el código BCD a número decimal
hora=hora ;
hora ;
if(horagt;=24)
{
hora=0;
write_ds1302(0x84, hora);
}
else
{
ten_to_bcd(hora);
write_ds1302(0x84, hora);
}
}
}
}
más if(RB2 ==0)
{
retraso();
if(RB2==0)
{ p>
si(cuenta==0)
> {
count=1;
two_to_ten(4); //Convierte código BCD a número decimal
mon=time;
mon;
if(mongt;=13)
{
mon=1;
write_ds1302(0x88, mon);
}
else
{
ten_to_bcd(mon);
write_ds1302(0x88, hora);
}
}
}
}
si no (RB3==0)
{
retraso();
si(RB3==0)
{
si(cuenta== 0)
{
count=1;
two_to_ten(3); //Convierte el código BCD a número decimal
day= hora;
día;
if((table1[6]4==0)amp;amp;(table1[4]==2)amp;amp;(daygt; =30)) //Febrero del año
{
día=1;
write_ds1302(0x86, día
); }
else if(((table1[6]4)!=0)amp;amp;(table1[4]==2)amp;amp;(daygt;=29))//No Febrero del año
{
día=1
write_ds1302(0x86, día
);
}
else if(((tabla1[4]==1)||(tabla1[4]==3)||(tabla1[4]==5)||(tabla1[4] ==7)||(tabla1[4]==8)||(tabla1[4]==0x10)||(tabla1[4]==0x12))amp;amp;(daygt;=32))
{
día=1
write_ds1302(0x86, día);
}
más si( ((tabla1[4]==4)||(tabla1[4]==6)||(tabla1[4]==9)||(tabla1[4]==0x11))amp;amp;(día ;=31))
{
día=1;
write_ds1302(0x86, día)
else
{
ten_to_bcd(día);
write_ds1302(0x86, hora
}
);}
}
}
si no (RB1==0)
{
retraso();
if(RB1==0)
{
if(count==0)
{ p>
count=1;
two_to_ten(6); //Convierte código BCD a número decimal
año=time;
año;
if(añogt;=16)
{
año=0x00;
write_ds1302(0x8c, 0);
}
else
{
ten_to_bcd(año);
write_ds1302(0x8c, hora
); }
}
}
}
else
count=0
> }
//*************************************** *** *
//***************lcd1602************************ **
>*************************************** ***
//Programa de retraso
//void delay()
// {
// unsigned char i;
// for(i=100;igt;0;i--);
// }
//******* *********** *************************
//LCD escribe un byte de datos
void write_lcd(código de carácter sin firmar)
{
PORTD=código
rs=1; > rw=0;
e=0;
retraso();
e=1;
//****** *************************************
//función de comando de escritura de LCD
void lcd_enable(código de carácter sin firmar)
{
PORTD=código;
rs=0;
rw= 0;
e=0;
retraso(); p>
}
//************************************ *******
//configuración de la pantalla LCD
void lcd_init()
{
lcd_enable(0x01); //Borrar pantalla
lcd_enable(0x38 ); //Establecer pantalla 16X2, matriz de puntos 5X7
lcd_enable(0x0c); //Abrir pantalla, no mostrar cursor
lcd_enable(0x06); //Mover el cursor hacia la izquierda
p>}
//------------------ --------------------- --------
//Función de visualización
visualización nula()
{
// PORTD=0X80 ;
//Horas
lcd_enable(0X80);
write_lcd((table1[2]gt;gt;4) 0x30);
// PORTD=0x81 ;
lcd_enable(0x81);
write_lcd((table1[2]amp; 0x0f)
// PORTD=0X82; >
lcd_enable(0X82);
write_lcd(':');
// PORTD=0X83; // puntos
lcd_enable(0X83) ;
write_lcd((table1[1]gt;gt;4) 0x30);
// PORTD=0x84;
lcd_enable(0x84);
write_lcd((table1[1]amp; 0x0f) 0x30
// PORTD=0X85
lcd_enable(0X85); p> write_lcd(':');
// PORTD=0X86; //Segundos
lcd_enable(0X86);
write_lcd((table1[0 ]gt; gt; 4) 0x30);
// PORTD=0x87;
lcd_enable(0x87);
write_lcd((tabla1[0]amp); ; 0x0f) 0x30);
// PORTD=0X89; // Cientos de dígitos de temperatura
lcd_enable(0X89); /p>
// PORTD=0X8a; // Decenas de temperatura
lcd_enable(0X8a);
write_lcd(shi 0x30); // PORTD=0X8b; //El dígito de las unidades de la temperatura
lcd_enable(0X8b);
write_lcd(ge 0x30);
// PORTD= 0X8c;
lcd_enable(0X8c);
write_lcd('.');
// PORTD=0X8d // Décimo lugar de temperatura
lcd_enable(0X8d);
write_lcd(shifen 0x30);
// PORTD=0X8e; //Mostrar 'C'
lcd_enable(
0X8e);
write_lcd('C');
//
// PORTD=0XC0 //Año
lcd_enable; (0XC0);
write_lcd((table1[6]gt; gt; 4)
//PORTD=0XC1
lcd_enable(0XC1);
write_lcd((table1[6]amp; 0x0f) 0x30);
// PORTD=0XC2
lcd_enable(0XC2); p>
p>
write_lcd('-');
// PORTD=0XC3 //Mes
lcd_enable(0XC3);
write_lcd(( table1[4]gt;gt;4) 0x30);
// PORTD=0xC4;
lcd_enable(0xC4);
write_lcd((table1[ 4]amp; 0x0f) 0x30);
// PORTD=0XC5
lcd_enable(0XC5); ');
p>
// PORTD=0XC6; //Día
lcd_enable(0XC6);
write_lcd((table1[3] gt; gt; 4) 0x30);
// PORTD=0xC7;
lcd_enable(0xC7);
write_lcd((tabla1[3]amp; 0x0f) 0x30);
// PORTD=0XCD; //Día de la semana
lcd_enable(0XCD); amplificador; 0x0f) 0x30);
}
//-------------------- ------------- -----
//Función de definición de PIN
void port_init()
{
TRISA=0x00; // Establece la salida completa del puerto A
TRISD=0X00; //Establece la salida completa del puerto D
ADCON1=0X06; puerto como un puerto de E/S normal
TRISB=0X0E; //
OPTION=0X00 //Abre el puerto B débilmente;
Pull-up
PORTA=0XFF;
PORTD=0XFF; //Apaga todas las pantallas
lcd_init(); TRISC= 0XEF; // salida RC3, otros son entrada
PORTC=0XEF
count=0
}
/; /- ------------------------------------------------
//Función principal
void main()
{
port_init(); //Llamar a la función de inicialización del pin p>
read_ds1302(0x81); //Compruebe si DS1302 está oscilando
if(read_dataamp;0x80) //No, inicialice DS1302
{
ds1302_init() ; //Llamar a la función de inicialización DS1302
set_time(); //Llamar a la función de configuración de tiempo
}
while(1)
{
get_time(); //Llamar a la función de tiempo
change_time();
get_temp(); función de conversión de temperatura
display(); //Llamar a la función de visualización
}
}