Monitor temperatury i poziomu światła z wyświetlaniem na LCD NOKIA 5110: 4 kroki

2024 Autor: John Day | [email protected]. Ostatnio zmodyfikowany: 2024-01-30 11:30

Cześć wszystkim!

W tym dziale wykonujemy proste elektroniczne urządzenie do monitorowania temperatury i poziomu światła. Pomiary tych parametrów wyświetlane są na wyświetlaczu LCD NOKIA 5110. Urządzenie oparte jest na mikrokontrolerze AVR ATMEGA328P. Urządzenie monitorujące wyposażone jest w termometr cyfrowy DS18B20 oraz fotorezystor do pomiaru poziomu światła.

Krok 1: Opis Składniki

Podstawowe elementy urządzenia monitorującego:

• Mikrokontroler AVR «ATMEGA328P»
• Monochromatyczny graficzny wyświetlacz LCD «NOKIA 5110»
• Programowalna rozdzielczość 1-przewodowy termometr cyfrowy «DS18B20»
• Rezystor światłoczuły
• Przewody

Mikrokontroler AVR «ATMEGA328P»

Urządzenie monitorujące wykorzystuje następujące funkcje peryferyjne mikrokontrolera:

1. 16-bitowe przerwanie timera/licznika
2. 8-kanałowy 10-bitowy przetwornik ADC
3. Interfejs szeregowy SPI master/slave

Monochromatyczny graficzny wyświetlacz LCD «NOKIA 5110»

Dane techniczne:

1. 48x84 Dot Wyświetlacz LCD
2. Interfejs magistrali szeregowej o maksymalnej szybkości 4 Mbit/S
3. Wewnętrzny kontroler/sterownik «PCD8544»
4. Podświetlenie LED
5. Pracuj przy napięciu 2,7-5 V
6. Niskie zużycie energii; nadaje się do zastosowań akumulatorowych
7. Zakres temperatur od -25˚C do +70˚C
8. Obsługa wejścia sygnału CMOS

Obsługa adresu LCD (adresowanie):

Układ adresów pamięci wyświetlany na wyświetlaczu LCD (DDRAM) to macierz składająca się z 6 wierszy (Adres Y) od Y-Address 0 do Y-Address 5 i 84 kolumn (X Address) od X-Address 0 do X- Adres 83. Jeżeli użytkownik chce uzyskać dostęp do pozycji wyświetlania wyniku na wyświetlaczu LCD, musi odwołać się do relacji pomiędzy X-Address i Y-Address.

Dane, które zostaną wysłane do wyświetlacza, mają 8 bitów (1 bajt) i zostaną ułożone jako linia pionowa; w tym przypadku Bit MSB będzie niższy, a Bit LSB wyższy, jak pokazano na rysunku.

Programowalna rozdzielczość 1-przewodowy termometr cyfrowy DALLAS «DS18B20»

Cechy:

1. Unikalny interfejs 1-Wire® wymaga tylko jednego pinu portu do komunikacji
2. Zmniejsz liczbę komponentów dzięki zintegrowanemu czujnikowi temperatury i pamięci EEPROM
3. Mierzy temperatury od -55°C do +125°C (-67°F do +257°F)
4. ±0,5°C Dokładność od -10°C do +85°C
5. Programowalna rozdzielczość od 9 do 12 bitów
6. Nie są wymagane żadne komponenty zewnętrzne
7. Pasożytniczy tryb zasilania wymaga tylko 2 pinów do działania (DQ i GND)
8. Upraszcza rozproszone aplikacje z czujnikami temperatury dzięki obsłudze wielu kropli
9. Każde urządzenie ma unikalny 64-bitowy kod szeregowy przechowywany we wbudowanej pamięci ROM
10. Elastyczne, definiowane przez użytkownika ustawienia alarmów nieulotnych (NV) z poleceniem wyszukiwania alarmów Identyfikuje urządzenia z temperaturami poza zaprogramowanymi limitami

Aplikacje:

1. Regulatory termostatyczne
2. Systemy przemysłowe
3. Produkty konsumenckie
4. Termometry
5. Systemy wrażliwe termicznie

Rezystor światłoczuły

Light Dependent Resistor (LDR) to przetwornik, który zmienia swoją rezystancję, gdy światło pada na jego powierzchnię.

Zazwyczaj LDR będzie miał od jednego do dwóch megaomów przy całkowitej ciemności, od dziesięciu do dwudziestu kiloomów przy dziesięciu luksach, od dwóch do pięciu kiloomów przy 100 luksach. Rezystancja między dwoma stykami czujnika maleje wraz z natężeniem światła lub wzrasta przewodność między dwoma stykami czujnika.

