¿Qué experto tiene el código fuente de una alarma de temperatura diseñada con 1602LCD y DS18B20 en el diseño integral de 100 cursos de programación en lenguaje C de microcomputadoras de un solo chip?
Archivo:DS18B20. C
Entorno: compilado en ICC AVR6.31A, simulado en AVR Studio4.10.
Hardware: chip ATMEGA16.
Fecha: 8 de agosto de 2008
/****************************** * ***************/
# include//Incluye archivos de encabezado del modelo.
# include//Contiene archivos de encabezado para operaciones de "bits".
# include//Archivo de encabezado de entrada/salida estándar
# include//Archivo de encabezado que contiene constantes personalizadas
# include " SMG . c "/ /Contiene La función de visualización del tubo digital.
/****************************************** *
Nombre de función: B20_init
Función: Restablecer DS18B20
Parámetros: Ninguno
Valor de retorno: Ninguno
/************************************************/
void B20_init(invalid)
{
DDRA | = BIT(ds 18b 20); //Configurado como salida
PORTA & amp= ~ BIT(ds 18b 20); //Desplegar
Drayus(600); //Esperar 600 microsegundos
PORTA | = BIT(ds 18b 20);/ /liberar bus
drayos(60); //esperar 60 microsegundos
ddra&=~bit(ds 18b 20); //configurado como entrada
And ((PINA &(BIT(ds 18b 20)));//Espera a que DS18B20 baje.
And(!(PINA&(BIT(ds 18b 20))); / /Esperar a que DS18B20 suelte el bus
}
/***********************. ********************
Nombre de función: B20_readB
Función: Leer un byte de datos
.Parámetros: Ninguno
Valor de retorno: retd: devuelve un byte de datos
/*********** ******. *************************/
uchar B20_readB(void)
{
uchar i, retd = 0;
for(I = 0;i<8;i++)//valor de recuento de bits
{
retd & gt& gt=1; //Mover hacia la derecha, listo para aceptar nuevos bits de datos
DDRA | = BIT(ds 18b 20); //Configurado como salida
PORTA & amp= ~ BIT(ds 18b 20); // Tira hacia abajo para comenzar a leer bits de datos
PORTA | = BIT(ds 18b 20); // Libera el bus
drayos(5) ; //Esperar 5 microsegundos
DDRA&= ~BIT(ds 18b 20); //Configurar como entrada y comenzar a leer bits de datos.
If (PINA & bit(ds 18b 20))//¿Este bit es alto?
{
retd | = 0x80 //Sí, establezca este bit en alto.
}
Drayus(50); //Esperar 50 microsegundos
}
Volver a retd //Volver a leer Bytes tomado.
}
/************************************ *********
Nombre de la función: B20_writeB
Función: escribe un byte de datos.
Parámetros: wrd - los datos que se van a escribir.
Valor de retorno: Ninguno
/********************************* *** *************/
void B20_writeB(uchar wrd)
{
Uchar I;
for(I = 0;i<8;i++)//Valor de recuento de bits
{
DDRA | = BIT(ds 18b 20);
PORTA & amp= ~ BIT(ds 18b 20); // Tire hacia abajo para comenzar a escribir bits de datos.
Drayus(1); //Espera 1 microsegundo
If (wrd & amp0x 001) // ¿Estos bits son altos?
{
PORTA | = BIT(ds 18b 20); //Si está alto, tire del bus único hacia arriba.
}
Otros
{
PORTA & amp= ~ BIT(ds 18b 20); //Si es bajo, el único autobús será derribado.
}
Drayus(50); //Espera 50 microsegundos
PORTA | = BIT(ds 18b 20); p>
wrd & gt& gt=1;//Muévase hacia la derecha y prepárese para escribir nuevos bits de datos.
}
Drayus(50); //Espera 50 microsegundos
}
/***** *** *********************************
Nombre de la función: Leer temperatura
Energía de trabajo: lea el valor de temperatura.
Parámetros: Ninguno
Valor de retorno: retemp: el valor de temperatura devuelto.
/****************************************** **/
uint Read_temp(vacío)
{
uchar templ, temph
Unidad de temperatura;
b20_init(); //Inicialización. Cada vez que escribes un comando, comienzas con la inicialización.
b20 _ writeB(0x cc); //Saltar ROM
b20 _ writeB(0x 44); //Iniciar conversión de temperatura
b20 _init () ;//inicialización. Cada vez que escribes un comando, comienzas con la inicialización.
b20 _ writeB(0x cc); //Saltar ROM
b20 _ writeB(0x be); //Leer registro
templ = B20 _ readB (); //Leer el byte de baja temperatura
temph = B20 _ readB(); //Leer el byte de alta temperatura
temp = templ+temph * 256 ; temperaturas en variables de 16 bits.
Temperatura de retorno; //Devuelve variable de 16 bits.
}
/************************************ *********
Nombre de la función: Num_BCD
Función: convierte un entero de un byte en un código BCD de tres dígitos.
Parámetros: num: el número entero que se va a convertir.
Valor de retorno: chr - puntero de matriz de código BCD de tres dígitos
/*********************** * ***********************/
uchar* Num_BCD (número de unidad)
{
uchar i, chr[3];
uchar report;
rept = & amp(chr[0]); array
for(I = 0;i<3;i++)
{
chr[2-I]= num % 10;//Obtener el resto de 10 (en realidad encuentra el módulo, pero para números positivos, tomar el resto equivale a encontrar el módulo)
num/= 10; // Divide entre 10 y prepárate para sacar el siguiente dígito.
}
Devolver informe; //Devolver un puntero
}
/*********** ***** *************************************
Nombre de la función : principal
Función: Leer y mostrar la temperatura.
Parámetros: Ninguno
Valor de retorno: Ninguno
/********************* *** *************************/
Gerente general no válido (no válido)
{
uint t;
uchar * temppt
uchar i, temp[3];
board _ init(); Inicialice la placa de desarrollo
while(1)
{
t = Leer _ temp() //Leer el valor de temperatura
temppt = Num _ BCD(t); //Convierte 10 veces la temperatura real en código BCD.
for(I = 0;i<3;i++)//Almacena el código BCD convertido en la matriz de visualización.
{
temp[I]= *(temppt+I);
}
for(I = 0;I& lt3 ;i++)//Mostrar temperatura
{
if(i==1)
{
temp[1]+ = 16; //Si eres tú, agrega el punto decimal (decodificación de tubo digital)
}
One_smg_display(temp[i], I+1);
Dalemus(5);
}
}
}
/************ ********************************
Archivo: Lotería. C
Entorno: compilado en ICC AVR6.25A, simulado en AVR Studio4.10.
Hardware: chip ATMEGA16.
Fecha: 12, 2006
Función: Conduzca el tubo digital en la placa de desarrollo para desplazarse y mostrar 1, 2, 3, 4, 5, 6.
Observaciones: Consulte los ejemplos de aplicación y programación en lenguaje C del microcontrolador de la serie AVR
/********************* ******* *******************/
# include//Incluir archivos de encabezado de modelo.
# include//Contiene archivos de encabezado para operaciones de "bits".
# include//Archivo de encabezado de entrada/salida estándar
#pragma data: code
const SEGMENT[26]={0x3f, 0x06, 0x5b, 0x4f , 0x66, 0x6d, 0x7d, 0x07,
0x7f, 0x6f, 0x77, 0x7c, 0x39, 0x5e, 0x79, 0x71,
0xbf, 0x86, 0xdb, 0xcf, 0xe6, 0xed. , 0xfd, 0x87,
0xff, 0x ef };
/************************ *******************
Nombre de la función: One_smg_display
Función: Especifique el tubo digital para mostrar el contenido especificado.
Parámetro: contenido de visualización de datos (0-15)
Número de tubo digital especificado (1-6)
Valor de retorno: Ninguno
/************************************************/
void One_smg_display(datos de uchar, número de uchar)
{
PORTB | = 0x3F//Selección de bits de salida
PORTA = BIT (BITLK ); //Actualizar selección de bits
Drayus(50); //Ajustar sincronización
PORTA & amp= ~ BIT(BITLK); //Enclavar selección de bits
PORTB = segment[data]; //Selección de segmento de salida
PORTA | = BIT(seg lk); //Actualizar selección de segmento
Drayus (50); /Ajustar sincronización
PORTA & amp= ~ BIT(se glk); //Selección de segmento de pestillo
número=~BIT(número-1);/ /Ajustar selección de posición (1 ~6 al especificar, 0~5 al operar)
PORTB = número; //Selección de bit de salida
PORTA | = BIT(BITLK); >
Drayus(50); //Ajustar sincronización
PORTA & amp= ~ BIT(BITLK); //Selección de bit de bloqueo
}
/****************************************** ****
Nombre de la función: All _ smg _display
Función: 6 tubos digitales muestran el contenido especificado.
Parámetros: * pdata: la dirección de la matriz de contenido mostrada.
Valor de retorno: Ninguno
/********************************* *** *************/
void All _ SMG _ display(uchar * pdata)
{
Uchar i;
for(I = 0; i<6;i++)
{
One_smg_display(pdata[i], I+1);
p>
retraso ms(1);
}
}
/********** ******* ****************************
Nombre de función: Visualización de bucle
Función: seis Los tubos digitales se desplazan de derecha a izquierda para mostrar el contenido especificado (una vez).
Parámetros: * pdata: la dirección de la matriz de contenido mostrada.
Valor de retorno: Ninguno
/********************************* *** *************/
Ciclo nulo _ SMG _ display(uchar * pdata)
{
uchar i, j;
for(I = 0;i<240;I++)/* * *Desplácese 6 veces, cada vez que se muestra el contenido durante 40 ciclos.
{
for(j = 0;j & lt6;j++)//Escanear 6 tubos digitales
{
uno _ SMG _ display(pdata[(I/4j)% 6], j+1); //Display
Drayus(2000); //Ajusta el tiempo de visualización y el brillo (cuanto mayor sea el tiempo, cuanto mayor sea el brillo, pero más tiempo parpadeará el tubo digital)
}
}
}