Monitor de temperatura i nivell de llum amb visualització en pantalla LCD NOKIA 5110: 4 passos

2024 Autora: John Day | [email protected]. Última modificació: 2024-01-30 08:14

Hola a tothom!

En aquesta secció fem un dispositiu electrònic senzill per controlar la temperatura i el nivell de llum. Les mesures d'aquests paràmetres es mostren a la pantalla LCD NOKIA 5110. El dispositiu es basa en el microcontrolador AVR ATMEGA328P. El dispositiu de monitorització està equipat amb termòmetre digital DS18B20 i fotoresistència per mesurar el nivell de llum.

Pas 1: components de la descripció

Components bàsics del dispositiu de control:

• Microcontrolador AVR «ATMEGA328P»
• LCD gràfic monocrom «NOKIA 5110»
• Termòmetre digital de 1 fil de resolució programable «DS18B20»
• Resistència dependent de la llum
• Filferros

Microcontrolador AVR «ATMEGA328P»

El dispositiu de control utilitza les funcions perifèriques següents del microcontrolador:

1. Interrupció de temporitzador / comptador de 16 bits
2. ADC de 10 canals de 8 canals
3. Interfície sèrie SPI mestre / esclau

LCD gràfic monocrom «NOKIA 5110»

Especificacions:

1. Pantalla LCD de 48 x 84 punts
2. Interfície de bus sèrie amb velocitat màxima alta de 4 Mbits / S
3. Controlador / controlador intern «PCD8544»
4. Llum de fons LED
5. Funciona al voltatge 2,7-5 volts
6. Baix consum d'energia; és adequat per a aplicacions de bateria
7. Rang de temperatura des de -25˚C fins a + 70˚C
8. Suport d'entrada CMOS de senyal

Gestió de l'adreça LCD (adreçament):

La disposició de l'adreça de la memòria que es mostra a la pantalla LCD (DDRAM) és una matriu que consta de 6 files (adreça Y) des de l'adreça Y 0 fins a l'adreça Y 5 i 84 columnes (adreça X) des de l'adreça X 0 fins a X- Adreça 83. Si l'usuari vol accedir a la posició de mostrar el resultat a la pantalla LCD, ha de referir-se a la relació entre l'adreça X i l'adreça Y.

Les dades que s’enviaran a la pantalla són de 8 bits (1 byte) i es disposaran com a línia vertical; en aquest cas, el bit MSB serà inferior i el bit LSB serà superior, tal com es mostra a la imatge.

Termòmetre digital amb 1 fil de resolució programable DALLAS «DS18B20»

Característiques:

1. La interfície única 1-Wire® requereix només un pin de port per a la comunicació
2. Reduïu el recompte de components amb sensor de temperatura integrat i EEPROM
3. Mesura temperatures de -55 ° C a + 125 ° C (-67 ° F a + 257 ° F)
4. ± 0,5 ° C Precisió de -10 ° C a + 85 ° C
5. Resolució programable de 9 bits a 12 bits
6. No es requereixen components externs
7. El mode d'alimentació parasitària només requereix 2 pins per funcionar (DQ i GND)
8. Simplifica les aplicacions de detecció de temperatura distribuïdes amb capacitat Multidrop
9. Cada dispositiu té un codi sèrie de 64 bits únic emmagatzemat a la ROM integrada
10. Configuració d'alarma flexible no definible per l'usuari (NV) amb ordre de cerca d'alarma que identifica dispositius amb temperatures fora dels límits programats

Aplicacions:

1. Controls termostàtics
2. Sistemes Industrials
3. Productes del Consumidor
4. Termòmetres
5. Sistemes tèrmicament sensibles

Resistència dependent de la llum

El Light Dependent Resistor (LDR) és un transductor que canvia la seva resistència quan la llum cau sobre la seva superfície.

Normalment, un LDR tindrà des d’un megaOhms fins a dos megaOhms a la foscor total, de deu a vint kiloOhms a deu LUX, de dos a cinc kiloohms a 100 LUX. La resistència entre els dos contactes del sensor disminueix amb la intensitat de la llum o augmenta la conductància entre els dos contactes del sensor.

Utilitzeu el circuit divisor de tensió per convertir el canvi de resistència al canvi de tensió.

