¿Por qué no puedo medir la temperatura con el programa DS18B02? Escrito en lenguaje C, utilizando 51 microcontroladores.
# include & ltreg52.h & gt
# include & ltstdio.h & gt
#Definir carácter uchar sin firmar
#Definir uint entero sin signo
sbit ds=p1^7; // Línea de señal del sensor de temperatura
sbit a1=p1^0; p>
sbit a2=p1^1; //cientos
sbit a3=p1^2;//diez
sbit a4=p1^3;// Cada uno
sbit a5=p1^4; //Control de selección de segmentos
sbit d =p0^2; //Punto decimal
sbit sound=p3^ 3; //Definir los pines del microcontrolador que controlan el zumbador.
Temperatura unitaria, t, I, b, xs;
Char yima sin firmar[]={0xeb, 0x88, 0xb3, 0xba, 0xd8, 0x7a, 0x7b, 0xa8, 0xfb, 0x fa };
retrasos nulos (unsigned int I); /*función de retardo*/
//************** ** ************************************************* * *****************
//Función de retardo, para un reloj de 12MHz, como z=10, el retardo es de aproximadamente 10 ms.
Retraso no válido (unidad z)
{
uint x, y;
for(x = z; x & gt0;x -) ;
for(y = 124; y & gt0;y-);
}
//********* *** ********************************************** ** **********************
//****************** ** ************************************************* * ***************
//Inicializar DS18B20
//Dejar que DS18B20 baje durante un tiempo relativamente largo y luego suba durante En un tiempo más corto, se puede iniciar.
void dsreset(void)
{//Para el reloj de 11,0592 MHz, ¿la relación de tiempo de una operación i++? Nosotros
uint I;
ds = 0;
I = 103; // El menú desplegable es de aproximadamente 800 us, que es más de los 480 us requeridos. por el protocolo.
while(I & gt; 0)I-;
ds = 1; // Genera un flanco ascendente y entra en estado de espera.
I = 4;
mientras(I & gt; 0)I-;
}
//**** ************************************************** * *******************************
//********** ****** ********************************************** ******* *******************
//Leer un bit de datos de DS18B20.
//Lea un poco, deje que DS18B20 baje primero durante un ciclo y luego suba durante dos ciclos.
//Luego, DS18B20 generará un bit de datos durante un período de tiempo.
bit tempreadbit(void)
{
uint I
bit dat
ds = 0;
i++; //i++ actúa como un retraso, con un retraso de aproximadamente 8us, que cumple con los requisitos del protocolo y permanece al menos 1us.
ds = 1;
i++; i++; // El retraso es de aproximadamente 16 us, al menos 15 us cumple con los requisitos del protocolo.
dat = ds
I = 8;
while(I & gt; 0)I- // El retraso es de aproximadamente 64 us, lo que cumple con el franja horaria de lectura El requisito no es inferior a 60us.
return(dat);
}
//********************* *** ************************************************* ****************
//************************ ****** ********************************************** ******* **
//Lee un byte de datos llamando a tempreadbit().
uchar tempread(vacío)
{
uchar i, j, dat
dat = 0
{
j = tempreadbit();
dat =(j & lt; <7) |(dat>>1);// El bit más bajo de los datos leídos está al frente, por lo que solo hay un byte en dat.
}
return(dat);
}
//************** ***** ********************************************** ****** *******************
//****************** ******** ******************************************* ********* **********
//Escribe un byte de datos en DS18B20.
void tempwritebyte(uchar dat)
{
uint I
uchar j
bit testb;
for(j = 1;j & lt=8;j++)
{
dat & amp0x 01;
dat = dat & gt& gt1;
If(testb) //Escribe "1", baja ds durante 15us y luego levanta ds entre 15us ~ 60us, es decir, escribe 1.
{
ds = 0;
i++; i++; // El menú desplegable es de aproximadamente 16us y se requiere que el símbolo esté dentro de 15~ 60 nosotros.
ds = 1;
I = 8; while(I & gt; 0)I-; // El retraso es de aproximadamente 64 us, lo que cumple con el requisito del intervalo de tiempo de escritura. No es menos de 60us.
}
De lo contrario //Escriba "0" para reducir ds entre 60us ~ 120 us.
{
ds = 0;
I = 8; while (I & gt; 0)I- // El menú desplegable es de aproximadamente 64us. , requisitos de símbolos.
ds = 1;
i++; i++; // Todo el proceso de escritura 0 ha superado los 60us, por lo que no es necesario retrasar 64us como escribir 1.
}
}
}
//****************** ***** ********************************************** ****** ****************
//********************* ******** ******************************************* ********* ******
//Enviar comando de conversión de temperatura a DS18B20.
Cambio de temperatura no válido (no válido)
{
dsreset(); //Inicializa DS18B20. No importa cuál sea el comando, inicialícelo primero.
Retraso (1); //Retraso 1 ms, porque DS18B20 bajará ds 60~240us como señal de respuesta.
tempwritebyte(0x cc); //Escribe el comando de ROM de omisión de lectura
tempwritebyte(0x 44); //Escribe el comando de conversión de temperatura
}
//******************************************* * **************************************
//** * ************************************************** ****************************
//Envíe un comando de lectura de datos a DS18B20 para obtener el valor de temperatura actual .
uint tmp()
{
TT flotante
//int TT
uchar bajo; , alto;
dsreset();
Delay (1);
tempwritebyte(0x cc); //Escribe la palabra de comando de omisión de número de secuencia
tempwritebyte(0x be); //Escribe la palabra de comando de lectura de datos para leer el almacenamiento temporal
//Lee dos bytes de datos continuamente.
low = tempread(); //Leer los 8 bits bajos
high = tempread(); //Leer los 8 bits altos
temp = high ; //Los 8 bits altos son para temperatura.
temp & lt& lt=8;//Los bytes altos y bajos se combinan en una variable plástica, la temperatura es de 16 bits, los 8 bits altos se desplazan a la izquierda y los 8 bits bajos se llenan con 0 .
temp = temp | low//Fase alta y baja de 8 bits o =temp es 16 bits = alta 8 + baja 8 bits.
xs = low&0x0f//Los 4 dígitos inferiores son la parte decimal.
TT = temp>& gt4;//Parte entera
//temp = TT * 10xs * 100/16;
temp = TT * 1((((xs * 5))& gt;& gt2)+1)>& gt1);
// *************** ** **********************
//y =(((x * 5)& gt; & gt2)+1 )> & gt1;
//Equivalente a y =((x * 5)/4+1)/2;
//Reequivalente a y =((x * 20 )/16+1)/2;
//y = 2 *(x * 10/16+0.5)/2;
//En realidad y = x * 10/ 16+0,5; //+0,5 se redondea.
// ******************************************* ** *****
//TT = temp * 0.0625; //La resolución predeterminada de DS18B20 es de 12 bits y la precisión es de 0,0625 grados, es decir, el bit más bajo de los datos de lectura. representa 0,0625 grados.
//temp = TT * 10(temp & gt; 0 ?0.5 : -0.5);//Si es mayor que 0, suma 0.5, si es menor que 0, menos 0.5
//temp = TT * 100; // Ampliar 100 veces, para que se puedan mostrar dos decimales (t=11,0625, temperatura calculada = 1106, que es 11,06 grados).
Devuelve la temperatura; //temp es un número entero
}
//**************** ****** ********************************************** ******* ****************
//********************* ********* ******************************************* ********** ******
//Función de visualización
Pantalla en blanco
{
Unsigned char a1=0, a2= 0, a3=0, a4 = 0; //Variable temporal
Estática int k = 0;
a 1 = t/1000; //Toma miles de t//
a2 = t % 1000/100; //Toma una centésima de t//
a3 = t % 100/10; el décimo dígito de t//
a4 = t % 10; //Toma la unidad de t//
if(k = = 0){ a 1 = 1; = 0; a3 = 0; a4 = 0; P0 = Yima[a 1];}
si(k = = 1){ a 1 = 0; = 0; P0 = Yima[a2 ];}
si no (k = = 2){ a 1 = 0; a2 = 0; a4 = 0; ;}
else if(k = = 3){ a 1 = 0; a2 = 0; a3 = 0; P0 = Yima[a4];}
k++;
si(k & gt; 3)k = 0
}
//************ ******** ******************************************* ********* ************
Principal()
{
/* TMOD = 0x 01;
TH0 =(65536-2000)/256;
TL0 =(65536-2000)% 256;
EA = 1;
TR0 = 1;
ET0 = 1;*/
mientras(1)
{
cambio de temperatura (); //Iniciar conversión de temperatura
//Hay un retraso después de iniciar la conversión de temperatura, aproximadamente 750 ms.
for(I = 0;I<40;I++) //Mostrar 5 veces (los primeros 3 dígitos del tubo digital son muy oscuros y no hay for) o se cambia la función de visualización para interrumpir la escritura.
{
Pantalla(t);
Retraso(1);
}
t = tmp; ();
}
}
/*
La interrupción 1 nula t0() utiliza 1//el programa de interrupción es responsable de valor de visualización de t.
{
Carbón sin signo a1=0, a2=0, a3=0, a4 = 0; //Variable temporal
Estático int k = 0;
TH0 =(65536-2000)/256;
TL0 =(65536-2000)% 256;
a 1 = t/1000;/ / Toma mil t//
a2 = t % 1000/100 //Toma una centésima de t//
a3 = t % 100/10; dígito de t//
a4 = t % 10 //Toma la unidad de t//
if(k = = 0){ a 1 = a2 = 0; ; a3 = 0; a4 = 0; P0 = Yima[a4];}
si(k = = 1){ a 1 = 0; a3 = 0; P0 = Yima[a3];}
else if(k = = 2){ a 1 = 0; a2 = 0; a3 = 1; a4 = 0; /p>
else if(k = = 3){ a 1 = 0; a2 = 0; a3 = 0; P0 = un caballo [a 1]; ;
if(k & gt; 3)k = 0;
//TH0 = 240;//Velocidad de escaneo
} */