Temperatur- og lysnivåmonitor med visning på LCD NOKIA 5110: 4 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:23

Hei alle sammen!

I denne delen lager vi en enkel elektronisk enhet for å overvåke temperatur og lysnivå. Målinger av disse parameterne vises på LCD NOKIA 5110. Enheten er basert på mikrokontrolleren AVR ATMEGA328P. Overvåkingsenheten er utstyrt med DS18B20 digitalt termometer og fotoresistor for å måle lysnivå.

Trinn 1: Beskrivelse av komponenter

Grunnleggende komponenter i overvåkingsenheten:

• Mikrokontroller AVR «ATMEGA328P»
• Monokrom grafisk LCD «NOKIA 5110»
• Programmerbar oppløsning 1-tråds digitalt termometer «DS18B20»
• Lysavhengig motstand
• Ledninger

Mikrokontroller AVR «ATMEGA328P»

Overvåkingsenheten bruker følgende perifere funksjoner i mikrokontrolleren:

1. 16-bit Timer/Counter-avbrudd
2. 8-kanals 10-biters ADC
3. Master/slave SPI serielt grensesnitt

Monokrom grafisk LCD «NOKIA 5110»

Spesifikasjoner:

1. 48 x 84 Dot LCD -skjerm
2. Serielt bussgrensesnitt med maksimal høy hastighet 4 Mbits/S
3. Intern kontroller/driver «PCD8544»
4. LED-baklys
5. Kjør på spenning 2,7-5 volt
6. Lavt energiforbruk; den er egnet for batteri
7. Temperaturområde fra -25˚C til +70˚C
8. Støttesignal CMOS -inngang

Håndtering av LCD -adresse (adressering):

Adressearrangementet for minne som vises på LCD-skjerm (DDRAM) er Matrix som består av 6 rader (Y-adresse) fra Y-adresse 0 til Y-adresse 5 og 84 kolonner (X-adresse) fra X-adresse 0 til X- Adresse 83. Hvis brukeren ønsker å få tilgang til posisjonen for å vise resultatet på LCD-skjermen, må det referere til forholdet mellom X-adresse og Y-adresse.

Data som skal sendes til visning er 8 bit (1 Byte), og de vil bli ordnet som en vertikal linje; i dette tilfellet vil Bit MSB være lavere og Bit LSB være øvre som vist på bildet.

Programmerbar oppløsning 1-tråds digitalt termometer DALLAS «DS18B20»

Funksjoner:

1. Unikt 1-Wire®-grensesnitt krever bare en portnål for kommunikasjon
2. Reduser antall komponenter med integrert temperatursensor og EEPROM
3. Måler temperaturer fra -55 ° C til +125 ° C (-67 ° F til +257 ° F)
4. ± 0,5 ° C Nøyaktighet fra -10 ° C til +85 ° C
5. Programmerbar oppløsning fra 9 bit til 12 bit
6. Ingen eksterne komponenter kreves
7. Parasittisk strømmodus krever bare 2 pins for drift (DQ og GND)
8. Forenkler distribuerte temperaturfølende applikasjoner med multidrop-evne
9. Hver enhet har en unik 64-biters seriekode lagret i innebygd ROM
10. Fleksibel brukerdefinerbar ikke-flyktig (NV) alarminnstilling med alarmsøkekommando Identifiserer enheter med temperaturer utenfor programmerte grenser

Applikasjoner:

1. Termostatiske kontroller
2. Industrielle systemer
3. Forbrukerprodukter
4. Termometre
5. Termisk følsomme systemer

Lysavhengig motstand

Lysavhengig motstand (LDR) er en transduser som endrer motstanden når lys faller på overflaten endres.

Vanligvis vil en LDR ha fra en megaOhm til to megaOhm ved totalt mørke, fra ti til tjue kiloOhm ved ti LUX, fra to til fem kiloohms ved 100 LUX. Motstanden mellom sensorens to kontakter reduseres med lysintensiteten eller konduktansen mellom to kontakter av sensoren øker.

