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;

}

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

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);

}

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

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

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

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 "

}