Hőmérséklet- és fényszintmérő LCD kijelzővel NOKIA 5110: 4 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:41

Üdv mindenkinek!

Ebben a szakaszban egyszerű elektronikus eszközt készítünk a hőmérséklet és a fényszint figyelésére. Ezeknek a paramétereknek a mértékegységei a NOKIA 5110 LCD kijelzőn jelennek meg. A készülék az AVR ATMEGA328P mikrokontrollerre épül. A felügyeleti eszköz DS18B20 digitális hőmérővel és fényellenállással rendelkezik a fényszint mérésére.

1. lépés: Alkatrészek leírása

A felügyeleti eszköz alapvető összetevői:

• AVR mikrokontroller «ATMEGA328P»
• Fekete -fehér grafikus LCD "NOKIA 5110"
• Programozható felbontású 1 vezetékes digitális hőmérő «DS18B20»
• Fényfüggő ellenállás
• Vezetékek

AVR mikrokontroller «ATMEGA328P»

A felügyeleti eszköz a mikrokontroller alábbi perifériás funkcióit használja:

1. 16 bites időzítő/számláló megszakítás
2. 8 csatornás 10 bites ADC
3. Master/slave SPI soros interfész

Fekete -fehér grafikus LCD "NOKIA 5110"

Specifikációk:

1. 48 x 84 pontos LCD kijelző
2. Soros busz interfész maximális nagy sebességgel 4 Mbit/s
3. Belső vezérlő/illesztőprogram «PCD8544»
4. LED háttérvilágítás
5. Futtassa 2,7-5 V feszültséggel
6. Alacsony energia fogyasztás; akkumulátoros alkalmazásokhoz alkalmas
7. Hőmérséklet -25 ° C és +70 ° C között
8. Támogatja a jel CMOS bemenetet

LCD -cím kezelése (címzés):

A memória címkijelzése az LCD kijelzőn (DDRAM) Mátrix, amely 6 sorból áll (Y-cím) az Y-cím 0-tól az Y-cím 5-ig és 84 oszlop (X cím) az X-cím 0-tól X-ig Cím 83. Ha a felhasználó hozzá akar férni az LCD kijelzőn megjelenített eredményhez, akkor hivatkoznia kell az X-cím és az Y-cím kapcsolatára.

A megjelenítendő adatok 8 bitesek (1 bájt), és függőleges vonalként lesznek elrendezve; ebben az esetben az MSB bit alacsonyabb lesz, az LSB bit pedig felső, mint a képen látható.

Programozható felbontású 1 vezetékes digitális hőmérő DALLAS «DS18B20»

Jellemzők:

1. Az egyedülálló 1 vezetékes interfész csak egy porttárat igényel a kommunikációhoz
2. Csökkentse a komponensek számát az integrált hőmérséklet -érzékelővel és az EEPROM -mal
3. -55 ° C és +125 ° C közötti hőmérsékletet mér (-67 ° F és +257 ° F között)
4. ± 0,5 ° C Pontosság -10 ° C és +85 ° C között
5. Programozható felbontás 9 bitről 12 bitre
6. Nincs szükség külső komponensekre
7. A parazita tápellátási mód működéséhez csak 2 érintkező szükséges (DQ és GND)
8. Egyszerűsíti az elosztott hőmérsékletérzékelő alkalmazásokat a többcseppes képességgel
9. Minden eszköz egyedi 64 bites soros kóddal rendelkezik a fedélzeti ROM-ban
10. Rugalmas, felhasználó által definiálható, nem illékony (NV) riasztási beállítások riasztáskeresési paranccsal Azonosítja azokat az eszközöket, amelyek hőmérséklete kívül esik a programozott határokon

Alkalmazások:

1. Termosztatikus vezérlők
2. Ipari rendszerek
3. Fogyasztói termékek
4. Hőmérők
5. Hőérzékeny rendszerek

Fényfüggő ellenállás

A fényfüggő ellenállás (LDR) egy jelátalakító, amely megváltoztatja ellenállását, ha a fény a felületére esik.

Általában az LDR egy megaOhm -tól két megaOhm -ig terjed teljes sötétségben, tíz -húsz kiloOhm -on tíz LUX -on, és két -öt kiloohmon 100 LUX -on. Az érzékelő két érintkezője közötti ellenállás csökken a fény intenzitásával, vagy nő az érzékelő két érintkezője közötti vezetőképesség.

Használjon feszültségosztó áramkört az ellenállásváltozás feszültségváltozássá alakításához.

