Temperatur- und Lichtpegelmonitor mit Anzeige auf LCD NOKIA 5110 - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:19

Hallo alle zusammen!

In diesem Abschnitt stellen wir ein einfaches elektronisches Gerät zur Überwachung der Temperatur und des Lichtniveaus her. Die Messungen dieser Parameter werden auf dem LCD NOKIA 5110 angezeigt. Das Gerät basiert auf dem Mikrocontroller AVR ATMEGA328P. Das Überwachungsgerät ist mit einem digitalen Thermometer DS18B20 und einem Fotowiderstand ausgestattet, um den Lichtpegel zu messen.

Schritt 1: Beschreibung Komponenten

Grundkomponenten des Überwachungsgeräts:

• Mikrocontroller AVR «ATMEGA328P»
• Monochromes Grafik-LCD «NOKIA 5110»
• 1-Draht-Digitalthermometer mit programmierbarer Auflösung «DS18B20»
• Lichtabhängiger Widerstand
• Drähte

Mikrocontroller AVR «ATMEGA328P»

Das Überwachungsgerät verwendet die folgenden Peripheriefunktionen des Mikrocontrollers:

1. 16-Bit-Timer/Zähler-Interrupt
2. 8-Kanal 10-Bit-ADC
3. Serielle Master/Slave-SPI-Schnittstelle

Monochromes Grafik-LCD «NOKIA 5110»

Spezifikationen:

1. 48 x 84 Dot LCD-Display
2. Serielle Busschnittstelle mit maximaler Hochgeschwindigkeit 4 Mbits/S
3. Interner Controller/Treiber «PCD8544»
4. LED-Hintergrundbeleuchtung
5. Betrieb mit Spannung 2,7-5 Volt
6. Energieeffizient; es ist für Batterieanwendungen geeignet
7. Temperaturbereich von -25˚C bis +70˚C
8. Unterstützt Signal-CMOS-Eingang

Handhabung der LCD-Adresse (Adressierung):

Die auf dem LCD-Display (DDRAM) angezeigte Adressanordnung des Speichers ist eine Matrix, die aus 6 Zeilen (Y-Adresse) von Y-Adresse 0 bis Y-Adresse 5 und 84 Spalten (X-Adresse) von X-Adresse 0 bis X besteht. Adresse 83. Wenn der Benutzer auf die Position der Ergebnisanzeige auf dem LCD-Display zugreifen möchte, muss die Beziehung zwischen X-Adresse und Y-Adresse beachtet werden.

Die Daten, die an die Anzeige gesendet werden, sind 8 Bit (1 Byte) und werden als vertikale Linie angeordnet; in diesem Fall ist Bit MSB niedriger und Bit LSB höher, wie im Bild gezeigt.

1-Draht-Digitalthermometer mit programmierbarer Auflösung DALLAS «DS18B20»

Merkmale:

1. Einzigartige 1-Wire®-Schnittstelle benötigt nur einen Port-Pin für die Kommunikation
2. Reduzieren Sie die Anzahl der Komponenten mit integriertem Temperatursensor und EEPROM
3. Misst Temperaturen von -55 °C bis +125 °C (67 °F bis +257 °F)
4. ±0,5°C Genauigkeit von -10°C bis +85°C
5. Programmierbare Auflösung von 9 Bit bis 12 Bit
6. Keine externen Komponenten erforderlich
7. Parasitärer Strommodus erfordert nur 2 Pins für den Betrieb (DQ und GND)
8. Vereinfacht verteilte Temperaturerfassungsanwendungen mit Multidrop-Fähigkeit
9. Jedes Gerät verfügt über einen einzigartigen seriellen 64-Bit-Code, der im On-Board-ROM gespeichert ist
10. Flexible benutzerdefinierbare nichtflüchtige (NV) Alarmeinstellungen mit Alarmsuchbefehl Identifiziert Geräte mit Temperaturen außerhalb der programmierten Grenzen

Anwendungen:

1. Thermostatische Steuerungen
2. Industrielle Systeme
3. Verbraucherprodukte
4. Thermometer
5. Thermisch empfindliche Systeme

Lichtabhängiger Widerstand

Der lichtabhängige Widerstand (LDR) ist ein Wandler, der seinen Widerstand ändert, wenn Licht auf seine Oberfläche fällt.

Typischerweise hat ein LDR von einem MegaOhm bis zwei MegaOhm bei völliger Dunkelheit, von zehn bis zwanzig Kiloohm bei zehn LUX, von zwei bis fünf Kiloohm bei 100 LUX. Der Widerstand zwischen den beiden Kontakten des Sensors nimmt mit der Lichtintensität ab oder der Leitwert zwischen zwei Kontakten des Sensors steigt.