Użyj obwodu dzielnika napięcia do konwersji zmiany rezystancji na zmianę napięcia.

Krok 2: Kod oprogramowania układowego mikrokontrolera

#ifndef F_CPU#define F_CPU 16000000UL // mówienie częstotliwości kryształu kontrolera (16 MHz AVR ATMega328P) #endif

// INTERFEJS SPI DEFINIUJE #define MOSI 3 // MOSI to PORT B, PIN 3 #define MISO 4 // MISO to PORT B, PIN 4 #define SCK 5 // SCK to PORT B, PIN 5 #define SS 2 // SS to PORT B, PIN 2

// ZRESETUJ WYŚWIETLACZ #define RST 0 // ZRESETUJ PORT B, PIN 0

//WYBÓR TRYBU WYŚWIETLACZA - Wejście do wyboru polecenia/adresu lub wprowadzania danych. #define DC 1 // DC to PORT B, PIN 1

// tablica kodów znaków ujemnych const unsigned char neg[4] = {0x30, 0x30, 0x30, 0x30};

// kody tablica cyfr [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, 0x, 0x8C, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 3 { 0x3C, 0x3E, 0x7C, 0x60, 0x60, 0xFC, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x 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, 0x1C7E, 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 };

// tablica kodów słowa "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, 0x38C8, 0x,00 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, };

// tablica kodów słowa "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, 003 001,01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01 };

#włączać

#włącz #włącz

// Inicjalizacja portu jest nieważna Port_Init() { DDRB = (1<<MOSI)|(1<<SCK)|(1<<SS)|(1<<RST)|(1<<DC);// Ustaw MOSI, SCK, SS, RST, DC jako wyjście, wszystkie inne wejścia PORTB |= (1<<RST);// Ustaw pin RST jako wysoki PORTB |= (1<<SS);// Ustaw pin SS jako wysoki - Wyświetlacz jest Wyłącz DDRC=0xFFu; // Ustaw wszystkie piny portu PORTC jako wyjście. DDRC &= ~(1<<0);//Ustawia pierwszy pin PORTC jako Wejście PORTC=0x00u; // Ustaw wszystkie piny PORTC w stan niski, co spowoduje jego wyłączenie. }

// Inicjalizacja ADC void ADC_init() { // Włącz ADC, częstotliwość próbkowania=osc_freq/128 ustaw preskaler na maksymalną wartość, 128 ADCSRA |= (1<<ADEN) | (1<<ADPS2)| (1<<ADPS1)| (1<<ADPS0); ADMUX = (1<<REFS0); // Wybierz napięcie odniesienia dla ADC // Wybierz kanał zero domyślnie za pomocą rejestru ADC Multiplexer Select (ADC0). }

// Funkcja odczytu wyniku konwersji analogowo-cyfrowej uint16_t get_LightLevel() { _delay_ms(10); // Poczekaj trochę czasu, aż kanał otrzyma wybrany ADCSRA |= (1<<ADSC); // Rozpocznij konwersję ADC, ustawiając bit ADSC. zapisz 1 do ADSC while (ADCSRA & (1<<ADSC)); // czekaj na zakończenie konwersji // ADSC ponownie staje się 0 do tego czasu, uruchom pętlę w sposób ciągły _delay_ms(10); powrót (ADC); // Zwróć wynik 10-bitowy }

// Inicjalizacja SPI void SPI_Init() { SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);//Włącz SPI, Ustaw jako Master, Ustaw Prescaler jako Fosc/16 w kontroli SPI Zarejestruj się }

// zainicjuj 16 bitowy Timer1, przerwanie i zmienną void TIMER1_init() { // ustaw timer z preskalerem = 256 i trybem CTC TCCR1B |= (1 << WGM12)|(1 << CS12); // zainicjuj licznik TCNT1 = 0; // zainicjuj porównywaną wartość - 1 sek OCR1A = 62500; // włącz porównywanie przerwań TIMSK1 |= (1 << OCIE1A); // włącz globalne przerwania sei(); }

//Włącz wyświetlanie void SPI_SS_Enable() { PORTB &= ~(1<<SS); // Włącz pin SS do logiki 0 }

//Wyświetlanie Wyłącz void SPI_SS_Disable() { PORTB |= (1<<SS); // Wyłącz pin SS do logiki 1 }