2. lépés: A mikrokontroller firmware -kódja

#ifndef F_CPU #define F_CPU 16000000UL // a vezérlő kristályfrekvenciájának megmondása (16 MHz AVR ATMega328P) #endif

// SPI INTERFACE DEFINES #define MOSI 3 // MOSI it B PORT, PIN 3 #define MISO 4 // MISO it PORT, PIN 4 #define SCK 5 // SCK it PORT B, PIN 5 #define SS 2 // SS ez a B PORT, PIN 2

// A KIJELZŐ NULLÁZÁSA #define RST 0 // RESET it B PORT, PIN 0

// KIJELZŐ ÜZEMMÓD VÁLASZTÁSA - Bemenet a parancs/cím vagy az adatbevitel kiválasztásához. #define DC 1 // DC ez a PORT B, PIN 1

// a negatív előjelű statikus const kódok tömbje kód nélküli neg neg [4] = {0x30, 0x30, 0x30, 0x30};

// kódok számok tömbje [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, 0x06, 0x06, 0x06, 0x06, 0x8C, 0x00, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 3 {0x3C, 0x3E, 0x7C, 0x60, 0x60, 0xFC, 0xFE, 0xFC, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 0x01, 0x03, 0x01}, // 4 {0x1C, 0x3E, 0x3E, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01x, // 5 0xFE, 0xFE, 0x36, 0x36, 0xF6, 0xF6, 0xE4, 0x01, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01}, // 6 {0x04, 0x06, 0x06, 0x86, 0xE6, 0x86, 0x00, 0x00, 0x00, 0x01, 0x03, 0x01, 0x00, 0x00}, // 7 {0xCC, 0xFE, 0xFE, 0x36, 0x36, 0xFE, 0xFE, 0xCC, 0x01, 0x03, 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};

// a "TEMP" szó tömb kódja: 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, 0xC 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, 0xF, 0x9C, 0x98, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x03, 0x03, 0x03, 0x01,};

// a "LUX" szó tömb kódja: 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, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x03, 0x03, 0x01, 0x00, 0x01, 0x01};

#befoglalni

#befoglalni #befoglalni

// Port inicializálása érvénytelen Port_Init () {DDRB = (1 << MOSI) | (1 << SCK) | (1 << SS) | (1 << RST) | (1 << DC); // MOSI beállítása, SCK, SS, RST, DC kimenetként, az összes többi bemenet PORTB | = (1 << RST); // Állítsa az RST tűt magasra PORTB | = (1 << SS); // Állítsa az SS tűt magasra - A kijelző A DDRC = 0xFFu letiltása; // A PORTC összes csapjának beállítása kimenetként. DDRC & = ~ (1 << 0); // A PORTC első érintkezőjét adja meg bemenetként PORTC = 0x00u; // Állítsa a PORTC összes csapját alacsonyra, ami kikapcsolja. }

// ADC inicializálás void ADC_init () {// ADC engedélyezése, mintavételi frekvencia = osc_freq/128 állítsa az előskálázót a maximális értékre, 128 ADCSRA | = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); ADMUX = (1 << REFS0); // Válassza ki az ADC feszültségreferenciáját // Válassza ki a nulla csatornát alapértelmezés szerint az ADC Multiplexer Select regiszter (ADC0) használatával. }

// Funkció az analóg -digitális konvertálás eredményének leolvasására uint16_t get_LightLevel () {_delay_ms (10); // Várjon egy kicsit, amíg a csatorna kiválasztja az ADCSRA | = (1 << ADSC); // Indítsa el az ADC átalakítást az ADSC bit beállításával. írjon 1 -et az ADSC -hez, miközben (ADCSRA & (1 << ADSC)); // várja meg a konverziót visszatérés (ADC); // A 10 bites eredmény visszaadása}

// SPI inicializálás érvénytelen SPI_Init () {SPCR = (1 << SPE) | (1 << MSTR) | (1 << SPR0); // SPI engedélyezése, Beállítás mesterként, Előbeállítás beállítása Fosc/16 -ként az SPI vezérlésben Regisztráció }

// 16 bites Timer1 inicializálása, megszakítás és változó void TIMER1_init () {// időzítő beállítása előskálázóval = 256 és CTC mód TCCR1B | = (1 << WGM12) | (1 << CS12); // inicializáló számláló TCNT1 = 0; // inicializálja az összehasonlító értéket - 1 mp OCR1A = 62500; // engedélyezze az összehasonlítás megszakítást TIMSK1 | = (1 << OCIE1A); // globális megszakítások engedélyezése sei (); }

