Monitor de temperatura y nivel de luz con visualización en LCD NOKIA 5110: 4 pasos

2024 Autor: John Day | [email protected]. Última modificación: 2024-01-30 08:42

¡Hola, todos!

En esta sección realizamos un sencillo dispositivo electrónico para controlar la temperatura y el nivel de luz. Las medidas de estos parámetros se muestran en la pantalla LCD NOKIA 5110. El dispositivo se basa en el microcontrolador AVR ATMEGA328P. El dispositivo de monitoreo está equipado con termómetro digital DS18B20 y fotorresistencia para medir el nivel de luz.

Paso 1: Descripción de los componentes

Componentes básicos del dispositivo de monitoreo:

• Microcontrolador AVR «ATMEGA328P»
• LCD gráfico monocromático «NOKIA 5110»
• Termómetro digital de 1 cable con resolución programable «DS18B20»
• Resistencia dependiente de la luz
• Alambres

Microcontrolador AVR «ATMEGA328P»

El dispositivo de monitoreo utiliza las siguientes características periféricas del microcontrolador:

1. Interrupción del temporizador / contador de 16 bits
2. ADC de 8 canales y 10 bits
3. Interfaz serial SPI maestro / esclavo

LCD gráfico monocromático «NOKIA 5110»

Especificaciones:

1. Pantalla LCD de 48 x 84 puntos
2. Interfaz de bus serie con una velocidad máxima de 4 Mbits / S
3. Controlador / controlador interno «PCD8544»
4. Luz de fondo LED
5. Funciona con un voltaje de 2,7 a 5 voltios
6. Bajo consumo de energía; es adecuado para aplicaciones de batería
7. Rango de temperatura de -25˚C a + 70˚C
8. Entrada de señal CMOS de soporte

Manejo de la dirección LCD (direccionamiento):

La disposición de la dirección de la memoria que se muestra en la pantalla LCD (DDRAM) es una matriz que consta de 6 filas (dirección Y) desde la dirección Y 0 a la dirección Y 5 y 84 columnas (dirección X) desde la dirección X 0 a la X- Dirección 83. Si el usuario desea acceder a la posición de visualización del resultado en la pantalla LCD, debe consultar la relación entre la dirección X y la dirección Y.

Los datos que se enviarán a la pantalla son de 8 bits (1 Byte) y se organizarán como una línea vertical; en este caso, el bit MSB será menor y el bit LSB será superior como se muestra en la imagen.

Termómetro digital de 1 cable con resolución programable DALLAS «DS18B20»

Características:

1. La interfaz única de 1 cable® requiere solo un pin de puerto para la comunicación
2. Reduzca el recuento de componentes con sensor de temperatura integrado y EEPROM
3. Mide temperaturas de -55 ° C a + 125 ° C (-67 ° F a + 257 ° F)
4. ± 0,5 ° C Precisión de -10 ° C a + 85 ° C
5. Resolución programable de 9 bits a 12 bits
6. No se requieren componentes externos
7. El modo de energía parasitaria requiere solo 2 pines para su funcionamiento (DQ y GND)
8. Simplifica las aplicaciones de detección de temperatura distribuidas con capacidad multipunto
9. Cada dispositivo tiene un código de serie único de 64 bits almacenado en la ROM incorporada
10. Configuraciones de alarma no volátiles (NV) definibles por el usuario flexibles con comando de búsqueda de alarma Identifica dispositivos con temperaturas fuera de los límites programados

Aplicaciones:

1. Controles termostáticos
2. Sistemas industriales
3. Productos de consumo
4. Termómetros
5. Sistemas térmicamente sensibles

Resistencia dependiente de la luz

La resistencia dependiente de la luz (LDR) es un transductor que cambia su resistencia cuando la luz incide sobre su superficie cambia.

Normalmente, un LDR tendrá de un megaohmios a dos megaohmios en oscuridad total, de diez a veinte kiloohmios a diez LUX, de dos a cinco kiloohmios a 100 LUX. La resistencia entre los dos contactos del sensor disminuye con la intensidad de la luz o aumenta la conductancia entre dos contactos del sensor.

Utilice un circuito divisor de voltaje para convertir el cambio de resistencia en un cambio de voltaje.

Paso 2: Código de firmware del microcontrolador

#ifndef F_CPU # define F_CPU 16000000UL // indicando la frecuencia del cristal del controlador (AVR de 16 MHz ATMega328P) #endif