Bruk spenningsdelerkrets for å konvertere endring i motstand til endring i spenning.

Trinn 2: Firmware -kode for mikrokontroller

#ifndef F_CPU #definere F_CPU 16000000UL // forteller kontrollerkrystallfrekvens (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 det er PORT B, PIN 2

// NULLSTILL DISPLAYEN #definer RST 0 // RESET det er PORT B, PIN 0

// DISPLAY MODE SELECT - Inngang for å velge enten kommando/adresse eller datainngang. #define DC 1 // DC det er PORT B, PIN 1

// koder array med negative signstatiske const usignerte char neg [4] = {0x30, 0x30, 0x30, 0x30};

// koder matrise med sifre [0..9] statisk const usignert 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, 0x06, 0x0,, 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, 0x01}, // 5 { 0xFE, 0xFE, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 6 {0x04, 0x06, 0x06, 0x6, 0x6, 0xE, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00}, // 7 {0xCC, 0xFE, 0xFE, 0x36, 0x36, 0xFE, 0xFE, 0xCC, 0x01, 0x03, 0x03, 0x0, 0x0, 0x0 3, 0x01}, // 8 {0x3C, 0x7E, 0x7E, 0x66, 0x66, 0xFE, 0xFE, 0xFC, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01} // 9};

// koder array av ordet "TEMP:" statisk konstant usignert tegn 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, 0x7, 0x8, 0x8, 0x8 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, 0x0, 0x8 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01,};

// koder array av ordet "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, 0x0, 0x0, 0x0, 0x0, 0x0,, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01};

#inkludere

#include #include

// Portinitialiseringvoid Port_Init () {DDRB = (1 << MOSI) | (1 << SCK) | (1 << SS) | (1 << RST) | (1 << DC); // Sett MOSI, SCK, SS, RST, DC som output, alle andre input PORTB | = (1 << RST); // Sett RST pin så høy PORTB | = (1 << SS); // Sett SS pin som høy - Display er Deaktiver DDRC = 0xFFu; // Sett alle pinnene på PORTC som utgang. DDRC & = ~ (1 << 0); // Gjør første pin av PORTC som Input PORTC = 0x00u; // Sett alle pinnene på PORTC lavt som slår den av. }

// ADC Initialization void ADC_init () {// Enable ADC, sampling freq = osc_freq/128 set prescaler to max value, 128 ADCSRA | = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); ADMUX = (1 << REFS0); // Velg spenningsreferanse for ADC // Velg kanal null som standard ved hjelp av ADC Multiplexer Select register (ADC0). }

// Funksjon for å lese resultatet av analog til digital konvertering uint16_t get_LightLevel () {_delay_ms (10); // Vent litt til kanalen får valgt ADCSRA | = (1 << ADSC); // Start ADC -konverteringen ved å sette ADSC -bit. skriv 1 til ADSC mens (ADCSRA & (1 << ADSC)); // vent på at konverteringen er fullført // ADSC blir 0 igjen til da, kjør sløyfe kontinuerlig _delay_ms (10); retur (ADC); // Returner 10-bits resultatet}

// SPI Initialization void SPI_Init () {SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // Aktiver SPI, Sett som Master, Sett Prescaler som Fosc/16 i SPI -kontroll registrere }

// initialiser 16 bit Timer1, interrupt og variabelt tomrom TIMER1_init () {// set up timer with prescaler = 256 and CTC mode TCCR1B | = (1 << WGM12) | (1 << CS12); // initialiser telleren TCNT1 = 0; // initialiser sammenligningsverdi - 1 sek. OCR1A = 62500; // aktiver sammenligne avbryt TIMSK1 | = (1 << OCIE1A); // muliggjøre globale avbrudd sei (); }

// Vis Aktiver tomrom SPI_SS_Enable () {PORTB & = ~ (1 << SS); // Aktiver SS -pinnen til logikk 0}

// Display Disable void SPI_SS_Disable () {PORTB | = (1 << SS); // Deaktiver SS -pinnen til logikk 1}