//Funkcja wysyłania danych do bufora wyświetlania void SPI_Tranceiver (unsigned char data) { SPDR = data; //Załaduj dane do bufora while(!(SPSR & (1<<SPIF))); //Poczekaj na zakończenie transmisji }

// Resetowanie wyświetlacza na początku inicjalizacji void Display_Reset() { PORTB &= ~(1<<RST); _delay_ms(100); PORTB |= (1<<RST); }

//Funkcja zapisu polecenia void Display_Cmnd(unsigned char data) { PORTB &= ~(1<<DC); // zrób pin DC do logiki 0 dla operacji polecenia SPI_Tranceiver(data); // wyślij dane do rejestru danych PORTB |= (1<<DC); // ustaw pin DC na stan wysoki dla operacji na danych }

//Inicjalizacja wyświetlania void Display_init() { Display_Reset(); // zresetuj wyświetlacz Display_Cmnd(0x21); // polecenie ustawione w trybie dodawania Display_Cmnd(0xC0); // ustaw napięcie wysyłając C0 oznacza VOP = 5V Display_Cmnd(0x07); // ustaw temp. współczynnik do 3 Display_Cmnd (0x13); // ustaw wartość napięcia polaryzacji systemu Display_Cmnd(0x20); // polecenie ustawione w trybie podstawowym Display_Cmnd(0x0C); // wyświetl wynik w trybie normalnym }

// Wyczyść ekran void Display_Clear() { PORTB |= (1<<DC); // ustaw wysoki pin DC na logikę dla operacji na danych dla (int k=0; k<=503; k++){SPI_Tranceiver(0x00);} PORTB &= ~(1<<DC);// ustaw pin DC na logikę zero dla operacji polecenia }

// ustaw kolumnę i wiersz na pozycję wyświetlania wyniku na wyświetlaczu LCD void Display_SetXY(unsigned char x, unsigned char y) { Display_Cmnd(0x80|x); // kolumna (0-83) Display_Cmnd(0x40|y); // wiersz (0-5) }

// Funkcja wyświetlania znaku ujemnego void Display_Neg(unsigned char neg) { Display_SetXY(41, 0); // Ustaw adres pozycji na wyświetlaczu dla (int index=0; index0) {SPDR = 0x30;} //Załaduj dane do bufora wyświetlacza (wyświetl znak ujemny) else {SPDR = 0x00;} //Załaduj dane do bufor wyświetlania (wyraźny znak ujemny) while(!(SPSR & (1<<SPIF))); //Poczekaj na zakończenie transmisji _delay_ms(100); } }

// Funkcja kasująca znak cyfrowy void Off_Dig(unsigned char x, unsigned char y) { Display_SetXY(x, y); // Ustaw adres pozycji na wyświetlaczu (górny wiersz) for (int index=0; index<8; index++) {SPI_Tranceiver(0);} //Załaduj dane do bufora wyświetlacza (wyczyść górną część znaku cyfrowego) y++; Display_SetXY(x, y);// Ustaw adres pozycji na wyświetlaczu (dolny rząd) dla (int index=0; index<8; index++) {SPI_Tranceiver(0);}// Załaduj dane do bufora wyświetlacza (wyraźna dolna część znaku cyfrowego) }

// Funkcja wyświetlania znaku cyfrowego void Display_Dig(int dig, unsigned char x, unsigned char y) { Display_SetXY(x, y);// Ustawia adres pozycji na wyświetlaczu (górny wiersz) dla (int index=0; index <16;index++) { if (index==8){y++;Display_SetXY(x, y);} // Ustaw adres pozycji na wyświetlaczu (wiersz dolny) SPI_Tranceiver(font6x8[dig][index]); // Załaduj tablicę kodów z danymi cyfr do bufora wyświetlacza _delay_ms(10); } }

// Inicjalizacja DS18B20 unsigned char DS18B20_init() { DDRD |= (1 << 2); // Ustaw pin PD2 PORTD jako wyjście PORTD &= ~(1 << 2); // Ustaw pin PD2 jako niski _delay_us(490); // Czas inicjalizacji DDRD &= ~(1 << 2); // Ustaw pin PD2 portu PORTD jako input _delay_us(68); // Czas OK_Flag = (PIND & (1 << 2)); // pobierz impuls czujnika _delay_us(422); zwróć OK_Flaga; // powrót 0-ok czujnik jest podłączony, 1-błąd czujnik jest odpięty }