// INTERFAZ SPI DEFINE #define MOSI 3 // MOSI es PORT B, PIN 3 #define MISO 4 // MISO es PORT B, PIN 4 #define SCK 5 // SCK es PORT B, PIN 5 #define SS 2 // SS es PUERTO B, PIN 2

// RESTABLECER LA PANTALLA #define RST 0 // RESTABLECER su PUERTO B, PIN 0

// DISPLAY MODE SELECT - Entrada para seleccionar comando / dirección o entrada de datos. #define DC 1 // DC es PUERTO B, PIN 1

// codifica una matriz de constante de signo negativo unsigned char neg [4] = {0x30, 0x30, 0x30, 0x30};

// codifica matriz de dígitos [0..9] static const unsigned char font6x8 [10] [16] = {{0xFC, 0xFE, 0xFE, 0x06, 0x06, 0xFE, 0xFE, 0xFC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 0 {0x00, 0x00, 0x18, 0x1C, 0xFE, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00}, // 1 { 0x0C, 0x8E, 0xCE, 0xE6, 0xE6, 0xBE, 0x9E, 0x0C, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 2 {0x00, 0x04, 0xFEx06, 0xDE, 0x8C, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 3 {0x3C, 0x3E, 0x7C, 0x60, 0x60, 0xFC, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x 0x01, 0x03, 0x01}, // 4 {0x1C, 0x3E, 0x3E, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01x}, // 5 { 0xFE, 0xFE, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 6 {0x04, 0x06, 0x06, 0x86, 0xFE, 0xE6C, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00}, // 7 {0xCC, 0xFE, 0xFE, 0x36, 0x36, 0xFE, 0xFE, 0xCC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x0 3, 0x01}, // 8 {0x3C, 0x7E, 0x7E, 0x66, 0x66, 0xFE, 0xFE, 0xFC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01} // 9};

// matriz de códigos de la palabra "TEMP:" static const unsigned char TEMP_1 [165] = {0x02, 0x06, 0x06, 0xFE, 0xFE, 0xFE, 0x06, 0x06, 0x02, 0x00, 0xFC, 0xFE, 0xFE, 0x26, 0x26, 0x24, 0x00, 0xFC, 0xFE, 0xFE, 0x1C, 0x38, 0x70, 0x38, 0x1C, 0xFE, 0xFE, 0xFC, 0x00, 0xFC, 0xFE, 0xFE, 0x66, 0x66, 0x7E, 0x7E, 0x3C, 0x00 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x03 0x01, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x0C, 0x1E, 0x33, 0x33, 0x1E, 0x0C, 0x0C, 0xFC 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01,};

// matriz de códigos de la palabra "LUX:" const unsigned char TEMP_2 [60] = {0xFC, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFC, 0xFE, 0xFC, 0x00, 0x00, 0xFC, 0xFE, 0xFC, 0x00, 0x04, 0x8E, 0xDE, 0xFC, 0xF8, 0xFC, 0xDE, 0x8E, 0x04, 0x00, 0x8C, 0x8C, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01};

#incluir

#incluir #incluir

// Port Initializationvoid Port_Init () {DDRB = (1 << MOSI) | (1 << SCK) | (1 << SS) | (1 << RST) | (1 << DC); // Establecer MOSI, SCK, SS, RST, DC como salida, todos los demás ingresan PORTB | = (1 << RST); // Establecer el pin RST como alto PORTB | = (1 << SS); // Establecer el pin SS como alto - La pantalla es Deshabilitar DDRC = 0xFFu; // Establecer todos los pines del PORTC como salida. DDRC & = ~ (1 << 0); // Hace el primer pin de PORTC como Entrada PORTC = 0x00u; // Establece todos los pines de PORTC bajo, lo que lo apaga. }

// Inicialización de ADC void ADC_init () {// Habilitar ADC, frecuencia de muestreo = osc_freq / 128 establece el preescalador al valor máximo, 128 ADCSRA | = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); ADMUX = (1 << REFS0); // Seleccione la referencia de voltaje para el ADC // Seleccione el canal cero por defecto usando el registro ADC Multiplexer Select (ADC0). }

// Función para leer el resultado de la conversión de analógico a digital uint16_t get_LightLevel () {_delay_ms (10); // Espere un tiempo para que el canal sea seleccionado ADCSRA | = (1 << ADSC); // Inicie la conversión ADC configurando el bit ADSC. escribe 1 en ADSC mientras (ADCSRA & (1 << ADSC)); // esperar a que se complete la conversión // ADSC vuelve a ser 0 hasta entonces, ejecutar el bucle continuamente _delay_ms (10); retorno (ADC); // Devuelve el resultado de 10 bits}

