Red de conocimiento informático - Conocimiento sistemático - Cómo programar la recopilación de temperatura en tiempo real

Cómo programar la recopilación de temperatura en tiempo real

# incluir & ltreg52.h & gt

# 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()

{ 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(); //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();

}

}