Pas 2: Codi de microprogramari del microcontrolador

#ifndef F_CPU # define F_CPU 16000000UL // indicant la freqüència de cristall del controlador (16 MHz AVR ATMega328P) #endif

// SPI INTERFACE DEFINES #define MOSI 3 // MOSI it's PORT B, PIN 3 #define MISO 4 // MISO it's PORT B, PIN 4 #define SCK 5 // SCK it's PORT B, PIN 5 #define SS 2 // SS és PORT B, PIN 2

// RESTABLEIX LA PANTALLA #define RST 0 // RESTABLEIX el PORT B, PIN 0

// DISPLAY MODE SELECT - Entrada per seleccionar comandes / adreces o entrada de dades. #define DC 1 // DC és PORT B, PIN 1

// matriu de codis de signstatic negatiu const unsigned char neg [4] = {0x30, 0x30, 0x30, 0x30};

// matriu de codis de dígits [0..9] constant 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, 0x0x, 0x06, 0x06, 0x0x,, 0x8C, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 3 {0x3C, 0x3E, 0x7C, 0x60, 0x60, 0xFC, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00 0x01, 0x03, 0x01}, // 4 {0x1C, 0x3E, 0x3E, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 5x 0x, 0xFE, 0xFE, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 6 {0x04, 0x06, 0x06, 0x86, 0x1, 0x1, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00}, // 7 {0xCC, 0xFE, 0xFE, 0x36, 0x36, 0xFE, 0xFE, 0xCC, 0x01, 0x03, 0x03, 0x03, 0x3, 0x0 3, 0x01}, // 8 {0x3C, 0x7E, 0x7E, 0x66, 0x66, 0xFE, 0xFE, 0xFC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01} // 9};

// matriu de codis de la paraula "TEMP:" estàtic 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, 0x00, 0x00 0x01, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x0C, 0x1E, 0x33, 0x33, 0x1E, 0x0C, 0x0C, 0x0C, 0x0C 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01,};

// matriu de codis de la paraula "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, 0x0x, 0x0x,, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01};

#incloure

#include #include

// Port Initializationvoid Port_Init () {DDRB = (1 << MOSI) | (1 << SCK) | (1 << SS) | (1 << RST) | (1 << DC); // Establir MOSI, SCK, SS, RST, DC com a sortida, totes les altres entrades PORTB | = (1 << RST); // Estableix el pin RST com a alt PORTB | = (1 << SS); // Estableix el pin SS com a alt: la pantalla és Desactiva DDRC = 0xFFu; // Estableix tots els pins del PORTC com a sortida. DDRC & = ~ (1 << 0); // Fa el primer pin de PORTC com a entrada PORTC = 0x00u; // Estableix tots els pins de PORTC que el desactivi. }

// ADC Initialization void ADC_init () {// Habilita ADC, mostreig freq = osc_freq / 128 estableix el precalificador al valor màxim, 128 ADCSRA | = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); ADMUX = (1 << REFS0); // Seleccioneu la referència de tensió per a l'ADC // Per defecte, seleccioneu el canal zero mitjançant el registre ADC Multiplexer Select (ADC0). }

// Funció per llegir el resultat de la conversió analògica a digital uint16_t get_LightLevel () {_delay_ms (10); // Espereu un temps fins que el canal obtingui ADCSRA seleccionat | = (1 << ADSC); // Inicieu la conversió ADC configurant el bit ADSC. escriviu 1 a ADSC mentre (ADCSRA & (1 << ADSC)); // espera que es completi la conversió // ADSC torna a ser 0 fins llavors, executa el bucle contínuament _delay_ms (10); retorn (ADC); // Torna el resultat de 10 bits}

// SPI Initialization void SPI_Init () {SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // Habilita SPI, Estableix com a mestre, Estableix el prescalador com Fosc / 16 al control SPI registre}

// inicialitzeu el temporitzador de 16 bits, la interrupció i el buit variable TIMER1_init () {// configureu el temporitzador amb prescaler = 256 i el mode CTC TCCR1B | = (1 << WGM12) | (1 << CS12); // inicialitzar el comptador TCNT1 = 0; // inicialitzar el valor de comparació: 1 segon OCR1A = 62500; // habilita la interrupció de comparació TIMSK1 | = (1 << OCIE1A); // habilita les interrupcions globals sei (); }