Verwenden Sie eine Spannungsteilerschaltung, um eine Widerstandsänderung in eine Spannungsänderung umzuwandeln.

Schritt 2: Mikrocontroller-Firmware-Code

#ifndef F_CPU#define F_CPU 16000000UL // Angabe der Quarzfrequenz des Controllers (16 MHz AVR ATMega328P) #endif

// SPI INTERFACE DEFINIERT #define MOSI 3 // MOSI ist PORT B, PIN 3 #define MISO 4 // MISO ist PORT B, PIN 4 #define SCK 5 // SCK ist PORT B, PIN 5 #define SS 2 // SS ist PORT B, PIN 2

// ZURÜCKSETZEN DES DISPLAYS #define RST 0 // ZURÜCKSETZEN seines PORT B, PIN 0

//DISPLAY MODE SELECT - Eingang zur Auswahl von Befehl/Adresse oder Dateneingabe. #define DC 1 // DC ist PORT B, PIN 1

// Code-Array mit negativem Vorzeichenstatic const unsigned char neg[4] = {0x30, 0x30, 0x30, 0x30};

// Codes Array von Ziffern [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, 0x76, 0xFE, 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 0x1.7E,, 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 };

// Code-Array des Wortes "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, 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, 0 0x01, 0x03, 0x01, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x0C, 0x1E, 0x33, 0x33, 0x1E, 0x0C, 0x00, 0xF8, 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01, };

// Code-Array des Wortes "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 };

#enthalten

#einschließen #einschließen

// Port Initializationvoid Port_Init() { DDRB = (1<<MOSI)|(1<<SCK)|(1<<SS)|(1<<RST)|(1<<DC);// MOSI setzen, SCK, SS, RST, DC als Ausgang, alle anderen Eingang PORTB |= (1<<RST); // RST-Pin auf High setzen PORTB |= (1<<SS); // SS-Pin auf High setzen - Anzeige ist DDRC deaktivieren=0xFFu; // Setze alle Pins des PORTC als Ausgang. DDRC &= ~(1<<0); // Macht den ersten Pin von PORTC als Eingang PORTC = 0x00u; // Setzen Sie alle Pins von PORTC auf niedrig, wodurch es ausgeschaltet wird. }

// ADC-Initialisierung void ADC_init() { // ADC aktivieren, Sampling freq=osc_freq/128 Prescaler auf maximalen Wert setzen, 128 ADCSRA |= (1<<ADEN) | (1<<ADPS2)| (1<<ADPS1)| (1<<ADPS0); ADMUX = (1<<REFS0); // Wählen Sie die Spannungsreferenz für den ADC // Wählen Sie standardmäßig den Kanal Null mit dem ADC Multiplexer Select Register (ADC0). }

// Funktion zum Lesen des Ergebnisses der Analog-Digital-Konvertierung uint16_t get_LightLevel () { _delay_ms (10); // Warten Sie einige Zeit, bis der Kanal ausgewählt ist ADCSRA |= (1<<ADSC); // Starten Sie die ADC-Konvertierung, indem Sie das ADSC-Bit setzen. schreibe 1 in ADSC while(ADCSRA & (1<<ADSC)); // warten, bis die Konvertierung abgeschlossen ist // ADSC wird bis dahin wieder 0, Schleife kontinuierlich ausführen _delay_ms(10); zurück (ADC); // Rückgabe des 10-Bit-Ergebnisses }

// SPI Initialization void SPI_Init() { SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);//Enable SPI, Set as Master, Set Prescaler as Fosc/16 in SPI control registrieren }

// 16 Bit Timer1, Interrupt und Variable initialisieren void TIMER1_init() { // Timer mit Prescaler = 256 und CTC-Modus TCCR1B einrichten |= (1 << WGM12)|(1 << CS12); // Zähler initialisieren TCNT1 = 0; // Vergleichswert initialisieren - 1 Sek. OCR1A = 62500; // Vergleichsinterrupt aktivieren TIMSK1 |= (1 << OCIE1A); // globale Interrupts aktivieren sei(); }

//Anzeige aktivieren void SPI_SS_Enable() { PORTB &= ~(1<<SS); // Aktivieren Sie den SS-Pin auf logisch 0}

//Anzeige deaktivieren void SPI_SS_Disable() { PORTB |= (1<<SS); // Deaktivieren Sie den SS-Pin auf Logik 1}

