Red de conocimiento informático - Material del sitio web - ¿Cómo escribir un programa en lenguaje C en imagen?

¿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).

//****************************************** *

//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

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

}

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)

{

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

{

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;

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)

{

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)

{

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

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

}

}