Temperatuur- en lichtniveaumonitor met weergave op LCD NOKIA 5110 - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:17

Dag iedereen!

In deze sectie maken we een eenvoudig elektronisch apparaat om de temperatuur en het lichtniveau te bewaken. Metingen van deze parameters worden weergegeven op LCD NOKIA 5110. Het apparaat is gebaseerd op de microcontroller AVR ATMEGA328P. Het bewakingsapparaat is uitgerust met een digitale thermometer DS18B20 en een fotoweerstand om het lichtniveau te meten.

Stap 1: Beschrijving Componenten

Basiscomponenten van het bewakingsapparaat:

• Microcontroller AVR «ATMEGA328P»
• Monochroom grafisch LCD-scherm «NOKIA 5110»
• Programmeerbare resolutie 1-draads digitale thermometer «DS18B20»
• Lichtafhankelijke weerstand:
• Draden

Microcontroller AVR «ATMEGA328P»

Bewakingsapparaat maakt gebruik van de volgende randfuncties van de microcontroller:

1. 16-bits timer/telleronderbreking
2. 8-kanaals 10-bit ADC
3. Master/slave SPI seriële interface

Monochroom grafisch LCD-scherm «NOKIA 5110»

Specificaties:

1. 48 x 84 Dot LCD-scherm
2. Seriële businterface met maximale hoge snelheid 4 Mbits/S
3. Interne controller/stuurprogramma «PCD8544»
4. LED-achtergrondverlichting
5. Run op spanning 2,7-5 Volt
6. Laag energieverbruik; het is geschikt voor batterijtoepassingen;
7. Temperatuurbereik van -25˚C tot +70˚C
8. Ondersteuning Signaal CMOS-ingang:

Behandeling van LCD-adres (adressering):

De adresrangschikking van het geheugen dat wordt weergegeven op het LCD-scherm (DDRAM) is een matrix die bestaat uit 6 rijen (Y-adres) van Y-adres 0 tot Y-adres 5 en 84 kolommen (X-adres) van X-adres 0 tot X- Adres 83. Als de gebruiker toegang wil tot de positie van het weergeven van het resultaat op het LCD-scherm, moet hij verwijzen naar de relatie tussen X-Address en Y-Address.

Gegevens die naar het display worden verzonden, zijn 8 bit (1 byte) en worden gerangschikt als een verticale lijn; in dit geval zal Bit MSB lager zijn en Bit LSB hoger zoals weergegeven in de afbeelding.

Programmeerbare resolutie 1-draads digitale thermometer DALLAS «DS18B20»

Functies:

1. Unieke 1-Wire®-interface vereist slechts één poortpin voor communicatie
2. Verminder het aantal componenten met geïntegreerde temperatuursensor en EEPROM
3. Meet temperaturen van -55 °C tot +125 °C (-67 °F tot +257 °F)
4. ±0,5°C Nauwkeurigheid van -10°C tot +85°C
5. Programmeerbare resolutie van 9 bits tot 12 bits
6. Geen externe componenten nodig
7. Parasitaire voedingsmodus vereist slechts 2 pinnen voor werking (DQ en GND)
8. Vereenvoudigt gedistribueerde temperatuurdetectietoepassingen met multidrop-mogelijkheid
9. Elk apparaat heeft een unieke 64-bits seriële code die is opgeslagen in de ingebouwde ROM
10. Flexibele, door de gebruiker te definiëren niet-vluchtige (NV) alarminstellingen met alarmzoekopdracht Identificeert apparaten met temperaturen buiten de geprogrammeerde limieten

Toepassingen:

1. Thermostatische regelaars
2. Industriële systemen
3. Consumentenproducten
4. Thermometers
5. Thermisch gevoelige systemen

Lichtafhankelijke weerstand:

Light Dependent Resistor (LDR) is een transducer die zijn weerstand verandert wanneer licht op het oppervlak verandert.

Typisch heeft een LDR van één megaOhm tot twee megaOhm bij totale duisternis, van tien tot twintig kiloOhm bij tien LUX, van twee tot vijf kiloohm bij 100 LUX. De weerstand tussen de twee contacten van de sensor neemt af met de lichtintensiteit of de geleidbaarheid tussen twee contacten van de sensor neemt toe.