// Funktion zum Senden von Daten in den Anzeigepuffer void SPI_Tranceiver (unsigned char data) { SPDR = data; //Daten in den Puffer laden while(!(SPSR & (1<<SPIF))); // Warten bis die Übertragung abgeschlossen ist }

// Display zu Beginn der Initialisierung zurücksetzen void Display_Reset() { PORTB &= ~(1<<RST); _verzögerung_ms(100); PORTB |= (1<<RST); }

//Befehlsschreibfunktion void Display_Cmnd(unsigned char data) { PORTB &= ~(1<<DC); // DC-Pin auf logisch 0 für Befehlsoperation machen SPI_Tranceiver (Daten); // Daten über das Datenregister PORTB senden |= (1<<DC); // DC-Pin für den Datenbetrieb auf logisch hoch machen}

//Initialisierung der Anzeige void Display_init() { Display_Reset(); // Zurücksetzen der Anzeige Display_Cmnd (0x21); // Befehlssatz im Additionsmodus Display_Cmnd(0xC0); // die Spannung durch Senden von C0 einstellen bedeutet VOP = 5V Display_Cmnd (0x07); // setze die temp. Koeffizient auf 3 Display_Cmnd(0x13); // Wert des Voltage Bias System einstellen Display_Cmnd (0x20); // Befehlssatz im Basismodus Display_Cmnd(0x0C); // Ergebnis im Normalmodus anzeigen }

// Anzeige löschen void Display_Clear() { PORTB |= (1<<DC); // DC-Pin auf logisch hoch für Datenbetrieb für (int k=0; k<=503; k++) machen {SPI_Tranceiver(0x00);} PORTB &= ~(1<<DC); // DC-Pin auf Logik machen Null für Befehlsoperation }

// setze die Spalte und Zeile auf die Position der Anzeige des Ergebnisses auf dem LCD-Display void Display_SetXY (unsigned char x, unsigned char y) { Display_Cmnd (0x80|x); // Spalte (0-83) Display_Cmnd(0x40|y); // Zeile (0-5) }

// Funktion zum Anzeigen des negativen Vorzeichens void Display_Neg (unsigned char neg) { Display_SetXY (41, 0); // Setze die Adresse der Position auf dem Display für (int index=0; index0) {SPDR = 0x30;} //Lade Daten in den Puffer des Displays (Anzeige negatives Vorzeichen) else {SPDR = 0x00;} //Lade Daten in der Puffer der Anzeige (negatives Vorzeichen löschen) while(!(SPSR & (1<<SPIF))); // Warten bis die Übertragung abgeschlossen ist _delay_ms (100); } }

// Funktion zum Löschen des digitalen Zeichens void Off_Dig(unsigned char x, unsigned char y) { Display_SetXY(x, y); // Setze die Adresse der Position auf dem Display (obere Zeile) für (int index=0; index<8; index++) {SPI_Tranceiver(0);} //Lade Daten in den Puffer des Displays (lösche den oberen Teil des digitalen Zeichens) y++; Display_SetXY(x, y); // Setze die Adresse der Position auf dem Display (untere Zeile) für (int index=0; index<8; index++) {SPI_Tranceiver(0);} // Lade Daten in den Puffer des Displays (klarer unterer Teil des digitalen Zeichens) }

// Funktion zum Anzeigen des digitalen Zeichens void Display_Dig(int dig, unsigned char x, unsigned char y) { Display_SetXY(x, y); // Setze die Adresse der Position auf dem Display (obere Zeile) für (int index=0; index <16; index++) { if (index==8){y++;Display_SetXY(x, y);} // Setzt die Adresse der Position auf dem Display (untere Zeile) SPI_Tranceiver(font6x8[dig][index]); // Code-Array mit Zifferndaten in den Puffer von display laden _delay_ms(10); } }

// Initialisierung von DS18B20 unsigned char DS18B20_init() { DDRD |= (1 << 2); // PD2-Pin des PORTD als Ausgang setzen PORTD &= ~(1 << 2); // PD2-Pin auf niedrig setzen _delay_us (490); // Initialisierungs-Timing DDRD &= ~(1 << 2); // PD2-Pin des PORTD als Eingang setzen _delay_us (68); // Timing OK_Flag = (PIND & (1 << 2)); // Sensorimpuls abrufen _delay_us (422); OK_Flag zurückgeben; // Rückgabe 0-ok Sensor ist Stecker, 1-Fehler Sensor ist abgezogen }

