La humedad del medicamento supera el límite
# incluir ltintrins.h gt
#Definir carácter uchar sin signo
#Definir uint entero sin signo
typedef unsigned char unint8 // unint8 reemplaza el char no especificado para mejorar la portabilidad
typedef unsigned char unint 16;
unsigned char str 1[]= { " " };
Carácter sin firmar str 2[]= { " " };
Código de carácter sin firmar dis 1[]= { " Xh RH: " } // Definir una matriz
Sin firmar código de carácter dis 2[]= { " DO T: " };
sbit buz=p1^0;
sbit TRH = p1^7 //Acceso a datos de temperatura y sensor de humedad DHT11
sbit LCD_RS = p1^1;
sbit LCD_rw = p1^2;
sbit LCD_en = p1^3;
unint8 TH_data, TL_data, RH_data, RL_data, CK_data;
unint8 TH_temp, TL_temp, RH_temp, RL_temp, CK_ temp;
unint8 com_data, untemp, temp
respuesta unint8;
void initcom()
{
TMOD = 0x 20
ésimo 1 = 0x FD <; /p>
TL 1 = 0x FD;
tr 1 = 1;
cualquiera = 1;
SM0 = 0;
sm 1 = 1;
EA = 1;
ES = 1;
}
envío nulo (carácter sin firmar) temperatura)
{
//Enviar Biaozi
SBUF = temp
Y (!TI);
TI = 0;
}
void sendwd()
{
//Enviar texto
uint w_d;
w_d = TH_datos 128;
SBUF = w_d;
Y (! TI);
TI = 0;
}
void envía d()
{
/ /Enviar Du Shi
SBUF = RH_data
Y (!TI);
TI = 0;
} p>
/************************************************ ** *************************************/
anular retraso nop () ///retraso
{
_ nop _();
_ nop _();
_ nop _ () ;
_ nop _();
}
/****************** ** ****
************************************************** * *****/
/************************************ * ********************************************/
//Subrutina de retardo de milisegundos
/********************************* *** ************************************************* */
void delay_ms (entero sin signo milisegundos)
{
Carácter sin signo I;
Cuándo (milisegundos)
{
for(I = 0;ilt150;i)
{
_ nop _();
_ nop _();
_ nop _();
_ nop _();
}
}
}
/*************************************** ********************************************/
/************************************************ * **********************************/
//Programa de retardo tipo 5us< / p>
/********************************************* ***** *************************************/
void delay_us()
{
unidad 8 I;
I-;
I-;
Yo-;
p>
Yo-;
Yo-;
Yo-;
}
/****** **************************************** *********** *************************/
/****** ******************* ********************************** ******************* *************/
//Pruebe el estado de ocupado de la pantalla LCD.
//Cuando //lcd_busy() es 1, ocupado y esperando. Cuando lcd_busy() es 0, está inactivo y se pueden escribir instrucciones y datos.
/****************************************** *****************************************/
bit lcd_busy()
{
Resultado del bit;
LCD_RS = 0;
LCD_RW = 1;
LCD _ EN = 1;
retraso nop();
resultado=(bit)(P0 amp0x 80);
LCD _ EN = 0;
Devolver (resultado);
}
/********************** ** ************************************************* *** *******/
/******************************* *** **********************************************/
//Escribe datos de comando en la pantalla LCD.
/****************************************** ***********************************/
void lcd_wcmd(carácter sin firmar comando)
{
mientras(LCD _ ocupado());
LCD _ RS = 0
LCD _ RW =; 0;
LCD_EN = 0;
_ nop _();
_ nop _();
P0 = cmd
retraso nop();
LCD_EN = 1;
retraso nop();
LCD_EN = 0;
}
/********************************* ******* **************************************/
/*** ******************************************* ******* ************************/
//Escribir datos de visualización en la pantalla LCD.
//RS=nivel alto, RW=nivel bajo, E=pulso alto, D0-D7=datos.
/****************************************** ***********************************/
void lcd_wdata (carácter sin firmar datos )
{
mientras(LCD _ ocupado());
LCD _ RS = 1
LCD _ RW = 0 ;
LCD _ EN = 0;
P0 = dat
retraso nop();
LCD _ EN = 1;
retraso nop();
LCD _ EN = 0;
}
/********* * ************************************************* ** ****************/
/************************ * ************************************************* ** */
//Configuración de inicialización de LCD
/************************** ** ************************************************* /
void lcd_init()
{
retraso _ ms(15);
LCD _ wcmd(0x 38); /16 *2 pantalla, matriz de puntos 5*7, datos de 8 bits
retraso _ ms(5);
LCD _ wcmd(0x 38); p>retraso _ ms(5);
LCD _ wcmd(0x 38
retraso _ ms(5);
LCD _ wcmd(0x0c); );/ /Activa y desactiva el cursor de visualización.
delay _ ms(5);
LCD _ wcmd(0x 06); //Mover el cursor
delay _ ms(5); p >
//LCD _ wcmd(0x 01); //Borrar el contenido de la pantalla LCD. Si la pantalla está demasiado oscura, estas dos frases se pueden eliminar.
//retraso _ ms(5);
}
/****************** ************************************************** * ********/
/********************************* **********************************************/ p>
//Establezca la posición de la pantalla LCD.
/****************************************** ********************************/
void lcd_dis_pos (posición de carácter sin firmar)
{
LCD _ wcmd(pos | 0x 80); //Puntero de datos=80 variable de dirección
}
/* * ************************************************** *************************/
/**************** ** ************************************************* *** **********/
//Detección de señal del transceptor, lectura de datos
/*************** * ************************************************* ** ************/
Recepción de carácter()
{
unint 8 I;
com_data = 0;
for(I = 0;ilt=7;i)
{
responder = 2;
Y ((!TRH) amp; amprespond );
delay _ us();
delay _ us()
delay _ us(); ;
Frecuencia intermedia (TRH)
{
temp = 1;
responder = 2;
while((TRH) amp; amprespond );
}
Otro
temp = 0;
com _ data lt lt= 1;
com_datos | = temp
}
retorno(com_datos);
}
/************************************************ *****************************/
/************ ************************************************** * *******************/
//Subrutina de lectura de humedad
//Alta 8 bits de temperatura == TL_data
>//baja temperatura de 8 bits == TH_data
//alta humedad de 8 bits == RH_data
//baja humedad de 8 bits == RH_data
// Verifique 8 bits = = CK _data
//El programa llamado incluye delay();, Delay_5us();, RECEIVE();
/*** ********************************************** ***** *************************/
void read_TRH()
{
/ /Host desplegable 18ms.
TRH = 0;
retraso _ ms(18);
TRH = 1;
//resistencia pull-up -up //El bus de datos aumenta el retraso del host en 20us.
retraso _ nosotros();
retraso _ nosotros();
retraso _ nosotros()
retraso _ nosotros ( );
//retraso _ nosotros();
//retraso _ nosotros(); retraso _ nosotros(); retraso _ nosotros();
//El host está configurado para ingresar la señal de respuesta del esclavo.
TRH = 1;
//Determina si DHT11 tiene una señal de respuesta de bajo nivel. Si no responde, aparecerá una ventana emergente y la respuesta se agotará.
If (!TRH)
{
respond = 2;
//Determine si DHT11 envía una respuesta de bajo nivel de 80us señal.
Y ((!TRH) amp; amprespond );
respond = 2;
//Determine si el esclavo envía un nivel alto de 80us, si En caso afirmativo, ingresará al estado de recepción de datos.
Y (TRH amp amprespond);
//Estado de recepción de datos
RH_temp = recibir();
RL _ temp = recibir();
TH_temp = recibir();
TL_temp = recibir();
CK_temp = recibir() ;
TRH = 1;
//Verificación de datos
untemp =(RH _ temp RL _ temp TH _ temp TL _ temp
if( untemp==temperatura CK)
{
RH_datos = RH_temp
RL_datos = RL_temp
TH_data = TH_temp
TL_data = TL_temp
CK_data = CK_temp;
}
}
//Parte entera de humedad
str 1[0]=(char)(0x 30 RH _ data/10);
str 1[1]=(char)(0x 30 RH _ data/10);
str 1[1]=(char)(0x 30 RH _ data 10);
str 1[2]= 0x2e; //Punto decimal
//Humedad Parte decimal
str 1[3]=(char) (0x 30 RL _ datos/10);
cadena 1[5]= 0x 25; //"" p>
cadena 1[6]= 0x 52; "
str 1[7]= 0x 48; //"H "
//Temperatura La parte entera
str 2[0]=(char )(0x 30 TH _ datos/10);
cadena 2[1]=(char)(0x 30 TH _ datos 10);
cadena 2[2]= 0x2e ; //Punto decimal
//Parte decimal de la temperatura
str 2[3]=(char )(0x 30 TL _ data/10);
cadena 2[5]= 0x 27; //"'"
cadena 2[6]= 0x 43; // "C "
}
/************************************ *********** *********************************/
//La temperatura y la humedad son adecuadas en invierno y verano.
//Humedad: 30-80 30-60
//Temperatura: 18 ℃-25 ℃, 23 ℃-28 ℃
/*** ************************************************** * ***********************/
Void baoj()//Función de alarma
{ p >
if(RH _ data gt;=80) //Límite superior de humedad 80
{
buz = 0;
retraso _ ms (200);
buz = 1;
retraso _ ms(10);
}
si no (RH _ datos). lt; = 30)//Límite inferior de humedad 30
{
buz = 0;
retraso _ ms(200); >buz = 1;
delay_ms(10);
}
else if(TH_data gt;= 25)//El límite superior de temperatura es 25 ℃
{
buz = 0;
retraso _ ms(200); p> delay_ms(10);
}
else if(TH_data lt;= 18)//límite de temperatura inferior 18℃
{
buz = 0;
retraso _ ms(200);
buz = 1;
retraso _ ms(10);
}
Otro
{
buz = 1;
}
} p >
/********************************************* *** **********************************/
//Función principal
//th, TL, RH, RL representan las partes entera y decimal de temperatura y humedad respectivamente.
/****************************************** ***********************************/
void main() p>
{
LCD _ init();
initcom();
retraso _ us(); while( 1)
{
Carácter sin firmar I, n=0x40, m;
leer _ TRH()
/ / Escribir caracteres
for(I = 0; i lt=7; i)
{
lcd_dis_pos(一); //Mostrar caracteres
>LCD _ wdata(dis 1[I]);
LCD _ dis _ pos(n I); //Mostrar caracteres
LCD _ wdata(dis 2[ I ]);
}
//Escribe datos de humedad
m = 0x08
for(I = 0; Ilt= 7 ; i )
{
LCD _ dis _ pos(m);
LCD _ wdata(cadena 1[I]); p>m;
}
//Escribe datos de temperatura
m = 0x48
for(I = 0; i lt= 7; i )
{
LCD _ dis _ pos(m
LCD _ wdata(cadena 2[I]); p>
m;
}
//Retraso
retraso _ ms(500);
baoj(); //Alarma
Enviar (0x ff); //bandera wsd
//retraso _ ms(10);
enviar wd(); p>
p>
//retraso _ ms(10);
sendsd();
//retraso _ ms(10);
}
}