Gebruik een spanningsdelercircuit om verandering in weerstand om te zetten in verandering in spanning.

Stap 2: Microcontroller-firmwarecode

#ifndef F_CPU#define F_CPU 16000000UL // vertelt de kristalfrequentie van de controller (16 MHz AVR ATMega328P) #endif

// SPI-INTERFACE DEFINITEERT #define MOSI 3 // MOSI het is POORT B, PIN 3 #define MISO 4 // MISO het is POORT B, PIN 4 #define SCK 5 // SCK het is POORT B, PIN 5 #define SS 2 // SS het is POORT B, PIN 2

// RESET HET DISPLAY #define RST 0 // RESET het is POORT B, PIN 0

// DISPLAY MODE SELECT - Invoer om een commando/adres of gegevensinvoer te selecteren. #define DC 1 // DC het is POORT B, PIN 1

// codes array van negatieve signstatic const unsigned char neg [4] = {0x30, 0x30, 0x30, 0x30};

// codes array van cijfers [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, 0x06, 0x26, FE, 0x76, 0x, 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 { 0xFC, 0xFE, 0xFE, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 6 { 0x04, 0x06, 0x06, 0x86, 0xE6, 0xFE,C7E, 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 };

// codes array van woord "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,x0x8 0x00,x 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, 0x00, 0x01, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x0C, 0x1E, 0x33, 0x33, 0x1E, 0x0C, 0x00, 0xF8,0, 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01, };

// codes array van woord "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, 0x01, 0x, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01 };

#erbij betrekken

#include #include

// Port Initializationvoid Port_Init() {DDRB = (1<<MOSI)|(1<<SCK)|(1<<SS)|(1<<RST)|(1<<DC);// Stel MOSI in, SCK, SS, RST, DC als output, alle andere input PORTB |= (1<<RST);// Stel RST-pin in op hoog PORTB |= (1<<SS);// Stel SS-pin in op hoog - Display is DDRC=0xFFu uitschakelen; // Stel alle pinnen van de PORTC in als uitvoer. DDRC &= ~(1<<0);//Maakt de eerste pin van PORTC als invoer PORTC=0x00u; // Stel alle pinnen van PORTC laag in, waardoor het wordt uitgeschakeld. }

// ADC-initialisatie ongeldig ADC_init() {// ADC inschakelen, bemonstering freq=osc_freq/128 prescaler instellen op maximale waarde, 128 ADCSRA |= (1<<ADEN) | (1<<ADPS2)| (1<<ADPS1)| (1<<ADPS0); ADMUX = (1<<REFS0); // Selecteer de spanningsreferentie voor de ADC // Selecteer standaard kanaal nul met behulp van het ADC Multiplexer Select-register (ADC0). }

// Functie om het resultaat te lezen van analoog naar digitaal converteren uint16_t get_LightLevel() { _delay_ms(10); // Wacht enige tijd totdat het kanaal is geselecteerd ADCSRA |= (1<<ADSC); // Start de ADC-conversie door het ADSC-bit in te stellen. schrijf 1 naar ADSC while(ADCSRA & (1<<ADSC)); // wacht tot de conversie is voltooid // ADSC wordt tot die tijd weer 0, voer de lus continu uit _delay_ms (10); retour (ADC); // Retourneer het 10-bits resultaat}

// SPI-initialisatie ongeldig SPI_Init() {SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);//SPI inschakelen, instellen als Master, Prescaler instellen als Fosc/16 in SPI-besturing register }

// initialiseer 16 bit Timer1, interrupt en variabele void TIMER1_init() {// stel timer in met prescaler = 256 en CTC-modus TCCR1B |= (1 << WGM12)|(1 << CS12); // initialiseer teller TCNT1 = 0; // initialiseer vergelijkingswaarde - 1 sec OCR1A = 62500; // inschakelen vergelijken interrupt TIMSK1 |= (1 << OCIE1A); // schakel globale interrupts in sei(); }

//Display Void inschakelen SPI_SS_Enable() {PORTB &= ~(1<<SS); // Schakel de SS-pin in op logische 0}

