Monitor de temperatură și nivel de lumină cu afișare pe LCD NOKIA 5110: 4 pași

2024 Autor: John Day | [email protected]. Modificat ultima dată: 2024-01-30 11:44

Bună ziua tuturor!

În această secțiune realizăm un dispozitiv electronic simplu pentru a monitoriza temperatura și nivelul de lumină. Măsurătorile acestor parametri sunt afișate pe ecranul LCD NOKIA 5110. Dispozitivul se bazează pe microcontrolerul AVR ATMEGA328P. Dispozitivul de monitorizare este echipat cu termometru digital DS18B20 și fotorezistor pentru a măsura nivelul luminii.

Pasul 1: Descrierea componentelor

Componentele de bază ale dispozitivului de monitorizare:

• Microcontroler AVR «ATMEGA328P»
• Monocrom LCD grafic «NOKIA 5110»
• Rezoluție programabilă Termometru digital cu 1 fir „DS18B20”
• Rezistor dependent de lumină
• Fire

Microcontroler AVR «ATMEGA328P»

Dispozitivul de monitorizare utilizează următoarele caracteristici periferice ale microcontrolerului:

1. Timer de 16 biți / întrerupere contor
2. ADC pe 8 canale pe 10 biți
3. Interfață serial master / slave SPI

Monocrom LCD grafic «NOKIA 5110»

Specificații:

1. Afișaj LCD 48 x 84 puncte
2. Interfață Serial Bus cu viteză maximă maximă de 4 Mbits / S
3. Controler / driver intern «PCD8544»
4. Iluminare din spate cu LED
5. Rulați la tensiunea 2,7-5 volți
6. Consum redus de putere; este potrivit pentru aplicații cu baterii
7. Intervalul de temperatură de la -25˚C la + 70˚C
8. Suport semnal CMOS intrare

Manipularea adresei LCD (adresare):

Aranjamentul adresei de memorie care este afișat pe afișajul LCD (DDRAM) este Matrix care constă din 6 rânduri (Adresa Y) de la adresa Y 0 la adresa Y 5 și 84 coloane (Adresa X) de la Adresa X 0 până la X- Adresa 83. Dacă utilizatorul dorește să acceseze poziția de afișare a rezultatului pe ecranul LCD, trebuie să se refere la relația dintre adresa X și adresa Y.

Datele care vor fi trimise pentru afișare sunt de 8 biți (1 octet) și vor fi aranjate ca linie verticală; în acest caz, Bit MSB va fi mai mic și Bit LSB va fi superior așa cum se arată în imagine.

Rezoluție programabilă Termometru digital cu 1 fir DALLAS «DS18B20»

Caracteristici:

1. Interfața unică cu 1 fir necesită un singur pin pentru comunicare
2. Reduceți numărul de componente cu senzor de temperatură integrat și EEPROM
3. Măsurează temperaturi de la -55 ° C la + 125 ° C (-67 ° F la + 257 ° F)
4. ± 0,5 ° C Precizie de la -10 ° C la + 85 ° C
5. Rezoluție programabilă de la 9 biți la 12 biți
6. Nu sunt necesare componente externe
7. Modul de alimentare parazită necesită doar 2 pini pentru funcționare (DQ și GND)
8. Simplifică aplicațiile distribuite de detectare a temperaturii cu funcționalitate Multidrop
9. Fiecare dispozitiv are un cod serial unic pe 64 de biți stocat în ROM-ul de bord
10. Setări de alarmă flexibile definite de utilizator nonvolatile (NV) cu comandă de căutare alarmă identifică dispozitivele cu temperaturi în afara limitelor programate

Aplicații:

1. Comenzi termostatice
2. Sisteme industriale
3. Produse pentru consumatori
4. Termometre
5. Sisteme sensibile termic

Rezistor dependent de lumină

Light Dependent Resistor (LDR) este un traductor care își schimbă rezistența atunci când lumina cade pe suprafața sa.