// Inicialización SPI void SPI_Init () {SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // Habilitar SPI, Establecer como maestro, Establecer Prescaler como Fosc / 16 en el control SPI Registrarse }

// inicializa Timer1 de 16 bits, interrupción y variable void TIMER1_init () {// configura el temporizador con prescaler = 256 y modo CTC TCCR1B | = (1 << WGM12) | (1 << CS12); // inicializar el contador TCNT1 = 0; // inicializar el valor de comparación - 1 segundo OCR1A = 62500; // habilita la interrupción de comparación TIMSK1 | = (1 << OCIE1A); // habilitar interrupciones globales sei (); }

// Mostrar habilitación void SPI_SS_Enable () {PORTB & = ~ (1 << SS); // Habilita el pin SS a la lógica 0}

// Deshabilitar pantalla void SPI_SS_Disable () {PORTB | = (1 << SS); // Deshabilita el pin SS a la lógica 1}

// Función para enviar datos al búfer de visualización void SPI_Tranceiver (datos de caracteres sin firmar) {SPDR = data; // Cargar datos en el búfer while (! (SPSR & (1 << SPIF))); // Espere hasta que se complete la transmisión}

// Restablece la pantalla al comienzo de la inicialización void Display_Reset () {PORTB & = ~ (1 << RST); _delay_ms (100); PORTB | = (1 << RST); }

// Función de escritura de comando void Display_Cmnd (datos de caracteres sin firmar) {PORTB & = ~ (1 << DC); // establece el pin de CC en 0 lógico para la operación de comando SPI_Tranceiver (datos); // enviar datos en el registro de datos PORTB | = (1 << DC); // hacer que el pin DC sea lógico alto para la operación de datos}

// Inicialización de la pantalla void Display_init () {Display_Reset (); // reinicia la pantalla Display_Cmnd (0x21); // comando establecido en modo adicional Display_Cmnd (0xC0); // establece el voltaje enviando C0 significa VOP = 5V Display_Cmnd (0x07); // establece la temperatura. coeficiente de 3 Display_Cmnd (0x13); // establecer el valor de Voltage Bias System Display_Cmnd (0x20); // comando establecido en modo básico Display_Cmnd (0x0C); // muestra el resultado en modo normal}

// Limpiar la pantalla void Display_Clear () {PORTB | = (1 << DC); // establece el pin DC en lógica alta para la operación de datos para (int k = 0; k <= 503; k ++) {SPI_Tranceiver (0x00);} PORTB & = ~ (1 << DC); // convierte el pin DC en lógica cero para operación de comando}

// establece la columna y la fila en la posición de visualización del resultado en la pantalla LCD void Display_SetXY (unsigned char x, unsigned char y) {Display_Cmnd (0x80 | x); // columna (0-83) Display_Cmnd (0x40 | y); // fila (0-5)}

// Función para mostrar el signo negativo void Display_Neg (unsigned char neg) {Display_SetXY (41, 0); // Establecer la dirección de la posición en la pantalla para (int index = 0; index0) {SPDR = 0x30;} // Cargar datos en el búfer de la pantalla (mostrar signo negativo) else {SPDR = 0x00;} // Cargar datos en el búfer de visualización (borrar signo negativo) while (! (SPSR & (1 << SPIF))); // Espere hasta que se complete la transmisión _delay_ms (100); }}

// Función para borrar el signo digital void Off_Dig (unsigned char x, unsigned char y) {Display_SetXY (x, y); // Establecer la dirección de la posición en la pantalla (fila superior) para (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Cargar datos en el búfer de la pantalla (borrar la parte superior del signo digital) y ++; Display_SetXY (x, y); // Establecer la dirección de la posición en la pantalla (fila inferior) para (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Cargar datos en el búfer de la pantalla (parte inferior clara del letrero digital)}

// Función para mostrar el signo digital void Display_Dig (int dig, unsigned char x, unsigned char y) {Display_SetXY (x, y); // Establecer la dirección de la posición en la pantalla (fila superior) para (int index = 0; index <16; index ++) {if (index == 8) {y ++; Display_SetXY (x, y);} // Establecer la dirección de la posición en la pantalla (fila inferior) SPI_Tranceiver (font6x8 [dig] [index]); // Cargar matriz de códigos de datos de dígitos en el búfer de la pantalla _delay_ms (10); }}