//Display Uitschakelen ongeldig SPI_SS_Disable() {PORTB |= (1<<SS); // Schakel de SS-pin uit naar logica 1}

// Functie om gegevens naar de weergavebuffer te verzenden void SPI_Tranceiver (unsigned char-gegevens) {SPDR = data; // Laad gegevens in de buffer while(!(SPSR & (1<<SPIF))); // Wacht tot de verzending is voltooid}

// Reset het display aan het begin van de initialisatie void Display_Reset() { PORTB &= ~(1<<RST); _delay_ms(100); PORTB |= (1<<RST); }

// Commando schrijffunctie void Display_Cmnd (unsigned char data) {PORTB &= ~(1<<DC); // maak DC-pin naar logische 0 voor opdrachtbewerking SPI_Tranceiver (data); // stuur gegevens op dataregister PORTB |= (1<<DC); // maak de DC-pin logisch hoog voor gegevensverwerking}

// Initialisatie van Display void Display_init () { Display_Reset (); // reset het display Display_Cmnd (0x21); // opdrachtset in extra modus Display_Cmnd (0xC0); // stel de spanning in door C0 te verzenden betekent VOP = 5V Display_Cmnd (0x07); // stel de temperatuur in. coëfficiënt tot 3 Display_Cmnd (0x13); // ingestelde waarde van Voltage Bias System Display_Cmnd (0x20); // opdracht ingesteld in basismodus Display_Cmnd (0x0C); // toon resultaat in normale modus}

// Wis de weergave leegte Display_Clear () { PORTB |= (1<<DC); // maak DC-pin logisch hoog voor databewerking voor (int k=0; k<=503; k++){SPI_Tranceiver(0x00);} PORTB &= ~(1<<DC);// maak DC-pin logisch nul voor commandobewerking }

// stel de kolom en rij in op de positie waarin het resultaat op het LCD-scherm wordt weergegeven void Display_SetXY (unsigned char x, unsigned char y) { Display_Cmnd (0x80 | x); // kolom (0-83) Display_Cmnd (0x40 | y); // rij (0-5) }

// Functie om negatief teken ongeldig weer te geven Display_Neg (unsigned char neg) {Display_SetXY(41, 0); // Stel het adres van de positie op het display in voor (int index=0; index0) {SPDR = 0x30;} // Laad gegevens in de buffer van het display (display minteken) else {SPDR = 0x00;} // Laad gegevens in de buffer van display (wis negatief teken) while(!(SPSR & (1<<SPIF))); // Wacht tot de verzending is voltooid _delay_ms (100); } }

// Functie om de leegte van het digitale teken te wissen Off_Dig (unsigned char x, unsigned char y) { Display_SetXY (x, y); // Stel het adres van de positie op het display in (bovenste rij) voor (int index=0; index<8; index++) {SPI_Tranceiver(0);} // Laad gegevens in de buffer van het display (wis het bovenste deel van het digitale bord) y++; Display_SetXY(x, y);// Stel het adres in van de positie op het display (onderste rij) voor (int index=0; index<8; index++) {SPI_Tranceiver(0);}// Laad data in de buffer van display (duidelijk onderste deel van digitaal teken)}

// Functie om het digitale teken leegte Display_Dig (int dig, unsigned char x, unsigned char y) {Display_SetXY (x, y);// Stel het adres van de positie op het display (bovenste rij) in voor (int index = 0; index <16; index++) {if (index==8){y++;Display_SetXY(x, y);} // Stel het adres van de positie op het display in (onderste rij) SPI_Tranceiver(font6x8[dig][index]); // Laad codesarray met cijfers in de buffer van display _delay_ms (10); } }

// Initialisatie van DS18B20 unsigned char DS18B20_init() {DDRD |= (1 << 2); // Stel de PD2-pin van de PORTD in als output PORTD &= ~(1 << 2); // Stel PD2-pin in als laag _delay_us (490); // Initialisatietiming DDRD &= ~(1 << 2); // Stel PD2-pin van de PORTD in als invoer _delay_us (68); // Timing OK_Flag = (PIND & (1 << 2)); // krijg sensorpuls _delay_us (422); retourneer OK_Flag; // retour 0-ok sensor is plug, 1-fout sensor is losgekoppeld}

