Se requiere buscar información sobre un microcontrolador para controlar los cambios de temperatura del agua. Se requieren programas y diagramas de hardware.
¡Tengo! Y también simulado #include"STC89C51RC.H"
#includelt; absacc.hgt;
#include "ds18b20.h"
#include" lcd1602. h"
#include "ds1302.h"
#include "2402.h"
uchar datos datadis[]={0x00, 0x00, 0x00, 0x00, 0x00};
uint temp=0;
bit K1=P3^0;
bit K2=P3^1;
bit K3=P3^2;
bit K4=P3^3;
bit K5=P3^7;
bit L1=P1 ^6 ;
sbit L2=P1^7;
sbit led=P2^7;
sbit altavoz=P1^0;
uchar keynum=1, bandera, bandera1, bandera2, sumador, q;
uint k, count, th, tl
uchar th1=8; uchar th2=5;
uchar th3=2;
uchar th4=0;
uchar tab, w;
anular retraso (uchar z)
{
uchar x, y;
for(x=z;xgt;0;x--)
for(y=110;ygt;0;y--);
}
uchar key4()
{
si(K4==0)
{
retraso(5);
si(K4==0)
{
mientras(!K4);
keynum;
if(keynum==5)keynum=1;
}
}
devuelve keynum;
}
void key_lcd()
{
if(flag1==1amp;amp;k==3)
{
if(K3==0)
{
retraso(5);
if(K3==0)
{
mientras(!K3);
bandera ;
if(flag==5)flag=1;
}
}
cambiar(bandera)
{
caso 1:
{
si(K1==0)
{
retraso(5);
if(K1==0)
{
th1;
mientras(!K1) ;
si(th1==10)th1=0;
}
}
si(K2==0)
{
retraso(5);
si(K2==0
)
{
th1--;
mientras(!K2);
if(th1==-1)th1= 9;
}
}
write_cmd(0xc3);
write_dat(th1 0x30);
}romper;
caso 2:
{
if(K1==0)
{
retraso(5);
if(K1==0)
{
th2;
mientras(!K1);
si(th2==10)th2=0;
}
}
si(K2==0)
{
retraso(5);
if(K2==0)
{
th2--;
mientras(!K2);
if(th2==-1)th2=9;
}
}
write_cmd(0xc4);
write_dat(th2 0x30);
}break;
caso 3:
{
si(K1==0)
{
retraso(5);
si(K1==0)
{
th3;
mientras(!K1);
if(th3==10)th3=0;
}
}
if(K2==0)
{
retraso(5);
if(K2==0)
{
th3--;
mientras(!K2);
if(th3==-1)th3=9;
}
}
write_cmd(0xcb);
write_dat(th3 0x30);
}rotura;
caso 4:
{
if(K1==0)
{
retraso(5);
si(K1==0)
{
th4;
mientras(!K1);
si(th4==10)th4=0;
}
}
if(K2==0)
{
retraso(5);
if(K2==0)
{
th4--;
mientras(!K2);
if(th4==-1)th4=9;
}
}
write_cmd(0xcc);
write_dat(th4 0x30
}romper; predeterminado: break;
}
}
else flag1=0;
th=th1*10 th2; Bit de temperatura alta
tl=th3*10 th4; //Obtener el bit bajo de temperatura establecida
}
void alarm_speaker() //Sistema de alarma y comparar la temperatura actual
Y procesar
{
if(templt; (tl*10))
{
speaker=~speaker;
L1=0;
L2=1;
sumador;
tab=temp/10;
write_add( sumador,tab);
}
else if(tempgt; (th*10))
{
altavoz=~altavoz ;
L1=1;
L2=0;
sumador ;
tab=temp/10;
write_add(sumador, tabulador);
}
else if(templt; (th*10)amp; amp; tempgt; (tl*10))
{
altavoz=1
L1=1
L2=1; p>}
void main()
{
systemtime tiempo real;
led=0;
init_18b20();
init_lcd();
init_2402();
altavoz=1
mientras(1)
p> p>
{
k=key4();
get_ds1302(amp; realtime); //Obtener la hora
temp=read_temp); (); //Obtener la temperatura
delay(200);
//Retraso para mantener los datos estables y evitar la actualización de datos
switch(k)
{
caso 1: //Menú 1, visualización de la hora
{
led=0;
write_cmd(0x80);
print(" Hora: ");
print(realtime.TimeString);
write_cmd(0xc0);
print( " Fecha: ");
print(realtime.DateString);
} break;
caso 2: //Menú 2, mostrar temperatura
{
write_cmd(0x80);
print(" DS18B20 está bien ");
write_cmd(0xc0);
print("AHORA TEMP: . C ");
if(flagt==1)datadis[0]=0x2d;
else datadis[0 ]=temp/1000 0x30;
datadis[1]=temp/10010 0x30;
datadis[2]=temp/1010 0x30;
datadis[ 3]=0x2e;
datadis[4]=temp10 0x30;
write_cmd(0xca);
print(datadis);
}romper;<
/p>
caso 3: //Menú tres, muestra el valor de configuración de temperatura
{
write_cmd(0x80);
print(" cambiar temperatura : ");
write_cmd(0xc0);
print("TH= TL= ");
write_cmd(0xc3);
write_dat(th1 0x30);
write_cmd(0xc4);
write_dat(th2 0x30);
write_cmd(0xc5);
write_dat(0xdf); //Punto lejano en grados Celsius
write_cmd(0xc6);
write_dat(0x43);
write_cmd(0xcb);
write_cmd(0xc6);
write_cmd(0xcb);
p>
write_dat(th3 0x30);
write_cmd (0xcc);
write_dat(th4 0x30);
write_cmd(0xcd); // símbolo Celsius
write_dat(0xdf);
write_cmd(0xce);
write_dat(0x43);
flag1=1;
}break;
caso 4: //Menú cuatro, registrar la temperatura de la alarma
{
write_cmd(0x80);
print(" ALARM TEMP ");
write_cmd(0xc0);
print(" REGISTRO: ");
write_cmd(0xcb);
write_dat(0xdf);
write_cmd(0xcc);
write_dat(0x43);
flag2=1;
flag2=1;
write_dat(0x43 ); p>
}break;
predeterminado: break;
}
key_lcd(); //Escaneo de teclas para configuración de temperatura en el menú tres
p>alarm_speaker(); //El sistema de alarma almacena la temperatura excedida hasta 2402 y la registra
if(K5==0) //Presione K5 para mostrar la alarma actual temperatura
{
retraso(5);
if(K5==0)
{
while(! K5);
q=read_add(adder);
}
};
if(flag2==1amp ;amp; k==4)
{
write_cmd(0xc9);
write_dat(q/1010 0x30);
write_cmd(0xca );
write_dat(q10 0x30);
led=1;
}
}
}
#ifndef _lcd1602_h_
#define
_lcd1602_h__
#includelt;ds1302.hgt;
#define uchar unsigned char
#define uint unsigned int
#define LCD_IO P0
bit LCD_RS = P2^4
bit LCD_RW = P2^5
bit LCD_EN = P2^6
nulo; retardo11(uint z)
{
uint x, y;
for(x = z; x gt; 0; x--) for(y = 10; y gt; 0; y--);
}
/*Medir señal de ocupado
bit lcd_busy()
{
return (bit)(lcdrcamp;0x80);
}
/*Escribir datos*/
void write_cmd( uchar cmd)
{
LCD_RW=0; LCD_RS = 0; LCD_EN = 0; // Cuando LCD_RS y R/W están bajos al mismo tiempo, se pueden escribir instrucciones.
LCD_IO = cmd; retardo11(5); //Utilice EN para ingresar un pulso alto a continuación.
LCD_EN = 1; retardo11(5); >
}
/*Escribir comando*/
void write_dat(uchar dat)
{
LCD_RS = 1; LCD_EN = 0 ;LCD_RW=0; //Cuando LCD_RS está alto y LCD_RW está bajo, se pueden escribir datos.
LCD_IO = dat; .
LCD_EN = 1; retraso11(5) LCD_EN = 0;
}
/*Inicialización de LCD*/
void init_lcd()
{
LCD_EN = 0;
write_cmd(0x38);
write_cmd(0x0c);
write_cmd (0x06);
write_cmd(0x01);
write_cmd(0x80);
}
impresión nula ( uchar *str)
{
mientras(*str!='\0')
{
write_dat(*str) ;
str;
}
}
#endif
#ifndef _ds18b20_h_
#define _ds18b20_h_
#define uchar unsigned char
#define uint unsigned int
//Oscilador de cristal 22MHZ
// Retraso//
sbit DQ=P1^3;
bit flagt;
voi
d delay_18b20(uint i)
{
mientras(i--);
}
/*****Inicialización Programa****/
void init_18b20()
{
uchar x=0;
DQ=1;
p>
retraso_18b20(8);
DQ=0;
retraso_18b20(80);
DQ=1;
retraso_18b20(15);
x=DQ;
retraso_18b20(15);
}
/ ** Sección Leer una palabra**/
uchar read_byte()
{
uchar i=0;
uchar dat= 0;
for(i=0;ilt;8;i)
{
DQ=0;
datgt;gt ;=1;
DQ=1;
if(DQ)dat|=0x80;
delay_18b20(5);
}
return dat;
}
/**Escribir un byte**/
void write_byte(uchar dat)
{
uchar i=0;
for(i=0;ilt;8;i)
{
DQ= 0;
DQ=datamp;0x01;
delay_18b20(5);
DQ=1;
datgt ;gt;= 1;
}
}
/**Conversión de temperatura y lectura de temperatura**/
uint read_temp( )
{
uchar a=0;
uchar b=0;
uint
init_18b20() ;
write_byte(0xcc); //Omitir la operación de lectura del número de serie
write_byte(0x44); //Iniciar conversión de temperatura
delay_18b20(100 );
init_18b20();
write_byte(0xcc); //Omitir la operación de lectura del número de serie
write_byte(0xbe); //Leer Obtener el registro de temperatura, etc. (***Se pueden leer 9 registros) Los dos primeros son temperatura
a=read_byte() //Leer el octavo bit
if(bamp;0x80) //Si la posición más alta de los ocho bits superiores es 1, si es 1, es negativo temperatura, si es 0, es 0-128 ;
{
flagt=1;
a=~a;
b=~b;
}
else flagt=0;
t=(b*256 a)*5; escrito como t=(b*256 a)*0.625; return t ;
return (tgt; gt; 3); //Desplazarse tres lugares hacia la derecha equivale a 5/8=0.625. La temperatura devuelta tiene 4 dígitos, miles, centenas, decenas y un decimal después de la conversión.
, sin dígitos de miles
}
#endif
#ifndef _2402_h_
#define _2402_h_
#define uchar unsigned char
#define uint unsigned int
sbit sda=P1^2;
sbit scl=P1^1;
//sbit sda=P1^6;
//sbit scl=P1^5;
void nop()
{ }
void start() //Función: Iniciar el bus I2C, es decir, enviar la condición de inicio I2C.
{
sda=1
nop();
scl=1
nop(; );
sda=0;
nop();
}
void stop() //Función: Finalizar el I2C. bus, es decir, enviando la condición final I2C.
{
sda=0;
nop();
scl=1
nop(; );
sda=1;
nop();
}
void respons() //Función: controlador maestro Hacer una señal de respuesta, (puede ser una señal de respuesta o de no respuesta)
{
uchar i;
scl=1;
nop ();
mientras((sda==1)amp;amp;(ilt;250))i;
scl=0;
nop( );
}
void write_byte_2402(uchar dat) //Función: envía datos, que pueden ser una dirección o datos, y espera una respuesta después de enviarlos
{
uchar i,temp;
temp=dat;
scl=0;
nop(
for(i=0;ilt;8;i)
{
temp=templt;lt;1;
>scl =0 /*Establezca la línea de reloj en nivel bajo y prepárese para recibir bits de datos*/
nop();
sda=CY
nop; ();
scl=1; /*Establece la línea del reloj en alto para notificar al dispositivo controlado que comience a recibir bits de datos*/
nop();
}
scl=0;
nop();
sda=1; //La línea de datos SDA está inactiva
nop ();
sda=1; p>
}
uchar read_byte_2402() // Función: Se utiliza para recibir datos del dispositivo y determinar errores del bus (sin señal de respuesta). se envía). Utilice la función de respuesta después de enviar
{
uchar i, k
scl=0; prepárese para recibir bits de datos*/
nop();
for(i=0;ilt;8;i)
{
scl=1; /*Establezca la línea del reloj en alto Haga que los datos en la línea de datos sean válidos y mantenga la estabilidad de los datos*/
nop();
k= (klt;lt;1)|sda;
scl=0;
nop();
}
return k;
}
void write_add (uchar add, uchar dat)
{
start();
write_byte_2402(0xa0);
respons();
write_byte_2402(add);
respons();
write_byte_2402(dat)
respons();
stop();
}
uchar read_add(uchar agregar)
{
uchar k;
start();
write_byte_2402(0xa0);
respons();
escritura_byte_2402
(agregar);
respuestas();
iniciar();
write_byte_2402(0xa1); /p>
k=read_byte_2402();
detener();
return k
}
void init_2402 ()
{
uint i;
sda=1
nop(); =1;
nop();
for(i=0;ilt;256;i)
{write_add(i, 0);}
}
#endif
/*************************** **** **
Función interna DS1302
*************************** ***/
#ifndef _ds1302_h_
#define _ds1302_h_
sbit T_RST=P3^5;
sbit T_CLK=P3^ 6;
bit T_IO=P3^4;
bit ACC0=ACC^0;
bit ACC7=ACC^7;
typedef struct systemtime
{
uchar segundo;
uchar minuto;
uchar hora;
uchar semana;
día de uchar;
mes de uchar;
año de uchar;
uchar DateString[9];
uchar TimeString[ 9];
}systemtime; //Tipo de hora definido
/*Escribir datos de 1BYTE en DS1302*/
void writeB(uchar) ucda)
{
uchar i;
ACC=ucda
for(i=8;igt;0;i- -)
{
T_IO=ACC0
T_CLK=1
T_CLK=0; ACC= ACCgt; gt;
}
// T_IO=0
}
/*Leer 1BYTE de DS1302 datos*/
uchar readB()
{
uchar i;
for(i=8;igt;0;i --)
{
ACC=ACCgt;gt;1;
ACC7=T_IO;
T_CLK=1;
p>
T_CLK=0;
}
retorno(ACC); *Lectura de un solo byte, lee datos de una determinada dirección de DS1302,
Escribe la dirección primero y luego escribe el comando/datos****************** /
uchar r_ds1302(uchar ucaddr)
{
uchar ucda;
T_
RST=0;
T_CLK=0
T_RST=1
escribirB(ucaddr);
ucda=readB(); ;
T_CLK=1;
T_RST=0;
retorno(ucda);
}
/************************************
Leer la hora actual de DS1302,
p>El formato es:
Segundo, minuto, hora, día, mes, semana, año
*********** ***** *******************/
void get_ds1302(systemtime *Hora)
{
uchar readtime;
readtime = r_ds1302(0x81); // Segunda operación de lectura de registro 0x81
Time-gt; second = ((readtimeamp;0x70)gt;gt ;4)*10 (readtimeamp; 0x0f); //Dígitos de decenas y unidades
readtime = r_ds1302(0x83); //Operación de lectura de subregistro 0x83
Time-gt; minuto = ((readtimeamp; 0x70)gt;gt;4)*10 (readtimeamp;0x0f);
readtime = r_ds1302(0x85);
Hora-gt; (readtimeamp;0x70)gt ;gt;4)*10 (readtimeamp;0x0f);
readtime = r_ds1302(0x87);
Hora-gt;día = ((readtimeamp; 0x70)gt;gt; 4)*10 (tiempo de lecturaamp;0x0f);
tiempo de lectura = r_ds1302(0x89);
Tiempo-gt;mes = ((tiempo de lecturaamp;0x70)gt ;gt;4)* 10 (readtimeamp; 0x0f);
readtime = r_ds1302(0x8d);
Tiempo-gt; año = ((readtimeamp;0x70)gt;gt; 4)*10 (readtimeamp ;0x0f);
//Convierte el número decimal al valor ASCII que se muestra en la pantalla LCD
Time-gt DateString[0] = Time-gt; ; año/10 '0';
Time-gt; DateString[1] = Time-gt;
Time-gt; -';
Hora-gt;DateString[3] = Hora-gt;mes/10 '0';
Hora-gt;DateString[4] = Hora-gt; mes10 '0';
Hora-gt; DateString[5] = '-';
Hora-gt; DateString[6] = Hora-gt; ';
Tiempo
-gt;DateString[7] = Time-gt;day10 '0';
Time-gt;DateString[8] = '\0';
//Convierte el decimal número Convertir a valor ASCII para pantalla LCD
Time-gt; TimeString[0] = Time-gt hora/10 '0';
Time-gt; = Hora-gt; hora10 '0';
Tiempo-gt; Hora-gt; minuto /10 '0';
Tiempo-gt; TimeString[4] = Tiempo-gt; minuto10 '0';
Tiempo-gt; ' ;
Tiempo-gt; TimeString[6] = Tiempo-gt; segundo/10 '0';
Tiempo-gt; ' 0';
Tiempo-gt; TimeString[8] = '\0';
}
#endif