// Funkcja odczytu bajtu z DS18B20 unsigned char read_18b20() { unsigned char i, data = 0; for(i = 0; i < 8; i++) { DDRD |= (1 << 2); // Ustaw pin PD2 portu PORTD jako wyjście _delay_us(2); // Timing DDRD &= ~(1 1; // Następny bit if(PIND & (1 << 2)) data |= 0x80; // wstaw bit do bajtu _delay_us(62); } zwraca dane; }

// Funkcja zapisu bajtu do DS18B20 void write_18b20(unsigned char data) { unsigned char i; for(i = 0; i < 8; i++) { DDRD |= (1 << 2); // Ustaw pin PD2 portu PORTD jako wyjście _delay_us(2); // Czas if(data & 0x01) DDRD &= ~(1 << 2); //jeśli chcemy napisać 1, zwolnij linię w przeciwnym razie DDRD |= (1 1; // Następny bit _delay_us(62);// Timing DDRD &= ~(1 << 2);// Ustaw pin PD2 PORTD jako wejście _delay_us(2); } }

// Funkcja wyświetlania poziomu światła void Read_Lux() { uint16_t buffer; bez znaku int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // pojedyncze cyfry, podwójne cyfry, potrójne cyfry, bufor ćwiartek cyfr = get_LightLevel(); // odczytaj wynik konwersji analogowo-cyfrowej poziomu światła temp_int_0 = buffer % 10000 / 1000; // ćwierć cyfry temp_int_1 = bufor % 1000/100; // trzycyfrowy temp_int_2 = bufor % 100 / 10; // dwucyfrowy temp_int_3 = bufor % 10; // jednocyfrowy if(temp_int_0 > 0) // jeśli wynik jest liczbą ćwierćcyfrową { Display_Dig(temp_int_0, 32, 2); // wyświetl 1 cyfrę poziomu światła Display_Dig(temp_int_1, 41, 2); // wyświetl 2 cyfry poziomu światła Display_Dig(temp_int_2, 50, 2); // wyświetl 3 cyfry poziomu światła Display_Dig(temp_int_3, 59, 2); // wyświetl 4 cyfry poziomu światła } else { if(temp_int_1 > 0) // jeśli wynik jest liczbą trzycyfrową { Off_Dig(32, 2); // wyczyść 1 znak liczby Display_Dig(temp_int_1, 41, 2); // wyświetl 1 cyfrę poziomu światła Display_Dig(temp_int_2, 50, 2); // wyświetl 2 cyfry poziomu światła Display_Dig(temp_int_3, 59, 2); // wyświetl 3 cyfry poziomu światła } else { if(temp_int_2 > 0) // jeśli wynik jest liczbą dwucyfrową { Off_Dig(32, 2); // wyczyść 1 znak liczby Off_Dig(41, 2); // wyczyść 2 znak liczby Display_Dig(temp_int_2, 50, 2); // wyświetl 1 cyfrę poziomu światła Display_Dig(temp_int_3, 59, 2); // wyświetl 2 cyfry poziomu światła } else // jeśli wynik jest liczbą jednocyfrową { Off_Dig(32, 2); // wyczyść 1 znak liczby Off_Dig(41, 2); // wyczyść 2 znak liczby Off_Dig(50, 2); // wyczyść 3 znak liczby Display_Dig(temp_int_3, 59, 2); // wyświetl 1 cyfrę poziomu światła } } } }

// Funkcja wyświetlania temperatury void Read_Temp() { unsigned int buffer; unsigned int temp_int_1, temp_int_2, temp_int_3; // pojedyncze cyfry, podwójne cyfry, potrójne cyfry, ćwierć cyfr unsigned char Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init(); // Inicjalizacja DS18B20 write_18b20(0xCC); // Sprawdzenie kodu czujnika write_18b20(0x44); // Rozpocznij konwersję temperatury _delay_ms(1000); // Opóźnienie odpytywania czujnika DS18B20_init(); // Inicjalizacja DS18B20 write_18b20(0xCC); // Sprawdzenie kodu czujnika write_18b20(0xBE); // Polecenie odczytu zawartości pamięci RAM czujnika Temp_L = read_18b20(); // Odczytaj pierwsze dwa bajty Temp_H = read_18b20(); flaga_temp = 1; // 1-dodatnia temperatura, 0-ujemna temperatura // Uzyskaj ujemną temperaturę if(Temp_H &(1 << 3)) // Sign Bit Sprawdź (jeśli bit jest ustawiony - ujemna temperatura) { sign int temp; flaga_temp = 0; // flaga ustawiona 0 - temperatura ujemna temp = (Temp_H <<8)|Temp_L; temp = -temp; // Konwertuj dodatkowy kod bezpośrednio Temp_L = temp; Temp_H = temp>> 8; } bufor = ((Temp_H 4); temp_int_1 = bufor % 1000/100; // trzycyfrowy temp_int_2 = bufor % 100 / 10; // dwucyfrowy temp_int_3 = bufor % 10; // jednocyfrowy