// Functie om byte te lezen van DS18B20 unsigned char read_18b20 () { unsigned char i, data = 0; for(i = 0; i < 8; i++) { DDRD |= (1 << 2); // Stel de PD2-pin van de PORTD in als output _delay_us (2); // Timing DDRD &= ~(1 1; // Volgende bit if(PIND & (1 << 2)) data |= 0x80; // zet bit in byte _delay_us(62);} retourneer data;}

// Functie om byte naar DS18B20 te schrijven void write_18b20 (unsigned char data) { unsigned char i; for(i = 0; i < 8; i++) { DDRD |= (1 << 2); // Stel de PD2-pin van de PORTD in als output _delay_us (2); // Timing if(data & 0x01) DDRD &= ~(1 << 2); // als we 1 willen schrijven, laat de regel los else DDRD |= (1 1; // Next bit _delay_us(62); // Timing DDRD &= ~(1 << 2); // Stel PD2-pin van de PORTD als invoer _delay_us(2);} }

// Functie om het lichtniveau leegte Read_Lux () {uint16_t buffer; niet-ondertekende int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // enkele cijfers, dubbele cijfers, drievoudige cijfers, kwart cijfers buffer = get_LightLevel(); // lees het resultaat van analoog naar digitaal convert lichtniveau temp_int_0 = buffer% 10000 / 1000; // kwartcijfer temp_int_1 = buffer % 1000/100; // driecijferige temp_int_2 = buffer% 100/10; // dubbelcijferige temp_int_3 = buffer % 10; // enkelcijferig als (temp_int_0 > 0) // als het resultaat een kwartcijfer is { Display_Dig (temp_int_0, 32, 2); // toon 1 cijfer van het lichtniveau Display_Dig (temp_int_1, 41, 2); // toon 2 cijfers van het lichtniveau Display_Dig (temp_int_2, 50, 2); // toon 3 cijfers van het lichtniveau Display_Dig (temp_int_3, 59, 2); // geef 4 cijfers van het lichtniveau weer } else { if (temp_int_1 > 0) // als het resultaat een driecijferig nummer is { Off_Dig (32, 2); // wis 1 teken van nummer Display_Dig (temp_int_1, 41, 2); // toon 1 cijfer van het lichtniveau Display_Dig (temp_int_2, 50, 2); // toon 2-cijferig lichtniveau Display_Dig (temp_int_3, 59, 2); // geef 3 cijfers van het lichtniveau weer } else { if (temp_int_2 > 0) // als het resultaat een dubbelcijferig nummer is { Off_Dig (32, 2); // wis 1 teken van nummer Off_Dig (41, 2); // wis 2 teken van nummer Display_Dig (temp_int_2, 50, 2); // toon 1 cijfer van het lichtniveau Display_Dig (temp_int_3, 59, 2); // geef 2 cijfers van het lichtniveau weer } else // als het resultaat een eencijferig nummer is { Off_Dig (32, 2); // wis 1 teken van nummer Off_Dig (41, 2); // duidelijk 2 teken van nummer Off_Dig (50, 2); // wis 3 teken van nummer Display_Dig (temp_int_3, 59, 2); // geef 1 cijfer van het lichtniveau weer } } } }

// Functie om temperatuur leegte Read_Temp () { unsigned int buffer; niet-ondertekende int temp_int_1, temp_int_2, temp_int_3; // enkele cijfers, dubbele cijfers, drievoudige cijfers, kwart cijfers unsigned char Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init(); // Initialisatie van DS18B20 write_18b20 (0xCC); // Sensorcodecontrole write_18b20 (0x44); // Start temperatuur conversie _delay_ms (1000); // Sensor polling vertraging DS18B20_init(); // Initialisatie van DS18B20 write_18b20 (0xCC); // Sensorcodecontrole write_18b20(0xBE); // Commando om de inhoud van de Sensor RAM te lezen Temp_L = read_18b20(); // Lees de eerste twee byte Temp_H = read_18b20 (); temp_vlag = 1; // 1-positieve temperatuur, 0-negatieve temperatuur // Krijg negatieve temperatuur if(Temp_H &(1 << 3)) // Sign Bit Check (als bit is ingesteld - negatieve temperatuur) {signed int temp; temp_vlag = 0; // vlag is ingesteld op 0 - negatieve temperatuur temp = (Temp_H <<8)|Temp_L; temperatuur = -temp; // Converteer de extra code in direct Temp_L = temp; Temp_H = temp>> 8; } buffer = ((Temp_H 4); temp_int_1 = buffer % 1000/100; // driecijferige temp_int_2 = buffer % 100/10; // dubbelcijferige temp_int_3 = buffer % 10; // enkelcijferig

