¿Quién puede ayudarme a escribir un programa para la colección de temperatura y humedad STH10 de la pantalla 1602 de STC89C52 escrito usando una microcomputadora de un solo chip? Definitivamente lo recompensaré con puntajes altos.
# include & ltmath.h & gt
#include "avrlcd3.1.c" //Este es un lcd escrito por mí Función de visualización.
//= = = Definición de macro = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
# define DATOS_1 PORTA | = 0x 01
#define portal data_0 & amp=0XFE
#define puerta SCK_1|= 0X02
#Definir portal SCK_0&=0XFD
#Definir entrada de conjunto de datos DDRA&= 0XFEPORTA|=0X01
#Definir salida de conjunto de datos DDRA|=0X01
# Definir DDRA de entrada SCK_set &= 0XFDPORTA|=0X02
#Definir DDRA de entrada SCK_set|=0X02
#Definir data_at (PINA & 0X01)
# Definir noACK 0
#Definir confirmación 1
//comando adr lectura/escritura
p># definir ESTADO _ REG _ W 0x 06//000 0011 0
# define ESTADO _ REG _ R 0x 07//000 0011 1
# define MEDIDA _ TEMP 0x 03//000 0001 1
#Define medición_ HUMI 0x 05//000 0010 1
#Definir reinicio 0x 1e//000 1111 0
#Definir temperatura 0
#Definir HUMI 1
//= = = =Declaración de función= = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = >
void delay _ ms(int t);
void s _ trans start( void);
char s_write_byte (valor de carácter sin firmar); //Escribe un comando de un byte para verificar si el sensor recibe estos datos correctamente. Un valor de retorno de 0 indica una recepción correcta.
char s_read_byte (unsigned char ack); //Lee un byte de datos y envía una señal "recibida" de un byte al sensor.
int s_measure(modo char sin firmar); //Medir.
void calc_sth 11(float * p _humidity, float * p _temperature); //Corrección del resultado de la medición
// - Función principal.
Gerente general no válido (inválido)
{
Temperatura flotante, Mihu;
mientras(1)
{
TEMP = s _ medida(TEMP);
Mihu = s _ medida(HUMI
calc _ algo 11(& amp; Mihu&temp); );
printf("t=%f C\nh=%f % ", temp, Mihu); //Envía los resultados de la prueba a la pantalla LCD,
// Esta función fue escrita por mí y usa una pantalla LCD, no la que está en stdio.h
delay _ ms(2000);
}
}
//= = = = Definición de función = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = =
//*********************************
//Retraso para unos milisegundos
//************************************ *
Delay_ms(int t) no válido
{
int i,j;
for(I = 0; i & ltt;i++ )
for(j = 0;j & lt1141;j++);
}
//******** **** **********************
//Pequeña demora
//******** ** ********************
void delay_little(no válido)
{
ASM(" nop");
ASM("nop");
ASM("nop");
ASM("nop");
ASM("nop");
ASM("nop");
}
//***** **** ***********************************
//Iniciar transmisión
//****************************************** **** **
void s_transstart(void)
{
DATA _ SETOUTPUT
SCK _ SETOUTPUT;
DATA_1;
SCK_0;
delay_little().
SCK_1;
delay_little().
DATA_0;
delay_little().
SCK_0;
delay_little().
SCK_1;
delay_little().
DATOS_1;
delay_little().
SCK_0;
}
//************************ **********
//Escribe un comando de un byte para comprobar si el sensor recibe los datos correctamente. Un valor de retorno de 0 indica una recepción correcta.
//******************************
char s_write_byte( Sin firmar valor de carácter)
{
Carácter sin firmar I;
Error de carácter;
DATA _ SETOUTPUT
SCK_SETOUTPUT ;
SCK_0;
DATA_0;
for(I = 0;I<8;I++) //Envía datos de 8 bits, el clúster lee los datos en el borde ascendente.
{
SCK_0;
if (valor&(0x80>>i))
DATA_1
Otro
p>DATOS_0;
delay_little().
SCK_1;
delay_little().
}
SCK_0; //Leer la señal "recibida" enviada por el esclavo en el siguiente flanco ascendente.
DATA_SETINPUT
delay_little().
SCK_1;
delay_little().
Error = (DATA_IN?1:0);
delay_little().
SCK_0;
DATA_SETOUTPUT
Error de retorno;
}
//** **** **************************************
/ /Lee un byte de datos y envía una señal "recibida" de un byte al sensor.
//****************************************** ***
char s_read_byte (carácter sin firmar)
{
Carbón sin firmar i, val = 0;
DATA _ SETINPUT
//SCK _ SETOUTPUT;
SCK _ 0;
for(I = 0x 80;i>0;I>>=1 ) //Recibir 8 bits datos.
{
SCK_1;
delay_little().
if (entrada de datos)
val =(val | I); //Leer bit
SCK_0;
delay_little() .
}
Si (Confirmar)
DATA_1;
Otro
DATA_0;
DATA _ SETOUTPUT//Envía un bit de confirmación (0) para indicar si se han recibido datos.
delay_little().
SCK_1;
delay_little().
Valor de retorno
}
//************************ ***************************
//Cálculo y corrección de temperatura y humedad
//************************************************
void calc _ sth 11(float * p _humidity, float * p _temperature)
{
const float c 1 =-4.0; bits
const float C2 =+0.0405; //Para 12 bits
Const float C3 =-0.0000028 //Para 12 bits
const float t 1 =+0.01; //para 14 bits @ 5V
Const float t2 =+0.00008; //para 14 bits @ 5V
float rh = * p _humidity; : humedad [escala] 12 bits
float t = * p _ temperatura// t: temperatura [escala] 14 bits
float rh _ lin// rh_lin: Humedad lineal
float rh _ true// rh_true: Humedad compensada por temperatura
Float t_C; // t_C: Temperatura
t_C = t * 0.01-40; Temperatura de la garrapata
RH _ Lin = C3 * RH * RH+C2 * RH+c 1 //calc. Humedad desde tick hasta [%RH]
RH_true =(t_C-25)*(t1+T2*RH)+RH_Lin; //calc. Humedad compensada por temperatura [%RH]
if(RH_true>100)RH_true = 100; //Recorta si el valor está fuera del rango
if (RH_true <0.1)RH_true = 0.1; //Rango físicamente posible
* p_temperature = t_C; //Temperatura de retorno
* p_ Humedad = rh _ true//Humedad de retorno [%RH]
}
//****************************************** **********
//Utilice la suma de comprobación para la medición (humedad/temperatura)
//Mida la temperatura/humedad una vez, no se requiere verificación.
//Parámetros: 0 representa temperatura, 1 representa humedad.
//****************************************** *********
int s_measure (modo de carácter sin firmar)
{
Carácter sin firmar a, b;
s _ trans start(); //Iniciar transmisión
Switch(mode) //Enviar el comando de inicio de medición.
{
Caso 0: s _ escribir _ byte(MEASURE _ TEMP roto;
Caso 1: s _ escribir _ byte(MEASURE _ HUMI); ); romper;
Predeterminado: romper
}
DATA _ SETINPUT
mientras(DATA _ IN); detección completa
//Leer dos bytes de datos
a = s _ read _ byte(0
b = s _ read _ byte (1); );
return((int)a)& lt;& lt8)+b;
}