// Display Enable void SPI_SS_Enable () {PORTB & = ~ (1 << SS); // Activeu el PIN SS a la lògica 0}

// Mostra Disable void SPI_SS_Disable () {PORTB | = (1 << SS); // Desactiveu el PIN SS a la lògica 1}

// Funció per enviar dades al buffer de visualització buit SPI_Tranceiver (dades de caràcters sense signar) {SPDR = data; // Carregueu dades al buffer mentre (! (SPSR & (1 << SPIF))); // Espereu fins que es completi la transmissió}

// Restableix la pantalla al començament de la inicialització buida Display_Reset () {PORTB & = ~ (1 << RST); _delay_ms (100); PORTB | = (1 << RST); }

// Funció d'escriptura d'ordres void Display_Cmnd (dades de caràcters sense signar) {PORTB & = ~ (1 << DC); // Feu el pin CC a la lògica 0 per a l'operació d'ordres SPI_Tranceiver (dades); // enviar dades al registre de dades PORTB | = (1 << DC); // Feu que el pin CC a la lògica sigui elevat per a l'operació de dades}

// Inicialització de Display void Display_init () {Display_Reset (); // restableix la pantalla Display_Cmnd (0x21); // conjunt d'ordres en mode addicional Display_Cmnd (0xC0); // configureu el voltatge enviant C0 significa VOP = 5V Display_Cmnd (0x07); // Estableix la temperatura. coeficient a 3 Display_Cmnd (0x13); // defineix el valor de Voltage Bias System Display_Cmnd (0x20); // conjunt d'ordres en mode bàsic Display_Cmnd (0x0C); // mostra el resultat en mode normal}

// Esborreu el Display buit Display_Clear () {PORTB | = (1 << DC); // Feu que el pin CC sigui lògic per al funcionament de les dades per a (int k = 0; k <= 503; k ++) {SPI_Tranceiver (0x00);} PORTB & = ~ (1 << DC); // Feu el pin CC a lògica zero per a l'operació d'ordres}

// configureu la columna i la fila a la posició del resultat de visualització a la pantalla LCD void Display_SetXY (sense signe x, sense signe y) {Display_Cmnd (0x80 | x); // columna (0-83) Display_Cmnd (0x40 | y); // fila (0-5)}

// Funció per mostrar el signe negatiu void Display_Neg (neg negatiu) {Display_SetXY (41, 0); // Estableix l'adreça de posició a la pantalla per a (int index = 0; index0) {SPDR = 0x30;} // Carrega les dades al buffer de visualització (mostra el signe negatiu) més {SPDR = 0x00;} // Carrega les dades a la memòria intermèdia de visualització (signe negatiu clar) mentre (! (SPSR & (1 << SPIF))); // Espereu fins que la transmissió finalitzi _delay_ms (100); }}

// Funció per esborrar el signe digital buit Off_Dig (sense signe x, sense signe y) {Display_SetXY (x, y); // Estableix l'adreça de posició a la pantalla (fila superior) per a (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Carrega les dades al buffer de la pantalla (esborra la part superior del signe digital) y ++; Display_SetXY (x, y); // Estableix l'adreça de posició a la pantalla (fila inferior) per a (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Carrega les dades al buffer de la pantalla (neteja la part inferior del signe digital)}

// Funció per mostrar el signe digital void Display_Dig (int dig, unsigned char x, unsigned char y) {Display_SetXY (x, y); // Estableix l'adreça de posició a la pantalla (fila superior) per a (int index = 0; index <16; index ++) {if (index == 8) {y ++; Display_SetXY (x, y);} // Estableix l'adreça de posició a la pantalla (fila inferior) SPI_Tranceiver (font6x8 [dig] [index]); // Carrega la matriu de codis de dades de dígits a la memòria intermèdia de la pantalla _delay_ms (10); }}