// Funktion zum Lesen von Byte aus DS18B20 unsigned char read_18b20 () { unsigned char i, data = 0; for(i = 0; i < 8; i++) { DDRD | = (1 << 2); // PD2-Pin des PORTD als Ausgang setzen _delay_us (2); // Timing DDRD &= ~(1 1; // Nächstes Bit if(PIND & (1 << 2)) data |= 0x80; // setze Bit in Byte _delay_us(62); } return data; }

// Funktion zum Schreiben von Byte in DS18B20 void write_18b20 (unsigned char data) { unsigned char i; for(i = 0; i < 8; i++) { DDRD | = (1 << 2); // PD2-Pin des PORTD als Ausgang setzen _delay_us (2); // Timing if(data & 0x01) DDRD &= ~(1 << 2); // Wenn wir 1 schreiben möchten, geben Sie die Zeile frei sonst DDRD |= (1 1; // Nächstes Bit _delay_us(62); // Timing DDRD &= ~(1 << 2); // PD2-Pin des setzen PORTD als Eingabe _delay_us(2); } }

// Funktion zum Anzeigen des Lichtpegels void Read_Lux () { uint16_t buffer; unsigned int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // einstellige, zweistellige, dreistellige, viertelstellige Puffer = get_LightLevel(); // das Ergebnis der Analog-Digital-Konvertierung des Lichtpegels lesen temp_int_0 = Puffer % 10000 / 1000; // Viertelziffer temp_int_1 = Puffer % 1000 / 100; // dreistellig temp_int_2 = Puffer % 100 / 10; // zweistellig temp_int_3 = Puffer % 10; // einstellige if(temp_int_0 > 0) // wenn das Ergebnis eine viertelstellige Zahl ist { Display_Dig(temp_int_0, 32, 2); // 1 Stelle der Lichtstärke anzeigen Display_Dig (temp_int_1, 41, 2); // 2 Stellen des Lichtniveaus anzeigen Display_Dig (temp_int_2, 50, 2); // Anzeige von 3 Stellen des Lichtniveaus Display_Dig (temp_int_3, 59, 2); // 4 Stellen der Lichtstärke anzeigen} else { if (temp_int_1 > 0) // wenn das Ergebnis eine dreistellige Zahl ist { Off_Dig (32, 2); // 1 Zeichen der Zahl löschen Display_Dig(temp_int_1, 41, 2); // 1 Stelle der Lichtstärke anzeigen Display_Dig (temp_int_2, 50, 2); // 2 Stellen des Lichtniveaus anzeigen Display_Dig (temp_int_3, 59, 2); // 3 Stellen der Lichtstärke anzeigen} else { if (temp_int_2 > 0) // wenn das Ergebnis eine zweistellige Zahl ist { Off_Dig (32, 2); // 1 Zeichen der Zahl löschen Off_Dig (41, 2); // 2 Zeichen der Zahl löschen Display_Dig(temp_int_2, 50, 2); // 1 Stelle der Lichtstärke anzeigen Display_Dig (temp_int_3, 59, 2); // 2 Stellen der Lichtstärke anzeigen} else // wenn das Ergebnis eine einstellige Zahl ist { Off_Dig (32, 2); // 1 Zeichen der Zahl löschen Off_Dig (41, 2); // 2 Zeichen der Zahl löschen Off_Dig (50, 2); // 3 Zeichen der Zahl löschen Display_Dig(temp_int_3, 59, 2); // 1 Stelle der Lichtstärke anzeigen } } } }

// Funktion zum Anzeigen der Temperatur void Read_Temp() { unsigned int buffer; unsigned int temp_int_1, temp_int_2, temp_int_3; // einstellig, zweistellig, dreistellig, viertelstellig unsigned char Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init(); // Initialisierung von DS18B20 write_18b20(0xCC); // Sensorcodeprüfung write_18b20 (0x44); // Temperaturkonvertierung starten _delay_ms(1000); // Sensorabfrageverzögerung DS18B20_init (); // Initialisierung von DS18B20 write_18b20(0xCC); // Sensorcodeprüfung write_18b20 (0xBE); // Befehl zum Lesen des Inhalts des Sensor-RAM Temp_L = read_18b20(); // Die ersten beiden Byte lesen Temp_H = read_18b20(); temp_flag = 1; // 1-positive Temperatur, 0-negative Temperatur // Hole negative Temperatur if(Temp_H &(1 << 3)) // Vorzeichen-Bit-Prüfung (wenn Bit gesetzt - negative Temperatur) { signed int temp; temp_flag = 0; // Flag ist gesetzt 0 - negative Temperatur temp = (Temp_H <<8)|Temp_L; temp = -temp; // Konvertieren des zusätzlichen Codes in direct Temp_L = temp; Temp_H = temp>> 8; } buffer = ((Temp_H 4); temp_int_1 = Puffer % 1000 / 100; // dreistellig temp_int_2 = Puffer % 100 / 10; // zweistellig temp_int_3 = Puffer % 10; // einstellig