// Inicialización de DS18B20 unsigned char DS18B20_init () {DDRD | = (1 << 2); // Establecer el pin PD2 del PORTD como salida PORTD & = ~ (1 << 2); // Establecer el pin PD2 como bajo _delay_us (490); // Tiempo de inicialización DDRD & = ~ (1 << 2); // Establecer el pin PD2 del PORTD como entrada _delay_us (68); // Cronometraje OK_Flag = (PIND & (1 << 2)); // obtiene el pulso del sensor _delay_us (422); return OK_Flag; // retorno 0-ok sensor está enchufado, 1-sensor de error está desenchufado}

// Función para leer el byte de DS18B20 unsigned char read_18b20 () {unsigned char i, data = 0; para (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Establecer el pin PD2 del PORTD como salida _delay_us (2); // Tiempo DDRD & = ~ (1 1; // Siguiente bit if (PIND & (1 << 2)) data | = 0x80; // poner bit en byte _delay_us (62);} return data;}

// Función para escribir un byte en DS18B20 void write_18b20 (datos de caracteres sin firmar) {caracteres sin firmar i; para (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Establecer el pin PD2 del PORTD como salida _delay_us (2); // Tiempo si (datos & 0x01) DDRD & = ~ (1 << 2); // si queremos escribir 1, suelte la línea else DDRD | = (1 1; // Siguiente bit _delay_us (62); // Timing DDRD & = ~ (1 << 2); // Establezca el pin PD2 del PORTD como entrada _delay_us (2);}}

// Función para mostrar el nivel de luz void Read_Lux () {uint16_t buffer; unsigned int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // dígitos simples, dígitos dobles, dígitos triples, dígitos cuartos de dígitos buffer = get_LightLevel (); // leer el resultado de la conversión analógica a digital del nivel de luz temp_int_0 = buffer% 10000/1000; // un cuarto de dígito temp_int_1 = buffer% 1000/100; // temp_int_2 de tres dígitos = búfer% 100/10; // temp_int_3 de dos dígitos = búfer% 10; // de un solo dígito if (temp_int_0> 0) // si el resultado es un número de un cuarto de dígito {Display_Dig (temp_int_0, 32, 2); // muestra 1 dígito del nivel de luz Display_Dig (temp_int_1, 41, 2); // muestra 2 dígitos del nivel de luz Display_Dig (temp_int_2, 50, 2); // muestra 3 dígitos del nivel de luz Display_Dig (temp_int_3, 59, 2); // muestra 4 dígitos del nivel de luz} else {if (temp_int_1> 0) // si el resultado es un número de tres dígitos {Off_Dig (32, 2); // borrar 1 signo del número Display_Dig (temp_int_1, 41, 2); // muestra 1 dígito del nivel de luz Display_Dig (temp_int_2, 50, 2); // muestra 2 dígitos del nivel de luz Display_Dig (temp_int_3, 59, 2); // muestra 3 dígitos del nivel de luz} else {if (temp_int_2> 0) // si el resultado es un número de dos dígitos {Off_Dig (32, 2); // borrar 1 signo del número Off_Dig (41, 2); // borrar el signo 2 del número Display_Dig (temp_int_2, 50, 2); // muestra 1 dígito del nivel de luz Display_Dig (temp_int_3, 59, 2); // muestra 2 dígitos del nivel de luz} else // si el resultado es un número de un solo dígito {Off_Dig (32, 2); // borrar 1 signo del número Off_Dig (41, 2); // borrar el signo 2 del número Off_Dig (50, 2); // borrar el signo 3 del número Display_Dig (temp_int_3, 59, 2); // muestra 1 dígito del nivel de luz}}}}

// Función para mostrar la temperatura void Read_Temp () {unsigned int buffer; unsigned int temp_int_1, temp_int_2, temp_int_3; // dígitos de un solo dígito, dígitos dobles, dígitos triples, dígitos cuartos de dígitos sin firmar Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init (); // Inicialización de DS18B20 write_18b20 (0xCC); // Comprobación del código del sensor write_18b20 (0x44); // Iniciar conversión de temperatura _delay_ms (1000); // Retardo de sondeo del sensor DS18B20_init (); // Inicialización de DS18B20 write_18b20 (0xCC); // Comprobación del código del sensor write_18b20 (0xBE); // Comando para leer el contenido de la RAM del sensor Temp_L = read_18b20 (); // Leer los dos primeros bytes Temp_H = read_18b20 (); temp_flag = 1; // Temperatura 1 positiva, temperatura 0 negativa // Obtiene temperatura negativa if (Temp_H & (1 << 3)) // Comprobación de bit de signo (si el bit está establecido - temperatura negativa) {sign int temp; temp_flag = 0; // el indicador se establece en 0 - temperatura negativa temp = (Temp_H << 8) | Temp_L; temp = -temp; // Convertir el código adicional en directo Temp_L = temp; Temp_H = temp >> 8; } buffer = ((Temp_H 4); temp_int_1 = buffer% 1000/100; // de tres dígitos temp_int_2 = buffer% 100/10; // de dos dígitos temp_int_3 = buffer% 10; // de un solo dígito