De obicei, un LDR va avea de la un megaOhm la doi megaOhms la întuneric total, de la zece la douăzeci de kiloOhms la zece LUX, de la doi la cinci kiloohmi la 100 LUX. Rezistența dintre cele două contacte ale senzorului scade odată cu intensitatea luminii sau conductanța dintre cele două contacte ale senzorului crește.

Utilizați circuitul divizor de tensiune pentru a converti schimbarea rezistenței la schimbarea tensiunii.

Pasul 2: Codul firmware-ului microcontrolerului

#ifndef F_CPU # define F_CPU 16000000UL // indicând frecvența cristalului controlerului (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 este PORT B, PIN 2

// RESETĂ AFIȘAREA #define RST 0 // RESET este PORT B, PIN 0

// DISPLAY MODE SELECT - Intrare pentru a selecta fie comanda / adresa, fie introducerea datelor. #define DC 1 // DC este PORT B, PIN 1

// matrice de coduri de semn negativ const nesemnat neg negativ [4] = {0x30, 0x30, 0x30, 0x30};

// matrice de coduri de cifre [0..9] constant const nesemnat font 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, 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, 0x0, 0x0, 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};

// matrice de coduri ale cuvântului "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, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 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, 0x0C 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01,};

// matrice de coduri ale cuvântului "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, 0x0, 0x0, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01};

#include

#include #include

// Port Initializationvoid Port_Init () {DDRB = (1 << MOSI) | (1 << SCK) | (1 << SS) | (1 << RST) | (1 << DC); // Set MOSI, SCK, SS, RST, DC ca ieșire, toate celelalte intrări PORTB | = (1 << RST); // Setați pinul RST ca ridicat PORTB | = (1 << SS); // Setați pinul SS ca înalt - Afișajul este Dezactivează DDRC = 0xFFu; // Setați toți pinii PORTC ca ieșire. DDRC & = ~ (1 << 0); // Face primul pin al PORTC ca intrare PORTC = 0x00u; // Setați toți pinii PORTC jos, ceea ce îl oprește. }

// ADC Initialization void ADC_init () {// Activați ADC, eșantionarea frecv = osc_freq / 128 setați prescalerul la valoarea maximă, 128 ADCSRA | = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); ADMUX = (1 << REFS0); // Selectați referința de tensiune pentru ADC // Selectați canalul zero în mod implicit utilizând registrul ADC Multiplexer Select (ADC0). }

// Funcția de a citi rezultatul conversiei analogice în digitale uint16_t get_LightLevel () {_delay_ms (10); // Așteptați un timp pentru ca canalul să fie selectat ADCSRA | = (1 << ADSC); // Porniți conversia ADC setând bitul ADSC. scrieți 1 către ADSC while (ADCSRA & (1 << ADSC)); // așteptați finalizarea conversiei // ADSC devine din nou 0 până atunci, rulați bucla continuu _delay_ms (10); returnare (ADC); // Returnează rezultatul de 10 biți}

// SPI Initialization void SPI_Init () {SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // Activați SPI, setați ca Master, setați Prescalerul ca Fosc / 16 în controlul SPI Inregistreaza-te }

// inițializați 16 biți Timer1, întrerupere și gol variabil TIMER1_init () {// configurați temporizatorul cu prescaler = 256 și modul CTC TCCR1B | = (1 << WGM12) | (1 << CS12); // inițializează contorul TCNT1 = 0; // inițializează valoarea de comparare - 1 sec OCR1A = 62500; // activați întreruperea comparării TIMSK1 | = (1 << OCIE1A); // activează întreruperile globale sei (); }

// Afișare Enable void SPI_SS_Enable () {PORTB & = ~ (1 << SS); // Activați pinul SS în logică 0}

// Afișare Dezactivare void SPI_SS_Disable () {PORTB | = (1 << SS); // Dezactivați pinul SS în logică 1}

// Funcția de a trimite date în buffer-ul de afișare gol SPI_Tranceiver (date de caractere nesemnate) {SPDR = date; // Încărcați datele în buffer while (! (SPSR & (1 << SPIF))); // Așteptați până se finalizează transmisia}