// Funksjon for å sende data til displaybufferrommet SPI_Tranceiver (usignerte char -data) {SPDR = data; // Last data inn i bufferen mens (! (SPSR & (1 << SPIF))); // Vent til overføringen er fullført}

// Tilbakestill displayet i begynnelsen av initialiseringen void Display_Reset () {PORTB & = ~ (1 << RST); _forsinkelse_ms (100); PORTB | = (1 << RST); }

// Kommando -skrivefunksjon void Display_Cmnd (usignerte char -data) {PORTB & = ~ (1 << DC); // lage DC -pin til logikk 0 for kommandodrift SPI_Tranceiver (data); // sende data om dataregister PORTB | = (1 << DC); // gjør DC -pin til logikk høy for datadrift}

// Initialisering av Display ugyldig Display_init () {Display_Reset (); // tilbakestill display_Cmnd (0x21); // kommando satt i tilleggsmodus Display_Cmnd (0xC0); // angi spenningen ved å sende C0 betyr VOP = 5V Display_Cmnd (0x07); // angi temp. koeffisient til 3 Display_Cmnd (0x13); // sett verdi for Spenningsskjevhet System Display_Cmnd (0x20); // kommando satt i grunnmodus Display_Cmnd (0x0C); // vis resultat i normal modus}

// Fjern visningsrommet Display_Clear () {PORTB | = (1 << DC); // gjør DC pin til logikk høy for datadrift for (int k = 0; k <= 503; k ++) {SPI_Tranceiver (0x00);} PORTB & = ~ (1 << DC); // lage DC pin til logikk null for kommandooperasjon}

// sett kolonnen og raden til posisjonen for å vise resultatet på LCD -displayet ugyldig Display_SetXY (usignert tegn x, usignert tegn y) {Display_Cmnd (0x80 | x); // kolonne (0-83) Display_Cmnd (0x40 | y); // rad (0-5)}

// Funksjon for å vise negativt tegn ugyldig Display_Neg (usignert tegn) {Display_SetXY (41, 0); // Angi posisjonsadressen på displayet for (int index = 0; index0) {SPDR = 0x30;} // Last data i bufferen på displayet (vis negativt tegn) ellers {SPDR = 0x00;} // Last data inn i visningsbufferen (klart negativt tegn) mens (! (SPSR & (1 << SPIF))); // Vent til overføringen er fullført _delay_ms (100); }}

// Funksjon for å slette det digitale tegnet ugyldig Off_Dig (usignert tegn x, usignert tegn) {Display_SetXY (x, y); // Angi posisjonsadressen på displayet (øverste rad) for (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Last data i bufferen på displayet (fjern øverste del av digitalt tegn) y ++; Display_SetXY (x, y); // Angi adressen til posisjonen på skjermen (nederste rad) for (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Last data i bufferen på displayet (tydelig nederste del av digitalt skilt)}

// Funksjon for å vise digitalt tegn ugyldig Display_Dig (int dig, unsigned char x, unsigned char y) {Display_SetXY (x, y); // Angi adressen til posisjonen på displayet (øverste rad) for (int index = 0; index <16; index ++) {if (index == 8) {y ++; Display_SetXY (x, y);} // Angi adressen til posisjonen på skjermen (nederste rad) SPI_Tranceiver (font6x8 [dig] [index]); // Last inn koder matrise med sifrede data i bufferen til display _delay_ms (10); }}

// Initialisering av DS18B20 usignerte char DS18B20_init () {DDRD | = (1 << 2); // Sett PD2 -pinne på PORTD som utgang PORTD & = ~ (1 << 2); // Sett PD2 -pin som lav _forsinkelse_us (490); // Initialiseringstidspunkt DDRD & = ~ (1 << 2); // Angi PD2 -pin på PORTD som input _delay_us (68); // Timing OK_Flag = (PIND & (1 << 2)); // få sensorpuls _delay_us (422); returner OK_Flag; // return 0-ok sensor er plugg, 1-error sensor er koble fra}