// Si la temperatura es un signo de temperatura negativo, de lo contrario, borre

if (temp_flag == 0) {Display_Neg (1);} else {Display_Neg (0);} if (temp_int_1> 0) // si el resultado es un número de tres dígitos {Display_Dig (temp_int_1, 45, 0); // muestra 1 dígito de temperatura Display_Dig (temp_int_2, 54, 0); // muestra 2 dígitos de temperatura Display_Dig (temp_int_3, 63, 0); // muestra 3 dígitos de temperatura} else {if (temp_int_2> 0) // si el resultado es un número de dos dígitos {Off_Dig (45, 0); // borrar 1 signo de número Display_Dig (temp_int_2, 54, 0); // muestra 1 dígito de temperatura Display_Dig (temp_int_3, 63, 0); // muestra 2 dígitos de temperatura} else // si el resultado es un número de un solo dígito {Off_Dig (45, 0); // borrar 1 signo del número Off_Dig (54, 0); // borrar el signo 2 del número Display_Dig (temp_int_3, 63, 0); // muestra 1 dígito de temperatura}}}

// Este ISR se dispara siempre que se produce una coincidencia del conteo del temporizador con el valor de comparación (cada 1 segundo) ISR (TIMER1_COMPA_vect) {// Lectura, visualización de temperatura y nivel de luz Read_Temp (); Read_Lux (); }

// Función para mostrar las palabras "TEMP" y "LUX" void Display_label () {// Palabra "TEMP" Display_SetXY (0, 0); // Establecer la dirección de la posición en la pantalla (fila superior) para (int index = 0; index <105; index ++) {if (index == 40) {Display_SetXY (0, 1);} // Establecer la dirección de la posición en pantalla (fila inferior) if (índice == 80) {Display_SetXY (72, 0);} // Establecer la dirección de la posición en pantalla (fila superior) if (índice == 92) {Display_SetXY (72, 1); } // Establecer la dirección de la posición en la pantalla (fila inferior) SPDR = TEMP_1 [índice]; // Carga los datos de la matriz de códigos en el búfer de la pantalla while (! (SPSR & (1 << SPIF))); // Espere hasta que se complete la transmisión _delay_ms (10); } // Palabra "LUX" Display_SetXY (0, 2); // Establecer la dirección de la posición en la pantalla (fila superior) para (int index = 0; index <60; index ++) {if (index == 30) {Display_SetXY (0, 3);} // Establecer la dirección de la posición en pantalla (fila inferior) SPDR = TEMP_2 [índice]; // Carga los datos de la matriz de códigos en el búfer de la pantalla while (! (SPSR & (1 << SPIF))); // Espere hasta que se complete la transmisión _delay_ms (10); }}

int main (vacío)

{Port_Init (); // Inicialización de puerto ADC_init (); // Inicialización de ADC SPI_Init (); // Inicialización SPI SPI_SS_Enable (); // Mostrar Habilitar DS18B20_init (); // Inicialización de DS18B20 Display_init (); // Mostrar inicialización Display_Clear (); // Mostrar clear Display_label (); // Mostrar las palabras "TEMP" y "LUX" TIMER1_init (); // Inicialización del Timer1. Empiece a monitorear. Obteniendo parámetros cada segundo. // Bucle infinito while (1) {}}

Paso 3: flasheo del firmware al microcontrolador

Subiendo el archivo HEX a la memoria flash del microcontrolador. Vea el video con una descripción detallada de la grabación de la memoria flash del microcontrolador: Grabación de la memoria flash del microcontrolador …

Paso 4: Ensamblaje del circuito del dispositivo de monitoreo

Conecte los componentes de acuerdo con el diagrama esquemático.

¡Enchufe la energía y está funcionando!