// Inicialització de DS18B20 sense signar DS18B20_init () {DDRD | = (1 << 2); // Estableix el pin PD2 del PORTD com a sortida PORTD & = ~ (1 << 2); // Estableix el pin PD2 com a _delay_us baix (490); // Temps d'inicialització DDRD & = ~ (1 << 2); // Estableix el pin PD2 del PORTD com a entrada _delay_us (68); // Temporització OK_Flag = (PIND & (1 << 2)); // obtenir el pols del sensor _delay_us (422); torna OK_Flag; // torna el sensor 0-ok està endollat, el sensor 1 error està desconnectat}

// Funció per llegir un byte de DS18B20 unsigned char read_18b20 () {unsigned char i, data = 0; per a (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Estableix el pin PD2 del PORTD com a sortida _delay_us (2); // Temporització DDRD & = ~ (1 1; // Bit següent si (PIND & (1 << 2)) dades | = 0x80; // posa el bit al byte _delay_us (62);} torna dades;}

// Funció per escriure bytes a DS18B20 void write_18b20 (dades de caràcters sense signar) {unsigned char i; per a (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Estableix el pin PD2 del PORTD com a sortida _delay_us (2); // Temporització if (data & 0x01) DDRD & = ~ (1 << 2); // si volem escriure 1, deixeu anar la línia else DDRD | = (1 1; // Bit següent _delay_us (62); // Timing DDRD & = ~ (1 << 2); // Estableix el pin PD2 del PORTD com a entrada _delay_us (2);}}

// Funció per mostrar el nivell de llum void Read_Lux () {uint16_t buffer; unsigned int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // dígits simples, dígits dobles, dígits triples, quart de dígits buffer = get_LightLevel (); // llegeix el resultat del nivell de llum de conversió analògica a digital temp_int_0 = buffer% 10000/1000; // quart de dígits temp_int_1 = memòria intermèdia% 1000/100; // de tres dígits temp_int_2 = memòria intermèdia% 100/10; // doble dígit temp_int_3 = memòria intermèdia% 10; // d'un dígit si (temp_int_0> 0) // si el resultat és un número de quart de dígit {Display_Dig (temp_int_0, 32, 2); // mostra 1 dígit del nivell de llum Display_Dig (temp_int_1, 41, 2); // mostra 2 dígits del nivell de llum Display_Dig (temp_int_2, 50, 2); // mostra 3 dígits del nivell de llum Display_Dig (temp_int_3, 59, 2); // mostra 4 dígits del nivell de llum} else {if (temp_int_1> 0) // if result is triple-number number {Off_Dig (32, 2); // esborreu 1 signe de número Display_Dig (temp_int_1, 41, 2); // mostra 1 dígit del nivell de llum Display_Dig (temp_int_2, 50, 2); // mostra 2 dígits del nivell de llum Display_Dig (temp_int_3, 59, 2); // mostra 3 dígits del nivell de llum} else {if (temp_int_2> 0) // if result is a two-digit number {Off_Dig (32, 2); // esborreu 1 signe del número Off_Dig (41, 2); // esborreu 2 signes de número Display_Dig (temp_int_2, 50, 2); // mostra 1 dígit del nivell de llum Display_Dig (temp_int_3, 59, 2); // mostra 2 dígits del nivell de llum} else // si el resultat és un número d'un sol dígit {Off_Dig (32, 2); // esborreu 1 signe del número Off_Dig (41, 2); // esborreu 2 signes del número Off_Dig (50, 2); // esborreu 3 signes de número Display_Dig (temp_int_3, 59, 2); // mostra 1 dígit del nivell de llum}}}}

// Funció per mostrar la temperatura buida Read_Temp () {buffer int sense signatura; unsigned int temp_int_1, temp_int_2, temp_int_3; // dígits simples, dígits dobles, dígits triples, dígits quarts sense signar caràcter Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init (); // Inicialització de DS18B20 write_18b20 (0xCC); // Comprovació del codi del sensor write_18b20 (0x44); // Inicia la conversió de temperatura _delay_ms (1000); // Retard de sondeig del sensor DS18B20_init (); // Inicialització de DS18B20 write_18b20 (0xCC); // Comprovació del codi del sensor write_18b20 (0xBE); // Ordre per llegir el contingut de la RAM del sensor Temp_L = read_18b20 (); // Llegiu els primers dos bytes Temp_H = read_18b20 (); temp_flag = 1; // 1-temperatura positiva, 0-temperatura negativa // Obtenir temperatura negativa si (Temp_H & (1 << 3)) // Sign Bit Check (si el bit està definit - temperatura negativa) {signat int temp; temp_flag = 0; // es marca 0: temperatura de temperatura negativa = (Temp_H << 8) | Temp_L; temp = -temp; // Converteix el codi addicional en Temp_L directe = temp; Temp_H = temp >> 8; } buffer = ((Temp_H 4); temp_int_1 = buffer% 1000/100; // triple dígit temp_int_2 = buffer% 100/10; // doble dígit temp_int_3 = buffer% 10; // d'un dígit