// Funksjon for å lese byte fra DS18B20 usignerte char read_18b20 () {usignerte char i, data = 0; for (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Angi PD2 -pin på PORTD som utgang _delay_us (2); // Timing DDRD & = ~ (1 1; // Neste bit hvis (PIND & (1 << 2)) data | = 0x80; // legg bit inn i byte _delay_us (62);} returner data;}

// Funksjon for å skrive byte til DS18B20 void write_18b20 (usignerte char -data) {unsigned char i; for (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Angi PD2 -pin på PORTD som utgang _delay_us (2); // Timing if (data & 0x01) DDRD & = ~ (1 << 2); // hvis vi vil skrive 1, slipp linjen ellers DDRD | = (1 1; // Neste bit _delay_us (62); // Timing DDRD & = ~ (1 << 2); // Sett PD2 -pin på PORTD som input _delay_us (2);}}

// Funksjon for å vise ugyldig lysnivå Read_Lux () {uint16_t buffer; usignert int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // enkelt siffer, to sifre, trippel siffer, kvart siffer buffer = get_LightLevel (); // les resultatet av analog til digital konvertere lysnivå temp_int_0 = buffer % 10000 /1000; // kvartssifret temp_int_1 = buffer % 1000 /100; // tresifret temp_int_2 = buffer % 100 /10; // tosifret temp_int_3 = buffer % 10; // ensifret hvis (temp_int_0> 0) // hvis resultatet er kvartssifret tall {Display_Dig (temp_int_0, 32, 2); // vise 1 siffer med lysnivå Display_Dig (temp_int_1, 41, 2); // vise 2 siffer lysnivå Display_Dig (temp_int_2, 50, 2); // vise 3 siffer lysnivå Display_Dig (temp_int_3, 59, 2); // vise 4 siffer lysnivå} annet {if (temp_int_1> 0) // hvis resultatet er tresifret tall {Off_Dig (32, 2); // fjern 1 tegn på tallet Display_Dig (temp_int_1, 41, 2); // vise 1 siffer med lysnivå Display_Dig (temp_int_2, 50, 2); // vise 2 siffer lysnivå Display_Dig (temp_int_3, 59, 2); // vise 3 siffer med lysnivå} annet {if (temp_int_2> 0) // hvis resultatet er tosifret tall {Off_Dig (32, 2); // fjern 1 tegn på nummeret Off_Dig (41, 2); // slett 2 tegn på tallet Display_Dig (temp_int_2, 50, 2); // vise 1 siffer med lysnivå Display_Dig (temp_int_3, 59, 2); // vise 2 siffer med lysnivå} annet // hvis resultatet er ensifret tall {Off_Dig (32, 2); // fjern 1 tegn på nummeret Off_Dig (41, 2); // slett 2 tegn på nummeret Off_Dig (50, 2); // tøm 3 tegn på tallet Display_Dig (temp_int_3, 59, 2); // vis ett lyssiffer}}}}

// Funksjon for å vise temperaturrommet Read_Temp () {usignert int buffer; usignert int temp_int_1, temp_int_2, temp_int_3; // enkelt siffer, to siffer, trippel siffer, kvart siffer usignert char Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init (); // Initialisering av DS18B20 write_18b20 (0xCC); // Sensorkodekontroll write_18b20 (0x44); // Start temperaturkonvertering _delay_ms (1000); // Forsinkelse av sensoravstemning DS18B20_init (); // Initialisering av DS18B20 write_18b20 (0xCC); // Sensorkodekontroll write_18b20 (0xBE); // Kommando for å lese innholdet i Sensor RAM Temp_L = read_18b20 (); // Les de to første byte Temp_H = read_18b20 (); temp_flag = 1; // 1-positiv temperatur, 0-negativ temperatur // Få negativ temperatur hvis (Temp_H & (1 << 3)) // Sign Bit Check (hvis bit er satt-negativ temperatur) {signert int temp; temp_flag = 0; // flagget er satt 0 - negativ temperatur temp = (Temp_H << 8) | Temp_L; temp = -temp; // Konverter tilleggskoden i direkte Temp_L = temp; Temp_H = temp >> 8; } buffer = ((Temp_H 4); temp_int_1 = buffer % 1000 /100; // tresifret temp_int_2 = buffer % 100 /10; // tosifret temp_int_3 = buffer % 10; // ensifret