// Display Enable void SPI_SS_Enable () {PORTB & = ~ (1 << SS); // Az SS -pin engedélyezése a logikához 0}

// Kijelző letiltása void SPI_SS_Disable () {PORTB | = (1 << SS); // Az SS -pin letiltása a logikához 1}

// Funkció adatok küldésére a kijelzőpufferbe void SPI_Tranceiver (unsigned char data) {SPDR = data; // Adatok betöltése a pufferbe while (! (SPSR & (1 << SPIF))); // Várjon, amíg az átvitel befejeződik}

// A kijelző visszaállítása az inicializálás elején void Display_Reset () {PORTB & = ~ (1 << RST); _delay_ms (100); PORTB | = (1 << RST); }

// Parancsírás függvény void Display_Cmnd (unsigned char data) {PORTB & = ~ (1 << DC); // készítse el a DC pin -t a 0 logikához a SPI_Tranceiver (adat) parancsművelethez; // adatok küldése az adatregiszterben PORTB | = (1 << DC); // hogy a DC pin a logikához magas legyen az adatkezeléshez}

// A kijelző inicializálása void Display_init () {Display_Reset (); // a kijelző visszaállítása Display_Cmnd (0x21); // parancs beállítása kiegészítési módban Display_Cmnd (0xC0); // állítsa be a feszültséget C0 küldésével: VOP = 5V Display_Cmnd (0x07); // állítsa be a hőmérsékletet együttható 3 Display_Cmnd (0x13); // a feszültség -torzítás beállítása Display_Cmnd (0x20); // parancskészlet alapmódban Display_Cmnd (0x0C); // eredmény megjelenítése normál módban}

// A kijelző törlése üres Display_Clear () {PORTB | = (1 << DC); // a DC pin logikává alakítása magasra az adatkezeléshez (int k = 0; k <= 503; k ++) {SPI_Tranceiver (0x00);} PORTB & = ~ (1 << DC); // DC pin logika nulla a parancsműveletekhez}

// állítsa az oszlopot és a sort az eredmény megjelenítésére az LCD kijelzőn. void Display_SetXY (unsigned char x, unsigned char y) {Display_Cmnd (0x80 | x); // oszlop (0-83) Display_Cmnd (0x40 | y); // sor (0-5)}

// Funkció negatív előjel megjelenítésére void Display_Neg (unsigned char neg) {Display_SetXY (41, 0); // Állítsa be a kijelzőn megjelenő pozíció címét (int index = 0; index0) {SPDR = 0x30;} // Adatok betöltése a kijelző pufferébe (negatív előjel megjelenítése) else {SPDR = 0x00;} // Adatok betöltése a a kijelző puffere (egyértelmű negatív előjel), miközben (! (SPSR & (1 << SPIF))); // Várjon, amíg az átvitel befejeződik _delay_ms (100); }}

// Funkció a digitális jel törlésére void Off_Dig (unsigned char x, unsigned char y) {Display_SetXY (x, y); // Állítsa be a megjelenített pozíció címét (felső sor) a következőhöz: (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Adatok betöltése a kijelző pufferébe (a digitális jel felső részének világos része) y ++; Display_SetXY (x, y); // Állítsa be a megjelenített pozíció címét (alsó sor) a következőhöz: (int index = 0; index <8; index ++) {SPI_Tranceiver (0);} // Adatok betöltése a kijelző pufferébe (törölje a digitális jel alsó részét)}

// Funkció a digitális jel érvénytelen megjelenítésére <16; index ++) {if (index == 8) {y ++; Display_SetXY (x, y);} // Állítsa be a megjelenített pozíció címét (alsó sor) SPI_Tranceiver (font6x8 [dig] [index]); // Töltse be a kódok tömbjét a számadatokból a kijelző pufferébe _delay_ms (10); }}

// A DS18B20 előjel nélküli karakter inicializálása DS18B20_init () {DDRD | = (1 << 2); // Állítsa be a PORTD PD2 tűjét kimenetként PORTD & = ~ (1 << 2); // Állítsa a PD2 tűt alacsony _delay_us (490); // Inicializálás időzítése DDRD & = ~ (1 << 2); // Állítsa be a PORTD PD2 tűjét bemenetként _delay_us (68); // Időzítés OK_Flag = (PIND & (1 << 2)); // érzékelő impulzus lekérése _delay_us (422); visszatérés OK_Flag; // visszatérés 0-ok érzékelő dugó, 1-hibás érzékelő kihúzva}