// Resetați afișajul la începutul inițializării void Display_Reset () {PORTB & = ~ (1 << RST); _delay_ms (100); PORTB | = (1 << RST); }

// Funcția de scriere a comenzii void Display_Cmnd (date de caractere nesemnate) {PORTB & = ~ (1 << DC); // faceți pinul DC la logica 0 pentru operația de comandă SPI_Tranceiver (date); // trimite date pe registrul de date PORTB | = (1 << DC); // face pinul DC la logica mare pentru operarea datelor}

// Inițializarea Display void Display_init () {Display_Reset (); // resetați afișajul Display_Cmnd (0x21); // set de comenzi în modul suplimentar Display_Cmnd (0xC0); // setați tensiunea prin trimiterea C0 înseamnă VOP = 5V Display_Cmnd (0x07); // setați temperatura. coeficient la 3 Display_Cmnd (0x13); // setează valoarea Voltage Bias System Display_Cmnd (0x20); // set de comenzi în modul de bază Display_Cmnd (0x0C); // afișează rezultatul în modul normal}

// Ștergeți Afișajul gol Display_Clear () {PORTB | = (1 << DC); // faceți pinul DC la logică mare pentru operarea datelor pentru (int k = 0; k <= 503; k ++) {SPI_Tranceiver (0x00);} PORTB & = ~ (1 << DC); // faceți pinul DC la logică zero pentru operația de comandă}

// setați coloana și rândul la poziția de afișare a rezultatului pe afișajul LCD void Display_SetXY (unsigned char x, unsigned char y) {Display_Cmnd (0x80 | x); // coloana (0-83) Display_Cmnd (0x40 | y); // rând (0-5)}

// Funcția de afișare a semnului negativ nul Display_Neg (nesemnat neg negativ) {Display_SetXY (41, 0); // Setați adresa poziției afișate pentru (int index = 0; index0) {SPDR = 0x30;} // Încărcați datele în buffer-ul afișajului (afișați semnul negativ) altceva {SPDR = 0x00;} // Încărcați datele în buffer-ul afișajului (semn negativ clar) while (! (SPSR & (1 << SPIF))); // Așteptați până când transmisia se finalizează _delay_ms (100); }}

// Funcția de a șterge semnul digital void Off_Dig (caractere nesemnate x, caractere nesemnate y) {Display_SetXY (x, y); // Setați adresa poziției afișate (rândul de sus) pentru (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Încărcați datele în buffer-ul afișajului (ștergeți partea superioară a semnului digital) y ++; Display_SetXY (x, y); // Setați adresa poziției afișate (rândul de jos) pentru (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Încărcați datele în buffer-ul afișajului (clar partea de jos a semnului digital)}

// Funcția de afișare a semnului digital nul Afișare_Dig (săpare int, caracter nesemnat x, caracter nesemnat y) {Display_SetXY (x, y); // Setați adresa poziției pe afișaj (rândul de sus) pentru (int index = 0; index <16; index ++) {if (index == 8) {y ++; Display_SetXY (x, y);} // Setați adresa poziției pe afișaj (rândul de jos) SPI_Tranceiver (font6x8 [dig] [index]); // Încărcați codul de date de cifre în buffer-ul afișajului _delay_ms (10); }}

// Inițializarea DS18B20 nesemnat DS18B20_init () {DDRD | = (1 << 2); // Setați pinul PD2 al PORTD ca ieșire PORTD & = ~ (1 << 2); // Setați pinul PD2 ca _delay_us redus (490); // Timp de inițializare DDRD & = ~ (1 << 2); // Setați pinul PD2 al PORTD ca intrare _delay_us (68); // Timing OK_Flag = (PIND & (1 << 2)); // obțineți impulsul senzorului _delay_us (422); returnează OK_Flag; // returnează senzorul 0-ok este conectat, senzorul cu 1 eroare este deconectat}

// Funcția de citit octet din DS18B20 unsigned char read_18b20 () {unsigned char i, data = 0; pentru (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Setați pinul PD2 al PORTD ca ieșire _delay_us (2); // Timing DDRD & = ~ (1 1; // Următorul bit if (PIND & (1 << 2)) data | = 0x80; // pune bitul în octet _delay_us (62);} returnează datele;}