// Hvis temperaturen er et negativt tegn på temperatur, er det klart

if (temp_flag == 0) {Display_Neg (1);} else {Display_Neg (0);} if (temp_int_1> 0) // hvis resultatet er tresifret tall {Display_Dig (temp_int_1, 45, 0); // vise 1 siffer med temperatur Display_Dig (temp_int_2, 54, 0); // vise 2 siffer med temperatur Display_Dig (temp_int_3, 63, 0); // vise 3 siffer med temperatur} annet {if (temp_int_2> 0) // hvis resultatet er tosifret tall {Off_Dig (45, 0); // fjern 1 tegn på tallet Display_Dig (temp_int_2, 54, 0); // vise 1 siffer med temperatur Display_Dig (temp_int_3, 63, 0); // vise to siffer med temperatur} annet // hvis resultatet er ensifret tall {Off_Dig (45, 0); // fjern 1 tegn på nummeret Off_Dig (54, 0); // slett 2 tegn på tallet Display_Dig (temp_int_3, 63, 0); // vise 1 siffer med temperatur}}}

// Denne ISR -en utløses hver gang det oppstår en samsvar mellom tidteller og sammenligningsverdi (hvert 1. Sekund) ISR (TIMER1_COMPA_vekt) {// Avlesning, visning av temperatur og lysnivå Read_Temp (); Read_Lux (); }

// Funksjon for å vise ordene "TEMP" og "LUX" ugyldig Display_label () {// Word "TEMP" Display_SetXY (0, 0); // Angi posisjonens adresse på displayet (opp rad) for (int index = 0; index <105; index ++) {if (index == 40) {Display_SetXY (0, 1);} // Angi posisjonens adresse på displayet (nederste rad) hvis (index == 80) {Display_SetXY (72, 0);} // Angi posisjonens adresse på displayet (opp rad) hvis (index == 92) {Display_SetXY (72, 1); } // Angi posisjonsadressen på skjermen (nederste rad) SPDR = TEMP_1 [indeks]; // Last kodematerielldata inn i bufferen på displayet mens (! (SPSR & (1 << SPIF))); // Vent til overføringen er fullført _delay_ms (10); } // Word "LUX" Display_SetXY (0, 2); // Angi posisjonsadressen på displayet (opp rad) for (int index = 0; index <60; index ++) {if (index == 30) {Display_SetXY (0, 3);} // Angi posisjonens adresse på skjermen (nederste rad) SPDR = TEMP_2 [indeks]; // Last kodematerielldata inn i bufferen på displayet mens (! (SPSR & (1 << SPIF))); // Vent til overføringen er fullført _delay_ms (10); }}

int main (ugyldig)

{Port_Init (); // Portinitialisering ADC_init (); // ADC Initialization SPI_Init (); // SPI -initialisering SPI_SS_Enable (); // Display Enable DS18B20_init (); // Initialisering av DS18B20 Display_init (); // Display initialisering Display_Clear (); // Vis tydelig Display_label (); // Vis ord "TEMP" og "LUX" TIMER1_init (); // Timer1 initialisering. Start overvåking. Få parametere hvert sekund. // Infinity loop mens (1) {}}

Trinn 3: Blinker fastvare til mikrokontroller

Laster opp HEX -fil til mikrokontrollerens flashminne. Se videoen med en detaljert beskrivelse av brenning av mikrokontroller -flashminne: Brenning av mikrokontroller -flashminne …

Trinn 4: Overvåking av enhetskretsmontering

Koble til komponenter i henhold til skjematisk diagram.

Plugg strømmen og den fungerer!