// Si la temperatura és negativa, mostreu el signe de temperatura;

if (temp_flag == 0) {Display_Neg (1);} else {Display_Neg (0);} if (temp_int_1> 0) // if result is triple-number number {Display_Dig (temp_int_1, 45, 0); // mostra 1 dígit de temperatura Display_Dig (temp_int_2, 54, 0); // mostra 2 dígits de temperatura Display_Dig (temp_int_3, 63, 0); // mostra 3 dígits de temperatura} else {if (temp_int_2> 0) // if result is two-digit number {Off_Dig (45, 0); // esborreu 1 signe de número Display_Dig (temp_int_2, 54, 0); // mostra 1 dígit de temperatura Display_Dig (temp_int_3, 63, 0); // mostra 2 dígits de temperatura} else // si el resultat és un número d'un sol dígit {Off_Dig (45, 0); // esborreu 1 signe del número Off_Dig (54, 0); // esborreu 2 signes de número Display_Dig (temp_int_3, 63, 0); // mostra 1 dígit de temperatura}}}

// Aquest ISR s'activa sempre que es produeix una coincidència amb el recompte de temporitzador amb el valor de comparació (cada 1 segon) ISR (TIMER1_COMPA_vect) {// Lectura, visualització de temperatura i nivell de llum Read_Temp (); Llegir_Lux (); }

// Funció per mostrar les paraules "TEMP" i "LUX" void Display_label () {// Word "TEMP" Display_SetXY (0, 0); // Estableix l'adreça de posició a la pantalla (fila superior) per a (int index = 0; index <105; index ++) {if (index == 40) {Display_SetXY (0, 1);} // Establir l'adreça de posició a la pantalla (fila inferior) if (índex == 80) {Display_SetXY (72, 0);} // Estableix l'adreça de posició a la pantalla (fila superior) if (index == 92) {Display_SetXY (72, 1); } // Estableix l'adreça de posició a la pantalla (fila inferior) SPDR = TEMP_1 [índex]; // Carregueu dades de matriu de codis a la memòria intermèdia de visualització mentre (! (SPSR & (1 << SPIF))); // Espereu fins que la transmissió finalitzi _delay_ms (10); } // Paraula "LUX" Display_SetXY (0, 2); // Estableix l'adreça de posició a la pantalla (fila superior) per a (int index = 0; index <60; index ++) {if (index == 30) {Display_SetXY (0, 3);} // Establir l'adreça de posició a la pantalla (fila inferior) SPDR = TEMP_2 [índex]; // Carregueu dades de matriu de codis a la memòria intermèdia de visualització mentre (! (SPSR & (1 << SPIF))); // Espereu fins que la transmissió finalitzi _delay_ms (10); }}

int main (buit)

{Port_Init (); // Inicialització del port ADC_init (); // Inicialització ADC SPI_Init (); // Inicialització SPI SPI_SS_Enable (); // Visualització Activa DS18B20_init (); // Inicialització de DS18B20 Display_init (); // Visualització de la inicialització Display_Clear (); // Mostra clar Display_label (); // Mostra les paraules "TEMP" i "LUX" TIMER1_init (); // Temporitzador1 Inicialització. Comenceu a supervisar. Obtenir paràmetres cada segon. // Bucle infinit mentre (1) {}}

Pas 3: Firmware intermitent al microcontrolador

Carregant fitxer HEX a la memòria flash del microcontrolador. Mireu el vídeo amb una descripció detallada de la gravació de memòria flash del microcontrolador: gravació de memòria flash del microcontrolador …

Pas 4: supervisió del muntatge del circuit del dispositiu

Connecteu els components segons el diagrama esquemàtic.

Connecteu l'alimentació i funciona.