// Als de temperatuur negatief is, geeft u het teken van de temperatuur weer, anders wissen

if(temp_flag == 0) {Display_Neg(1);} else {Display_Neg(0);} if(temp_int_1 > 0) // als het resultaat een driecijferig getal is {Display_Dig(temp_int_1, 45, 0); // toon 1 cijfer van temperatuur Display_Dig (temp_int_2, 54, 0); // toon 2 cijfers van temperatuur Display_Dig (temp_int_3, 63, 0); // toon 3 cijfers van temperatuur } else { if (temp_int_2 > 0) // als het resultaat een dubbelcijferig nummer is { Off_Dig (45, 0); // wis 1 teken van nummer Display_Dig (temp_int_2, 54, 0); // toon 1 cijfer van temperatuur Display_Dig (temp_int_3, 63, 0); // toon 2 cijfers van temperatuur} else // als het resultaat een eencijferig nummer is { Off_Dig (45, 0); // wis 1 teken van nummer Off_Dig (54, 0); // wis 2 teken van nummer Display_Dig (temp_int_3, 63, 0); // toon 1 cijfer van temperatuur } } }

// Deze ISR wordt geactiveerd wanneer er een match optreedt van timertelling met vergelijkingswaarde (elke 1 seconde) ISR (TIMER1_COMPA_vect) { // Lezen, weergeven van temperatuur en lichtniveau Read_Temp (); Read_Lux(); }

// Functie om woorden "TEMP" en "LUX" void Display_label () weer te geven {// Woord "TEMP" Display_SetXY (0, 0); // Stel het adres van de positie op het display (bovenste rij) in voor (int index=0; index<105; index++) {if (index==40){Display_SetXY(0, 1);} // Stel het adres van de positie in op het display (onderste rij) if (index==80){Display_SetXY(72, 0);} // Stel het adres van de positie op het display in (bovenste rij) if (index==92){Display_SetXY(72, 1); } // Stel het adres van de positie op het display in (onderste rij) SPDR = TEMP_1[index]; // Laad codesarraygegevens in de buffer van display while(!(SPSR & (1<<SPIF))); // Wacht tot de verzending is voltooid _delay_ms (10); } // Woord "LUX" Display_SetXY (0, 2); // Stel het adres van de positie op het display (bovenste rij) in voor (int index=0; index<60; index++) {if (index==30){Display_SetXY(0, 3);} // Stel het adres van de positie in op display (onderste rij) SPDR = TEMP_2[index]; // Laad codesarraygegevens in de buffer van display while(!(SPSR & (1<<SPIF))); // Wacht tot de verzending is voltooid _delay_ms (10); } }

int hoofd(void)

{ Poort_Init(); // Poortinitialisatie ADC_init(); // ADC-initialisatie SPI_Init (); // SPI-initialisatie SPI_SS_Enable (); // Weergave inschakelen DS18B20_init(); // Initialisatie van DS18B20 Display_init(); // Display-initialisatie Display_Clear(); // Toon duidelijk Display_label(); // Display woorden "TEMP" en "LUX" TIMER1_init(); // Timer1 initialisatie. Begin met monitoren. Elke seconde parameters ophalen. // Infinity loop while (1) { } }

Stap 3: Firmware flashen naar microcontroller

HEX-bestand uploaden naar het flashgeheugen van de microcontroller. Bekijk de video met een gedetailleerde beschrijving van het branden van microcontroller-flashgeheugen: Microcontroller-flashgeheugen branden…

Stap 4: Monitoring Device Circuit Assembly

Componenten aansluiten volgens schema.

Stekker in het stopcontact en het werkt!