// Wenn die Temperatur ein negatives Anzeigezeichen der Temperatur ist, sonst löschen

if(temp_flag == 0) {Display_Neg(1);} else {Display_Neg(0);} if(temp_int_1 > 0) // wenn das Ergebnis eine dreistellige Zahl ist { Display_Dig(temp_int_1, 45, 0); // 1 Stelle der Temperatur anzeigen Display_Dig (temp_int_2, 54, 0); // 2 Stellen der Temperatur anzeigen Display_Dig (temp_int_3, 63, 0); // 3 Stellen der Temperatur anzeigen} else { if (temp_int_2 > 0) // wenn das Ergebnis eine zweistellige Zahl ist { Off_Dig (45, 0); // 1 Zeichen der Zahl löschen Display_Dig(temp_int_2, 54, 0); // 1 Stelle der Temperatur anzeigen Display_Dig (temp_int_3, 63, 0); // 2 Stellen der Temperatur anzeigen} else // wenn das Ergebnis eine einstellige Zahl ist { Off_Dig (45, 0); // 1 Zeichen der Zahl löschen Off_Dig (54, 0); // 2 Zeichen der Zahl löschen Display_Dig(temp_int_3, 63, 0); // 1 Stelle der Temperatur anzeigen } } }

// Dieser ISR wird immer dann ausgelöst, wenn eine Übereinstimmung des Timerzählers mit dem Vergleichswert auftritt (alle 1 Sekunde) ISR (TIMER1_COMPA_vect) { // Lesen, Anzeigen von Temperatur und Lichtstärke Read_Temp(); Read_Lux(); }

// Funktion zum Anzeigen der Wörter "TEMP" und "LUX" void Display_label() { // Wort "TEMP" Display_SetXY(0, 0); // Setze die Adresse der Position auf dem Display (Up Row) für (int index=0; index<105; index++) { if (index==40){Display_SetXY(0, 1);} // Setze die Adresse der Position auf dem Display (untere Reihe) if (index==80){Display_SetXY(72, 0);} // Setze die Adresse der Position auf dem Display (obere Reihe) if (index==92){Display_SetXY(72, 1); } // Setze die Adresse der Position auf dem Display (untere Reihe) SPDR = TEMP_1[index]; // Code-Array-Daten in den Puffer des Displays laden while(!(SPSR & (1<<SPIF))); // Warten bis die Übertragung abgeschlossen ist _delay_ms(10); } // Wort "LUX" Display_SetXY (0, 2); // Setze die Adresse der Position auf dem Display (Up Row) für (int index=0; index<60; index++) { if (index==30){Display_SetXY(0, 3);} // Setze die Adresse der Position im Display (untere Reihe) SPDR = TEMP_2[index]; // Code-Array-Daten in den Puffer des Displays laden while(!(SPSR & (1<<SPIF))); // Warten bis die Übertragung abgeschlossen ist _delay_ms(10); } }

int main(void)

{ Port_Init(); // Port-Initialisierung ADC_init(); // ADC-Initialisierung SPI_Init(); // SPI-Initialisierung SPI_SS_Enable(); // Anzeige aktivieren DS18B20_init(); // Initialisierung von DS18B20 Display_init(); // Initialisierung anzeigen Display_Clear(); // Anzeige löschen Display_label(); // Wörter "TEMP" und "LUX" anzeigen TIMER1_init(); // Timer1-Initialisierung. Überwachung starten. Abrufen von Parametern jede Sekunde. // Infinity-Schleife while (1) { } }

Schritt 3: Flashen der Firmware auf den Mikrocontroller

Hochladen der HEX-Datei in den Flash-Speicher des Mikrocontrollers. Sehen Sie sich das Video mit einer detaillierten Beschreibung des Brennens des Mikrocontroller-Flash-Speichers an: Brennen des Mikrocontroller-Flash-Speichers…

Schritt 4: Schaltungsbaugruppe des Überwachungsgeräts

Komponenten gemäß Schaltplan anschließen.

Strom einstecken und es funktioniert!