// Fájl a bájt olvasásához a DS18B20 -ból unsigned char read_18b20 () {unsigned char i, data = 0; mert (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Állítsa be a PORTD PD2 tűjét kimenetként _delay_us (2); // Időzítés DDRD & = ~ (1 1; // Következő bit, ha (PIND & (1 << 2)) adatok | = 0x80; // bit behelyezése a bájtba _delay_us (62);} visszatérési adatok;}

// Bájt írása a DS18B20 -ba void write_18b20 (unsigned char data) {unsigned char i; mert (i = 0; i <8; i ++) {DDRD | = (1 << 2); // Állítsa be a PORTD PD2 tűjét kimenetként _delay_us (2); // Időzítés if (data & 0x01) DDRD & = ~ (1 << 2); // ha 1 -et akarunk írni, engedjük fel az else sort DDRD | = (1 1; // Következő bit _delay_us (62); // Időzítő DDRD & = ~ (1 << 2); // Állítsa be a PORTD bemenetként _delay_us (2);}}

// Funkció a fényszint megjelenítésére void Read_Lux () {uint16_t buffer; unsigned int temp_int_1, temp_int_2, temp_int_3, temp_int_0; // egy számjegy, két számjegy, hármas számjegy, negyed számjegy puffer = get_LightLevel (); // olvassa el az analóg -digitális konvertálás eredményét fényszint temp_int_0 = buffer % 10000 /1000; // negyedszámjegyű temp_int_1 = puffer % 1000 /100; // három számjegyű temp_int_2 = puffer % 100/10; // két számjegyű temp_int_3 = puffer % 10; // egy számjegyű if (temp_int_0> 0) // ha az eredmény negyedjegyű szám {Display_Dig (temp_int_0, 32, 2); // a kijelző 1 számjegyének megjelenítése Display_Dig (temp_int_1, 41, 2); // Display_Dig (temp_int_2, 50, 2) megvilágítási szint 2 számjegyének megjelenítése; // Display_Dig (3_jegy, 3, 59, 2) megvilágítási szint 3 számjegye; // a fényszint 4 számjegyének megjelenítése} else {if (temp_int_1> 0) // ha az eredmény háromjegyű szám {Off_Dig (32, 2); // törölje a szám 1 jelét Display_Dig (temp_int_1, 41, 2); // a kijelző 1 számjegyének megjelenítése Display_Dig (temp_int_2, 50, 2); // Display_Dig (fény_hirdetés_3, 59, 2) 2 számjegyű kijelzője; // a fényerő 3 számjegyének megjelenítése} else {if (temp_int_2> 0) // ha az eredmény kétszámjegyű szám {Off_Dig (32, 2); // törölje a szám 1 jelét Off_Dig (41, 2); // törölje a szám 2 jelét Display_Dig (temp_int_2, 50, 2); // Display_Dig (temp_int_3, 59, 2) 1 -es fényszint megjelenítése; // a fényerő 2 számjegyének megjelenítése} else // ha az eredmény egyjegyű szám {Off_Dig (32, 2); // törölje a szám 1 jelét Off_Dig (41, 2); // szám 2 jelének törlése Off_Dig (50, 2); // törölje a szám 3 jelét Display_Dig (temp_int_3, 59, 2); // 1 számjegyű fényerő megjelenítése}}}}

// Funkció a hőmérséklet megjelenítésére void Read_Temp () {unsigned int buffer; unsigned int temp_int_1, temp_int_2, temp_int_3; // egy számjegy, két számjegy, hármas számjegy, negyed számjegy aláírás nélküli karakter Temp_H, Temp_L, OK_Flag, temp_flag; DS18B20_init (); // A DS18B20 inicializálása write_18b20 (0xCC); // Érzékelő kód ellenőrzése write_18b20 (0x44); // Hőmérséklet -konverzió indítása _delay_ms (1000); // Érzékelő lekérdezési késleltetése DS18B20_init (); // A DS18B20 inicializálása write_18b20 (0xCC); // Érzékelő kód ellenőrzése write_18b20 (0xBE); // Parancs az érzékelő RAM tartalmának olvasására Temp_L = read_18b20 (); // Az első két bájt olvasása Temp_H = read_18b20 (); temp_zászló = 1; // 1-pozitív hőmérséklet, 0-negatív hőmérséklet // Negatív hőmérsékletet kap, ha (Temp_H & (1 << 3)) // Sign Bit Check (Ha a bit be van állítva-negatív hőmérséklet) {sign int temp; temp_zászló = 0; // a zászló beállítása 0 - negatív hőmérséklet temp = (Temp_H << 8) | Temp_L; hőmérséklet = -hőmérséklet; // A kiegészítő kód konvertálása közvetlen Temp_L = temp; Hőmérséklet_H = hőmérséklet >> 8; } puffer = ((Temp_H 4); temp_int_1 = puffer % 1000 /100; // háromjegyű temp_int_2 = puffer % 100/10; // kétszámjegyű temp_int_3 = puffer % 10; // egy számjegy

