Cómo programar la recopilación de temperatura en tiempo real
# incluir & ltmath.h & gt//biblioteca Keil
# incluir & ltstdio.h & gt//biblioteca Keil
#include<INTRINS. H & gt
#Definir carácter uchar sin signo
#Definir uint entero sin signo
#Definir visualización de izquierda a derecha 1 0x Fe//Nigital tube 1
#Definir pantalla 2 0x FD//Tubo digital 2 de izquierda a derecha
#Definir pantalla 3 0x FB//Tubo digital 3 de izquierda a derecha
#Definir visualización 4 0xf 7//Tubo digital 4 de izquierda a derecha
#Definir visualización 5 0x ef//Tubo digital 5 de izquierda a derecha
#Definir visualización 6 0x df //Tubo digital 6 de izquierda a derecha
#Definir visualización 7 0x BF//Tubo digital 7 de izquierda a derecha
#Definir visualización 80x7f//Tubo digital 8 de izquierda a right
sbit led=p1^5;
sbit dq=p3^6;//Configurar según la situación real
sbit setth=p1^0; //Configurar el
sbit up=p1^1; //Agregar
sbit down=p3^2; //Signo menos
sbit beep = p3 ^3;
uchar tempint, f, bb, tempth, temptl, th, tl, beepflag//La parte entera y decimal de la temperatura
int tempdf, c;
p>código sin firmar char ledmap[]={0xc0, 0xf9, 0xa4, 0xb0, 0x99,
0x92, 0x82, 0xf8, 0x80, 0x90, 0x BF};
código de mapa LED de caracteres sin firmar 1[]= {0x 40, 0x79, 0x24, 0x30,
0x19, 0x12, 0x02, 0x78, 0x00, 0x 10};
// Tubo digital de 7 segmentos 0 ~ 9 dígitos * * *Código de visualización positivo y código de dígito negativo (último dígito)
void set _ ds 18b 20() //Inicializa la subrutina DS18B20.
void get _ Temperature(); //Obtener la subrutina de temperatura
void read _ ds 18b 20() //Leer la subrutina DS18B20
void write_ds18b20 (comando uchar); //Escribe una subrutina de 1 byte en DS18B20.
void delay(uchar count); //retraso en la subrutina de conteo de milisegundos
void disp_temp(tempint, tempdf); //muestra la subrutina de temperatura
/ * * * * * * * * * * * * * * * * * * * * * * * *Inicializar subrutina DS18B20* * * * * * * * * * * * * * * * * * * * * *
//****************************************** *** ********************************
void set_ds18b20()
{
mientras(1)
{
uchar retraso, bandera;
bandera = 0;
DQ = 1;
Delay = 1;
while(-delay);
DQ = 0;
Retraso = 250;
while(-delay); //Mantiene el nivel bajo durante 500us.
DQ = 1; //La línea de datos está configurada en nivel alto.
Retraso = 30;
while(-delay); //Mantiene el nivel alto durante 60us.
While(DQ==0) //Determina si DS18B20 envía una señal de bajo nivel.
{
Retraso = 210; //DS18B20 responde con un retraso de 420us.
while(-delay);
If(DQ) //DS18B20 envía con éxito una inicialización de alto nivel y regresa.
{
flag = 1; //Indicador de éxito de inicialización DS18B20
//Indicador LED de éxito de inicialización
Break;
}
}
Si (flag) // La inicialización es exitosa, luego retrasa 480us, requisitos de tiempo.
{
Retraso = 240
mientras(-retraso);
Descanso
}
}
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//****************** ****** ********************************************** ******* *********
Void get_temperature() //Subrutina de conversión de temperatura y adquisición de temperatura
{
set _ ds 18b 20( ); //Inicializar DS18B20
write _ ds 18b 20 (0x cc); //Enviar comando para omitir la coincidencia de ROM.
escribir _ ds 18b 20 (0x 44); //Enviar comando de conversión de temperatura
//retraso ms(750);
disp_temp(tempint, tempdf ); //Muestra la temperatura y espera la conversión de AD.
set_ds 18b 20();
write_ds 18b 20(0x cc); //Enviar comando para omitir la coincidencia de ROM.
write_ds 18b 20(0x be); //Emitir un comando de lectura de temperatura.
read_ds 18b 20(); //Guarda los datos de temperatura leídos en tempint y tempdf.
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//********************************* ***** **********************************************
void read_ds18b20()
{
uchar retraso, I, j, k, temp, temph, templ
j = 4 ; // leer datos de bytes de 2 bits
do
{
for(I = 8;I>0;I-)//Leer una palabra con 8 Festival de bits.
{
temp & gt& gt=1; //Leer 1 bit y desplazarse 1 bit a la derecha.
DQ = 0; //La línea de datos está configurada en nivel bajo.
Delay = 1;
while(-delay);
DQ = 1; //La línea de datos está configurada en nivel alto.
Retraso = 4;
while(-delay); //Retraso 8us
If(DQ) //Leer datos de 1 bit.
temp | = 0x80
Retraso = 25; //Retraso 50us después de leer datos de 1 bit.
while(-delay);
}
If (j==4)
templ = temp//leer El primero El byte se almacena en temp.
If (j==3)
temph = temp//El segundo byte leído se almacena en temph.
Si (j==2)
tempth = temp//El tercer byte leído almacena el valor de tempth.
Si (j==1)
temptl = temp//La lectura del cuarto byte almacena el valor de tempth TL.
} while(-j);
f = 0;
if ((temph & amp0xf8)!=0x00) //Si la temperatura es negativa Luego maneje el complemento a dos.
{
f = 1; //La temperatura negativa f se establece en 1.
temph = ~ temp
templ = ~ temp
k = templ+1
templ = k
;if(k & gt; 255)
{
temph++;
}
}
tempdf = templ & amp0x0f//Convierte los datos leídos en un valor de temperatura. La parte entera se almacena en tempint y la parte decimal se almacena en tempdf.
c =(temppdf * 625);
temppdf = c
templ & gt& gt=4;//
temph; & lt& lt=4;//Convertir a temperatura de byte
tempint = temph | templ//Dos bytes se combinan en un byte.
if(tempint & gt;th | tempint = = th | tempint & lttl|tempint==tl)
beepflag = 1;
Otro
p>
beepflag = 0;
}
/* * * * * * * * * * * * * * * * * * * * * * Escribir programa de subrutina DS18B20* * * * * * * * * * * * * * * * * * * * * *
//************* ***** ********************************************** ****** ********
void write_ds18b20 (comando uchar)
{
Uchar demora, yo;
for(I = 8;I>0;I-)//Escribe un byte de datos bit a bit.
{
DQ = 0; //La línea de datos está configurada en nivel bajo.
Retraso = 6; //Retraso 12us
while(-delay);
DQ = Comando y Control 0x 01; la línea de datos
Retraso = 25; //Retraso 50us
mientras(-delay);
comando = comando & gt& gt1; Siguiente bit de datos
DQ = 1; //Después de enviar un bit de datos, la línea de datos se establece en nivel alto.
}
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
//****************** ************************************************** * ********
void disp_temp( tempint, tempdf)
{
Uchar tempint, tempint, tempdf Tempin Bai = th/100 ;
if (bb==1)
{
tempin Bai = th/100;
tempint =(th % 100 )/10;
temp intl = th % 10; //Módulo entero
flecha = 0/1000;
Diez = 0% 1000/100;
Cientos = 0% 100/10;
Miles = 0% 10; // Módulo decimal
}
else if( bb = = 2)
{ tempin Bai = TL/100;
tempinth =(TL % 100)/ 10;
temp intl = TL % 10 ; //módulo entero
flecha = 0/1000;
diez = 0% 1000/100;
p>
Porcentaje = 0% 100 /10;
Milésimo = 0% 10; // Módulo decimal
}
Otros
{
tempin Bai = tempint/100;
tempint =(tempint % 100)/10;
temp intl = tempint % 10; //Módulo entero
flecha = tempdf/1000;
shifen = tempdf % 1000/100;
baifen = tempdf % 100/10;
qianfen = tempdf % 10; /Módulo decimal
}
Si (f==0)
{
P0 = visualización 1 //Bit de signo
P2 = mapa led[0];
}
Otros
{
P0 = display 1; //Bit de señal
P2 = mapa led[10];
}
Dai Lai Mus(2);
P0 = display2
P2 = mapa led[tempin Bai]; //Abrir cien lugares
Dalems (2)
P0 = display
P2 = mapa LED[tempint]; //abre diez asientos
Daremus (2);
P0 = display4
P2 = mapa LED 1[temp intl]; //Abre el asiento
Dalems(2);
P0 = display5
P2 = mapa LED[arrowroot]; Abrir una posición
Dalems(2);
P0 = display6
P2 = led map[shifen] //abrir durante diez minutos
Daremus(2);
P0 = mostrar7
<p>P2 = mapa LED[porcentaje]; //percentil abierto
Dalems(2);
P0 = display8
P2 = mapa LED[qianfen] ;//Abrir una milésima
}
//****************** ********* **************************************/
// *Suena el zumbador*/
//****************************** ******** ********************************/
void beep_st()
{
if (beepflag==1)
{ pitido = 0;
retrasos(1000); = 1;
}
Otro
Bip = 1;
}
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
/ /****************************************** ******* ***********************************
retraso nulo ms(recuento de uchar)/ /Subrutina ms de conteo retrasado
{
uchar i, j;
Do
{
for( I = 5;I>0;I-)
for(j = 98;j>0;j-);
} while(-count);
//************************************ ***** **************************************
void keycan()/ /Escaneo de teclado
{
Si (configuración==0)
{
retraso ms(1) ;
}
Si (set == 0)
{
b b++;
Y (! setth); /El bucle aquí no es 0=1.
}
si(bb==1)
{
si(arriba==0)
{
retraso ms(1);
}
if(up==0)
{
disp_temp(th, tempdf);
if(th<125)
{ th++;}
Y (!Up)//no es 0 =1
{
disp_temp(th, tempdf);
}
}
if( abajo ==0)
{
retraso ms(1);
}
if(abajo==0)
{
disp_temp(th, tempdf);
Verdadero si (th!=0) //no es igual a 0.
{
th-;
Y (!Down)//Down se usa (no 0=1) para la ejecución del bucle.
{
disp_temp(th, tempdf);
}
}
}
}
si (bb==2)
{
si (arriba==0)
{
retraso ms(1);
}
if(up==0)
{
disp_temp( tl, tempdf);
si (TL & lt;125)
{ tl++;}
Y (!Up)//no 0=1
{
disp_temp(th, tempdf);
}
}
if(abajo== 0 )
{
retraso ms(1);
}
if(abajo==0)
{
disp_temp(th, tempdf);
Verdadero si (tl!=0) //no es igual a 0.
{
TL-;
Y (!Down)//Down se usa (no 0=1) para la ejecución del bucle.
{
disp_temp(tl, tempdf);
}
}
}
}
Si (bb==3)
{ bb = 0;
set _ ds 18b 20() //Inicializar DS18B20<; /p>
write_ds 18b 20(0x cc); //Enviar comando para omitir la coincidencia de ROM.
escribir _ ds 18b 20(0x4e); //Enviar comando de conversión de temperatura
escribir _ ds 18b 20(th); //Escribir TH 3
escribir _ ds 18b 20(TL);
//escribir _ ds 18b 20(0x7f);
set _ ds 18b 20() //Inicializar DS18B20
write_ds 18b 20(0x cc); //Enviar comando para omitir la coincidencia de ROM.
escribir _ ds 18b 20 (0x 48
}
}
void main()
write _ ds 18b 20(0x cc); //Enviar comando para omitir la coincidencia de ROM.
write_ds 18b 20(0x be); //Emitir un comando de lectura de temperatura.
read _ ds 18b 20(); //Datos a leer
th = tempth//Leer TH a MCU
tl = temptl
SP = 0x60//Establecer puntero de pila
bb = 0;
beepflag = 0
while(1)
;p>
{
key scan();
get_temperature();//Obtener la temperatura
disp_temp(tempint, tempdf) ;/ /Mostrar temperatura
beep_ST();
}
}