// Jeśli temperatura jest ujemna, wyświetlaj znak temperatury, w przeciwnym razie wyczyść

if(temp_flag == 0) {Display_Neg(1);} else {Display_Neg(0);} if(temp_int_1 > 0) // if wynik jest liczbą trzycyfrową { Display_Dig(temp_int_1, 45, 0); // wyświetl 1 cyfrę temperatury Display_Dig(temp_int_2, 54, 0); // wyświetl 2 cyfry temperatury Display_Dig(temp_int_3, 63, 0); // wyświetl 3 cyfry temperatury } else { if(temp_int_2 > 0) // jeśli wynik jest liczbą dwucyfrową { Off_Dig(45, 0); // wyczyść 1 znak liczby Display_Dig(temp_int_2, 54, 0); // wyświetl 1 cyfrę temperatury Display_Dig(temp_int_3, 63, 0); // wyświetl 2 cyfry temperatury } else // jeśli wynik jest liczbą jednocyfrową { Off_Dig(45, 0); // wyczyść 1 znak liczby Off_Dig(54, 0); // wyczyść 2 znak liczby Display_Dig(temp_int_3, 63, 0); // wyświetl 1 cyfrę temperatury } } }

// Ten ISR jest uruchamiany za każdym razem, gdy występuje dopasowanie licznika czasu z porównywaną wartością (co 1 sekundę) ISR (TIMER1_COMPA_vect) { // Odczyt, wyświetlanie temperatury i poziomu światła Read_Temp(); Czytaj_Luks(); }

// Funkcja do wyświetlania słów "TEMP" i "LUX" void Display_label() { // Słowo "TEMP" Display_SetXY(0, 0); // Ustaw adres pozycji na wyświetlaczu (wiersz górny) for (int index=0; index<105; index++) { if (index==40){Display_SetXY(0, 1);} // Ustaw adres pozycji na wyświetlaczu (dolny rząd) if (index==80){Display_SetXY(72, 0);} // Ustaw adres pozycji na wyświetlaczu (górny rząd) if (index==92){Display_SetXY(72, 1); } // Ustaw adres pozycji na wyświetlaczu (dolny wiersz) SPDR = TEMP_1[indeks]; // Załaduj dane tablicy kodów do bufora wyświetlacza while(!(SPSR & (1<<SPIF))); // Czekaj na zakończenie transmisji _delay_ms(10); } // Słowo "LUX" Display_SetXY(0, 2); // Ustaw adres pozycji na wyświetlaczu (górny wiersz) for (int index=0; index<60; index++) { if (index==30){Display_SetXY(0, 3);} // Ustaw adres pozycji na wyświetlaczu (wiersz dolny) SPDR = TEMP_2[indeks]; // Załaduj dane tablicy kodów do bufora wyświetlacza while(!(SPSR & (1<<SPIF))); // Czekaj na zakończenie transmisji _delay_ms(10); } }

int główny (unieważniony)

{ Port_Init(); // Inicjalizacja portu ADC_init(); // Inicjalizacja ADC SPI_Init(); // Inicjalizacja SPI SPI_SS_Enable(); // Włącz wyświetlanie DS18B20_init(); // Inicjalizacja DS18B20 Display_init(); // Wyświetl inicjalizację Display_Clear(); // Wyświetl wyczyść Display_label(); // Wyświetl słowa "TEMP" i "LUX" TIMER1_init(); // Inicjalizacja timera1. Rozpocznij monitorowanie. Pobieranie parametrów co sekundę. // Pętla nieskończoności, gdy (1) { } }

Krok 3: Flashowanie oprogramowania układowego do mikrokontrolera

Wgrywanie pliku HEX do pamięci flash mikrokontrolera. Obejrzyj film ze szczegółowym opisem wypalania pamięci flash mikrokontrolera: Wypalanie pamięci flash mikrokontrolera…

Krok 4: Montaż obwodu urządzenia monitorującego

Połącz elementy zgodnie ze schematem ideowym.

Podłącz zasilanie i działa!