// Funcția de a scrie octet în DS18B20 void write_18b20 (date de caractere nesemnate) {unsigned char i; pentru (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Setați pinul PD2 al PORTD ca ieșire _delay_us (2); // Timing if (data & 0x01) DDRD & = ~ (1 << 2); // dacă vrem să scriem 1, eliberați linia else DDRD | = (1 1; // Bitul următor _delay_us (62); // Timing DDRD & = ~ (1 << 2); // Setați pinul PD2 al PORTD ca intrare _delay_us (2);}}

// Funcție pentru afișarea nivelului de lumină gol Read_Lux () {uint16_t buffer; unsigned int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // cifre unice, cifre duble, cifre triple, sfert de cifre tampon = get_LightLevel (); // citiți rezultatul analogului în digital converti nivelul luminii temp_int_0 = buffer% 10000/1000; // sfert de cifră temp_int_1 = tampon% 1000/100; // cu trei cifre temp_int_2 = tampon% 100/10; // cu două cifre temp_int_3 = tampon% 10; // cu o singură cifră dacă (temp_int_0> 0) // dacă rezultatul este numărul de un sfert de cifră {Display_Dig (temp_int_0, 32, 2); // afișează 1 cifră a nivelului de lumină Display_Dig (temp_int_1, 41, 2); // afișează 2 cifre ale nivelului de lumină Display_Dig (temp_int_2, 50, 2); // afișează 3 cifre ale nivelului de lumină Display_Dig (temp_int_3, 59, 2); // afișează 4 cifre ale nivelului de lumină} else {if (temp_int_1> 0) // if result is three-digit number {Off_Dig (32, 2); // ștergeți 1 semn al numărului Display_Dig (temp_int_1, 41, 2); // afișează 1 cifră a nivelului de lumină Display_Dig (temp_int_2, 50, 2); // afișează 2 cifre ale nivelului de lumină Display_Dig (temp_int_3, 59, 2); // afișează 3 cifre ale nivelului de lumină} else {if (temp_int_2> 0) // dacă rezultatul este numărul de două cifre {Off_Dig (32, 2); // ștergeți 1 semn al numărului Off_Dig (41, 2); // ștergeți 2 semne ale numărului Display_Dig (temp_int_2, 50, 2); // afișează 1 cifră a nivelului de lumină Display_Dig (temp_int_3, 59, 2); // afișează 2 cifre ale nivelului de lumină} altfel // dacă rezultatul este un număr dintr-o singură cifră {Off_Dig (32, 2); // ștergeți 1 semn al numărului Off_Dig (41, 2); // ștergeți 2 semnul numărului Off_Dig (50, 2); // ștergeți 3 semne ale numărului Display_Dig (temp_int_3, 59, 2); // afișează 1 cifră a nivelului de lumină}}}}

// Funcția de afișare a temperaturii nul Read_Temp () {unsigned int buffer; unsigned int temp_int_1, temp_int_2, temp_int_3; // cifre simple, cifre duble, cifre triple, cifre sferturi nesemnate caractere Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init (); // Initializarea DS18B20 write_18b20 (0xCC); // Verificare cod senzor write_18b20 (0x44); // Începe conversia temperaturii _delay_ms (1000); // Întârziere interogare senzor DS18B20_init (); // Initializarea DS18B20 write_18b20 (0xCC); // Verificare cod senzor write_18b20 (0xBE); // Comandă pentru citirea conținutului senzorului RAM Temp_L = read_18b20 (); // Citiți primii doi octeți Temp_H = read_18b20 (); temp_flag = 1; // 1-temperatură pozitivă, 0-temperatură negativă // Obțineți temperatură negativă dacă (Temp_H & (1 << 3)) // Verificați bitul de semnare (dacă bitul este setat - temperatura negativă) {semnat int temp; temp_flag = 0; // steagul este setat 0 - temperatura negativă temp = (Temp_H << 8) | Temp_L; temp = -temp; // Conversia codului suplimentar în direct Temp_L = temp; Temp_H = temp >> 8; } buffer = ((Temp_H 4); temp_int_1 = buffer% 1000/100; // triple-digit temp_int_2 = buffer% 100/10; // double-digit temp_int_3 = buffer% 10; // single-digit

