Proporcione un microcontrolador DS18B289C51 + alarma sonora y luz LED en el programa de alarma de temperatura. Se puede utilizar el lenguaje ensamblador/C, gracias.
El procedimiento es el siguiente
/*************************************** *** *************/
#include "reg51.h"
#include "intrins.h"
#include " math.h"
#define disdata P0 //puerto de salida del código de segmento
#define discan P2 //puerto de escaneo
#define uchar unsigned char
#define uint unsigned int
sbit duqu=P3^6; // puerto de entrada de temperatura
sbit dian=P0^7; Control decimal LED
sbit beep=P1^6; //zumbador
sbit key0=P3^0
sbit key1=P3^1; p>
sbit key02=P3^2;
sbit key03=P3^3;
sbit led0=P1^0; //Luz roja
sbit led1 =P1^1; //luz verde
sbit led2=P1^2; //luz amarilla<
uint h;
uchar r;
char alto=40,bajo=15; /p>
uchar ti;
uchar pp;
uchar ee;
uchar nn;
/*** **** ******* Parte decimal de la temperatura usando el método de tabla de búsqueda************//
uchar code ditab[16]=
{ 0x00,0x01,0x01, 0x02,0x03,0x03,0x04,0x04,0x05,0x06,0x06,0x07,0x08,0x08,0x09,0x09};
//
uchar código dis_7[15]={0x3f,0x06,0x5b,0x4f,0x66, 0x6d,0x7d,0x07,0x7f,0x67,0x00,0x40,0x76,0x38,0x39};
//*** *Lista de códigos de segmento LED Yin "0" "1" "2" "3" "4" "5" "6" "7" "8" "9" "Opaco" "-" "H" "L" " C"
uchar code scan_con[4]={0x70,0xb0,0xd0,0xe0}; //Palabra de control de escaneo de columna
uchar data temp_data[2]= {0x00,0x00 }; //leer temperatura temp
uchar data display[5]={0x00, 0x00,0x00,0x00,0x00} //Mostrar datos de la unidad, ***4 datos y aritmética; puesta en escena
/************************Función de retardo 11us************** ************** /
retraso nulo(uint t)
{
for (;t>0; t--);
}
/****************** Función de escaneo de pantalla******
*********************/
escaneo de vacío()
{
char k ;
for(k=0;k<4;k++) //Control de escaneo LED de 4 bits
{
discan=scan_con[k]; //selección de dígitos
disdata=dis_7[display[k]]; //visualización de datos
if (k==1 ){dian=1;}//visualización de puntos decimales
p>retraso(200);
}
}
}
/**** **** ********Función de reinicio DS18B20************************/
ow_reset(void )
{
char presencia=1;
mientras(presencia)
{
mientras(presencia )
{
duqu=1;_nop_();_nop_(); //desde arriba hacia abajo
duqu=0;
retraso (50); //550 us
duqu=1;
retraso(6); //66 us
presencia=duqu; //presencia= 0 reinicio exitoso, continúa con el siguiente paso
}
delay(45); //retraso 500 us
presence=~duqu; /p>
}
duqu=1; //extraer nivel alto
}
/********** ******* *Función de comando de escritura DS18B20************ ***********/
// Escribe 1 byte en el bus de 1 CABLE
void write_byte(uchar val)
{
uchar i;
for(i=8;i >0;i- -)
{
duqu=1;_nop_();_nop_(); //bajar de mayor a menor
duqu =0;_nop_( );_nop_(); _nop_();_nop_(); //5 us
duqu=val&0x01; delay(6); // 66 us
delay(6).//66 us
val=val/2 // Desplazamiento a la derecha 1 bit
}
duqu=1;
retraso(1);
}
/******** ******** DS18B20 leer función de 1 byte************************/
// Obtener 1 byte desde el bus
uchar read_byte(void)
{
uchar i;
uchar value=0;
for( i=8;i>0;i--)
{
duqu=1;_nop_();_nop_();
valor>>= 1;
duqu=0;_nop_();_nop_();_no
p_();_nop_(); //4 nosotros
duqu=1;_nop_();_nop_( );_nop_();_nop_(); //4 nosotros
if(duqu)value|=0x80;
delay(6); //66 nosotros
}
duqu=1;
return(value);
}
/****************** Leer función de temperatura******* ***** ****************/
uint read_temp()
{
ow_reset( ); //reinicio del bus
retraso(200);
write_byte(0xcc); //Enviar comando
write_byte(0x44); comando
wow_reset();
delay(1);
write_byte(0xcc); //Enviar comando
write_byte(0xbe); );
temp_data[0]=read_byte(); //Lee el primer byte del valor de temperatura
temp_data[1]=read_byte() //Lee la palabra alta. del valor de temperatura Sección
temp=temp_data[1];
temp<<=8;
temp=temp|temp_data[0]; Dos bytes Sintetizan una variable entera.
return temp; // Valor de temperatura de retorno
}
/*************** Procesamiento de datos de temperatura Función ************************/
// La mitad inferior del byte binario alto y la mitad superior del el byte bajo Nibbles forma un byte. Este
//byte se convierte de binario a decimal y es el número de centenas, decenas y dígitos del valor de temperatura. // es bajo La mitad inferior del byte se convierte a decimal, que es la parte decimal del valor de temperatura
/****************** *********** ********************** *******/
work_temp (uint tem)
{
uchar n=0;
nn=0;
if(tem>6348) // valores de temperatura positivos y negativos
{tem=65536-tem;n=1;nn=1 ;}// Complemento de temperatura negativo, posición de marca 1
display[4]=tem&0x0f ; // Parte decimal del valor
p>display[0]=ditab[display[4]] // Almacena la parte decimal del valor mostrado
display[4 ]=tem>& gt;4; // Toma los 8 bits del medio, es decir, la parte entera del valor
display[3]=display[4]/100; dígito
display[1]=display[4]%100 ; // Obtiene los dos últimos dígitos de los datos
display[2]=display [1]/10; / Obtener el almacenamiento de datos de diez dígitos
display[1]=display[ 1]%10;
r=display[1]+display[2]*1display[ 3]*100;
/******** ********** Juicio de visualización de bits de signo**************** ***********/
if(! display[3])
{
display[3]=0; //No mostrar cuando el bit más alto es 0
if(!display[2] )
{
display[2]=0; No mostrar cuando el segundo bit más alto es 0
}
}
if(n){display[3]=0x0b;}//El más alto El bit muestra "-" para indicar temperatura negativa
}
/***** ************* Función de alarma sonora**** * *********************/
anular BEEP()
{
si (r>=alto||r<=bajo)
{
pitido =1;led1=1;
if(r>=alto)<
{
led0=0; led2=1;
}
si no (r<=bajo)
{
led2=0;led0=1;
}
}
}
else if ((nn==1)& ;&(r>=abs(low)))
{
led2=0;led0=1;beep=1;led1 =1;
}
else
{
bip=0;led1=0;led0=1;led2=1;
}
}
/****************** Función de inicialización********************** ****/
void init()
{
beep=0;
EA=1;
EX0=0;
EX1=0;
IT0=1;
IT1=1;
TMOD=0x11 ;
TH0=(65536-10000)/256;
TL0=(65536-10000)%256;
TH1 = (65536-833)/ 256;
TL1=(65536-833)%256;
signo=0;
ti=alto;
}
/****************** Interruptor de ajuste de temperatura/arriba y abajo***************** ** **** *******/
void key11()
{
mientras(key1==0)
{
retraso(300);
if(key1==0)
{
st++;
si (st== 4)
st=1;
}
mientras(!key1);
retraso(300);
mientras(!key1);
}
}
/*************** *********** * Límites superior e inferior de ajuste del interruptor******************************
anular tecla10()
{
mientras(clave0==0)
{
retraso(300) ; //dejitter
if(key0==0 )
{
signo=! firmar;
}
mientras(!key0);
retraso(300);
mientras(!key0);
p>
}
}
/****************** ***** Añadir 1 a los límites superior e inferior ****** ********************/
void key2()
{
mientras(clave02 ==0)
{
retraso(400);
si(clave02==0)
{
si(signo)
{ bajo=bajo+1;
si(bajo>alto)
{pp=bajo; bajo=alto;alto=pp;}
}
else
{alto= 1** ************ *************/
void key3()
{
mientras(key03==0)
{
retraso(400);
if(key03==0)
{
if(signo)
bajo=bajo-1;
else
{ alto=alto-1;ti=alto;
if(bajo>alto )
{pp=bajo;bajo=alto;alto=pp;}
}
}
mientras(!key03) ;
retraso(400);
>
mientras(!key03);
}
}
/****************** ** ** Visualización de temperatura límite superior************ *******************/
void high1()
{
uchar k;
if(high<100)
{ display[0]=high%10;
display[ 1]=alto/10;
display[2]=10;
display[3]=12;
para (k=0;k< 4;k++)
{
discan=scan_con[k]
disdata=dis_7[display [k]];
if (k==1){dian=0;}
retraso(300);
disdata=0x00;
retraso(100);
p>}
}
else
{
mostrar[0] =alto%10;
display[1]=high%100/10;
display[2]=high/100;
display[3] =12;
for(k=0;k<4;k++)
{
discan=scan_con[k]; >disdata=dis_7[display[k] ]
if (k==1){dian=0;}
retraso(300);
disdata=0x00;
retraso(100);
}
}
}
/** ********** ******* Bajar el indicador de temperatura****************************** */
void low1()
{
uchar ki;
if(low>=0)
{ mostrar[0]=bajo%10;
mostrar[1]=bajo/10;
mostrar[2]=10;
mostrar [3]=13;
for( ki=0;ki<4;ki++)
{
discan=scan_con[ki]; >
disdata=dis_7[display[ki]];
if (ki==1){dian=0;}
retraso( 100);
disdata=0x00;
retraso (100);
}
}
else
{
ee=abs(bajo);
display[0]=ee%10;
display[1]=ee/10;
display[2]=11;
display[3]=13;
for(ki=0;ki<4;ki++)
{
discan=scan_con[ki]
disdata=dis_7[display[ki]]
if (ki==1){dian= 0;}
retraso(100);
disdata=0x00;
es
poner(100);
}
}
}
/*************** ***** *** función principal *************************/
void main()
{
init();
disdata=0x00; //inicializar puerto
discan=0x00; h=0;h <4;h++) //arranque mostrar "0000"
{display[h]=0;}
ow_reset(); //arranque convertir una vez
write_byte(0xcc); /Saltar ROM
write_byte(0x44); /Enviar comando de conversión
for(h=0;h<100;h++) / /Inicia y muestra "0000" "
{scan();}
while(1)
{
switch( st) //rama
{
caso 1:{
work_temp(read_temp());
scan(); /mostrar temperatura
BEEP();
pausa;
}
caso 2: {
high1(); / Muestra la temperatura límite superior
key10();
key2();
key3();
break;
}
caso 3: {
low1();
Muestra la temperatura límite inferior
key10 () ;
tecla2();
tecla3();
romper;
}
}
clave11();
}
}
//****************** ************ fin **** * **********************//