// Ha a hőmérséklet negatív, akkor jelezze a hőmérsékletet

if (temp_flag == 0) {Display_Neg (1);} else {Display_Neg (0);} if (temp_int_1> 0) // ha az eredmény háromjegyű szám {Display_Dig (temp_int_1, 45, 0); // megjeleníti a hőmérséklet 1 számjegyét Display_Dig (temp_int_2, 54, 0); // a kijelző két számjegyének megjelenítése Display_Dig (temp_int_3, 63, 0); // a hőmérséklet 3 számjegyének megjelenítése} else {if (temp_int_2> 0) // ha az eredmény kétszámjegyű szám {Off_Dig (45, 0); // törölje a szám 1 jelét Display_Dig (temp_int_2, 54, 0); // megjeleníti a hőmérséklet 1 számjegyét Display_Dig (temp_int_3, 63, 0); // a hőmérséklet 2 számjegyének megjelenítése} else // ha az eredmény egyjegyű szám {Off_Dig (45, 0); // törölje a szám 1 jelét Off_Dig (54, 0); // törölje a szám 2 jelét Display_Dig (temp_int_3, 63, 0); // a hőmérséklet 1 számjegyének megjelenítése}}}

// Ez az ISR aktiválódik, amikor egyezik az időzítők száma az összehasonlítási értékkel (1 másodpercenként) ISR (TIMER1_COMPA_vect) {// Olvasás, a hőmérséklet és a fényszint megjelenítése Read_Temp (); Read_Lux (); }

// Funkció a "TEMP" és a "LUX" szavak megjelenítésére void Display_label () {// Word "TEMP" Display_SetXY (0, 0); // Állítsa be a megjelenített pozíció címét (felső sor) a következőhöz: (int index = 0; index <105; index ++) {if (index == 40) {Display_SetXY (0, 1);} // Állítsa be a pozíció címét a kijelzőn (alsó sor) if (index == 80) {Display_SetXY (72, 0);} // Állítsa be a megjelenített pozíció címét (felső sor), ha (index == 92) {Display_SetXY (72, 1); } // Állítsa be a megjelenített pozíció címét (alsó sor) SPDR = TEMP_1 [index]; // Töltse be a kód tömb adatait a kijelző pufferébe, miközben (! (SPSR & (1 << SPIF))); // Várjon, amíg az átvitel befejeződik _delay_ms (10); } // Word "LUX" Display_SetXY (0, 2); // Állítsa be a megjelenített pozíció címét (felső sor) a következőhöz: (int index = 0; index <60; index ++) {if (index == 30) {Display_SetXY (0, 3);} // Állítsa be a pozíció címét a kijelzőn (alsó sor) SPDR = TEMP_2 [index]; // Töltse be a kód tömb adatait a kijelző pufferébe, miközben (! (SPSR & (1 << SPIF))); // Várjon, amíg az átvitel befejeződik _delay_ms (10); }}

int main (void)

{Port_Init (); // Port inicializálása ADC_init (); // ADC inicializálás SPI_Init (); // SPI inicializálása SPI_SS_Enable (); // Display Enable DS18B20_init (); // A DS18B20 inicializálása Display_init (); // Kijelző inicializálása Display_Clear (); // Clear display Display_label (); // "TEMP" és "LUX" szavak megjelenítése TIMER1_init (); // Időzítő1 inicializálása. Kezdje el a megfigyelést. A paraméterek lekérése másodpercenként. // Végtelen ciklus (1) {}}

3. lépés: Firmware villogása a mikrokontrollerhez

HEX fájl feltöltése a mikrokontroller flash memóriájába. Nézze meg a videót a mikrovezérlő flash memóriájának égetésének részletes leírásával: A mikrokontroller flash memóriájának égetése…

4. lépés: A készülék áramkörének felügyelete

Csatlakoztassa az alkatrészeket a vázlatos rajz szerint.

Csatlakoztassa az áramot, és működik!