// Dacă temperatura este negativă, afișați semnul temperaturii, altfel clar

if (temp_flag == 0) {Display_Neg (1);} else {Display_Neg (0);} if (temp_int_1> 0) // if result is three-digit number {Display_Dig (temp_int_1, 45, 0); // afișează 1 cifră a temperaturii Display_Dig (temp_int_2, 54, 0); // afișează 2 cifre de temperatură Display_Dig (temp_int_3, 63, 0); // afișează 3 cifre de temperatură} else {if (temp_int_2> 0) // if result is double-digit number {Off_Dig (45, 0); // ștergeți 1 semn al numărului Display_Dig (temp_int_2, 54, 0); // afișează 1 cifră a temperaturii Display_Dig (temp_int_3, 63, 0); // afișează 2 cifre de temperatură} altfel // dacă rezultatul este un număr dintr-o singură cifră {Off_Dig (45, 0); // ștergeți 1 semn al numărului Off_Dig (54, 0); // ștergeți 2 semne ale numărului Display_Dig (temp_int_3, 63, 0); // afișează 1 cifră de temperatură}}}

// Acest ISR este declanșat ori de câte ori apare o potrivire a numărului de timer cu valoarea de comparare (la fiecare 1 secundă) ISR (TIMER1_COMPA_vect) {// Citire, afișare a temperaturii și a nivelului de lumină Read_Temp (); Read_Lux (); }

// Funcția de afișare a cuvintelor „TEMP” și „LUX” void Display_label () {// Word „TEMP” Display_SetXY (0, 0); // Setați adresa poziției afișate (rândul sus) pentru (int index = 0; index <105; index ++) {if (index == 40) {Display_SetXY (0, 1);} // Setați adresa poziției pe afișaj (rândul de jos) if (index == 80) {Display_SetXY (72, 0);} // Setați adresa poziției pe display (rândul sus) if (index == 92) {Display_SetXY (72, 1); } // Setați adresa poziției pe afișaj (rândul de jos) SPDR = TEMP_1 [index]; // Încărcați datele matricii de coduri în bufferul de afișare while (! (SPSR & (1 << SPIF))); // Așteptați până când transmisia se finalizează _delay_ms (10); } // Cuvântul „LUX” Display_SetXY (0, 2); // Setați adresa poziției afișate (rândul sus) pentru (int index = 0; index <60; index ++) {if (index == 30) {Display_SetXY (0, 3);} // Setați adresa poziției pe afișaj (rândul de jos) SPDR = TEMP_2 [index]; // Încărcați datele matricii de coduri în bufferul de afișare while (! (SPSR & (1 << SPIF))); // Așteptați până când transmisia se finalizează _delay_ms (10); }}

int main (nul)

{Port_Init (); // Inițializare port ADC_init (); // Inițializare ADC SPI_Init (); // Inițializare SPI SPI_SS_Enable (); // Afișare Activare DS18B20_init (); // Initializarea DS18B20 Display_init (); // Afișare inițializare Display_Clear (); // Afișați clar Display_label (); // Afișați cuvintele „TEMP” și „LUX” TIMER1_init (); // Inițializare Timer1. Începeți monitorizarea. Obținerea parametrilor la fiecare secundă. // Bucla infinit în timp ce (1) {}}

Pasul 3: Firmware intermitent pe microcontroler

Încărcarea fișierului HEX în memoria flash a microcontrolerului. Urmăriți videoclipul cu o descriere detaliată a arderii memoriei flash a microcontrolerului: arderea memoriei flash a microcontrolerului …

Pasul 4: Monitorizarea ansamblului circuitului dispozitivului

Conectați componentele în conformitate cu diagrama schematică.

Conectați alimentarea și funcționează!