Meni v Arduinu in kako uporabljati gumbe: 10 korakov (s slikami)

2024 Avtor: John Day | [email protected]. Nazadnje spremenjeno: 2024-01-30 12:05

V moji vadnici Arduino 101 vas bodo naučili, kako nastaviti okolje v Tinkercadu. Tinkercad uporabljam, ker je precej zmogljiva spletna platforma, ki mi omogoča, da študentom pokažem vrsto spretnosti za gradnjo vezij. Vse moje vaje lahko ustvarite z uporabo Arduino IDE in pravega Arduina!

V tej vadnici se bomo naučili o gumbih! Moramo vedeti:

• Kako jih povezati
• Branje njihove vrednosti
• Odpoved in zakaj je to pomembno
• Praktična aplikacija (izdelava menija)

Večina ljudi misli, da je najbolj praktična stvar z gumbom prižiganje in izklop luči. Bomo, ne tukaj! Našega bomo uporabili za ustvarjanje menija in nastavitev nekaterih možnosti na Arduinu.

Pripravljen? Začnimo!

1. korak: Nastavite ploščo

Prvi korak je namestitev Arduino in Breadboard Small na območje izdelave prototipov. Na zgornjih slikah si oglejte, kako priključite napajalne tirnice.

Breadboard Mini ima dve zgornji in spodnji dve vodili. Te priključimo na Arduino, da lahko zagotovimo napajanje več komponent. Kasneje v tej vadnici bomo uporabili 3 gumbe, zato bomo potrebovali več energije. Treba je opozoriti, da na majhni ploščici vodila vodijo po deski vodoravno. To se razlikuje od stolpcev na glavnem območju izdelave prototipov na sredini; te tečejo navpično. Za napajanje katerega koli stolpca v glavnem območju na sredini lahko uporabite katerega koli napajalnega zatiča.

Ko dodate napajanje, uporabite črne in rdeče žice na negativno oziroma pozitivno. Na koncu dodajte žice, ki napajajo drugo stran plošče. Te strani ne bomo uporabili, vendar je to dobra praksa.

Korak: Dodajte gumb in upor

Dodajte majhen gumb na pladnju za komponente. Izgledati mora kot na sliki. Prepričajte se, da ni stikalo! Dodajte tudi upor. Kliknite ga in nastavite vrednost na 10 kΩ. To je dovolj, da pin povlečete, ko ni povezan, kar je zelo pomembno pozneje v kodi.

Sestavni del postavite na sredino plošče. Gumb deluje na naslednji način:

• Od vogala do vogala, gumb ni povezan. S pritiskom na gumb zaprete stike in povežete vogale.
• Strani gumba sta povezani. Če bi žico priključili v zgornji levi in spodnji levi del, bi se vezje zaprlo.

Zato komponento postavimo čez prostor na sredini. Zagotavlja, da vogali niso povezani pod zatiči na plošči.

Naslednji korak ponuja nekaj slik, ki ponazarjajo te točke.

Upor postavite od spodnjega desnega zatiča čez stolpce, tako da leži vodoravno.

3. korak: Povezave gumbov

Na zgornjih slikah je precej jasno, kako se gumbi povežejo. Vedno je prišlo do zmede, ko mislite, da je vse v redu in ne deluje!

Zdaj pa dodajmo žice.

• Rdeči kabel iz pozitivnega napajalnega zatiča postavite v isti stolpec kot spodnji desni zatič na gumbu
• Postavite črni kabel iz negativnega vtiča v isti stolpec kot upor.
• Barvno žico (ne rdečo/črno) postavite od zgornjega levega zatiča do digitalnega zatiča 2 na Arduinu

Preverite zgornje slike in se prepričajte, da je ožičenje pravilno.

4. korak: Koda …

Oglejmo si kodo za osnovni gumb.

Odprite urejevalnik kod in preklopite iz blokov v besedilo. Počistite opozorilo, ki se prikaže. Veseli smo besedila!

Poznate osnovno nastavitev, zato določimo gumb in preberite osnovno branje. Izpis bomo natisnili v Serial.

V spodnjo kodo sem vstavil nekaj dodatnih komentarjev, tako da je lažje prebrati kot sliko.

// Določimo konstante

#define button 2 void setup () {pinMode (button, INPUT); Serial.begin (9600); } void loop () {// Preberite digitalni pin, da preverite stanje gumba int pritisnjeno = digitalRead (gumb); // Gumb vrne HIGH, če pritisnete, LOW, če ne, če (pritisnjeno == HIGH) {Serial.println ("Pritisnjeno!"); }}

Ok, to deluje!

V bistvu vse, kar počnemo, je preverjanje stanja digitalnega zatiča vsakič, ko se koda ponovi. Če kliknete Začni simulacijo in pritisnete gumb, se prikaže serijski monitor (kliknite gumb pod kodo), ki prikazuje "Pritisnjeno!" večkrat.

Ena od lastnosti, ki jih boste videli v zgornji kodi, je ocena stanja if (). Vse, kar počne koda, je v tem primeru postaviti vprašanje in oceniti, ali je res. Za preverjanje, ali je vrednost spremenljivke enaka določeni vrednosti, uporabljamo znak enako (dvojni enaki znaki, na primer: ==). DigitalRead () vrne visoko ali nizko.

Z uporabo if () else if / else lahko preverimo številne pogoje ali vse pogoje, in če se vrnete na osnove Arduina, boste videli nekaj primerjav, ki jih lahko naredite.

Zdaj … Naša koda bi lahko izgledala popolna … Imamo pa problem.

Glej, to zelo dobro deluje, ko si v simulatorju. Toda prava elektrika ima hrup, zlasti enosmerna elektronika. Tako lahko naš gumb včasih vrne napačno odčitavanje. In to je problem, ker se vaš projekt morda ne bo odzval na pravi način za uporabnika.

Popravimo!

5. korak: Malo odmika

Za premagovanje težave z gumbi uporabljamo postopek, imenovan debounce. To v bistvu čaka na določen čas med pritiskom na gumb in dejanskim odzivom na pritisk. Uporabniku se še vedno zdi naravno (razen če si vzamete čas predolgo). Uporabite ga lahko tudi za preverjanje dolžine pritiska, tako da se lahko vsakič odzovete drugače. Ožičenja vam ni treba spreminjati!

Poglejmo kodo:

#define button 2#define debounceTimeout 100

Prva sprememba je na globalnem področju. Spomnili se boste, da tukaj definiramo spremenljivke, ki bi jih lahko uporabljale številne naše funkcije, ali tiste, ki jih ni mogoče ponastaviti vsakič, ko se zanka sproži. Tako smo definiranim konstantam dodali debounceTimeout. Naredili smo 100 (kar bo kasneje prevedeno v 100 ms), lahko pa bi bilo krajše. Še dlje in počutil se bo nenaravno.

long int lastDebounceTime;

Ta spremenljivka je deklarirana pod konstantami. To je vrsta dolge int, ki nam v bistvu omogoča shranjevanje dolgih številk v pomnilnik. Poimenovali smo ga lastDebounceTime.

V funkciji void setup () nam ni treba ničesar spreminjati. Pustimo tole.

void loop () {// Preberite digitalni pin, da preverite stanje gumba int pritisnjeno = digitalRead (gumb); dolg int currentTime = millis (); // Koda gumba}

Prva sprememba, ki jo naredimo v funkciji loop (), je pod klicem za branje gumba. Spremljati moramo trenutni čas. Funkcija millis () vrne trenutni čas ure, odkar se je Arduino zagnal v milisekundah. To moramo shraniti v spremenljivko tipa int.

Zdaj se moramo prepričati, da se zavedamo časa, odkar je bil gumb pritisnjen, zato ponastavimo časovnik, ko ni pritisnjen. Poglej:

void loop () {// Preberite digitalni pin, da preverite stanje gumba int pritisnjeno = digitalRead (gumb); dolg int currentTime = millis (); if (pritisnjeno == LOW) {// Ponastavi čas štetja, medtem ko gumb ni pritisnjen lastDebounceTime = currentTime; } // Koda gumba}

Algoritem if (pritisnjen == LOW) preveri, če gumb ni pritisnjen. Če ni, potem koda shrani trenutni čas od zadnjega razkritja. Tako imamo ob vsakem pritisku gumba časovno točko, iz katere lahko preverimo, kdaj je bil gumb pritisnjen. Nato lahko naredimo hiter matematični izračun, da vidimo, kako dolgo je bil gumb pritisnjen, in se pravilno odzovemo. Poglejmo preostanek kode:

void loop () {// Preberite digitalni pin, da preverite stanje gumba int pritisnjeno = digitalRead (gumb); dolg int currentTime = millis (); if (pritisnjeno == LOW) {// Ponastavi čas štetja, medtem ko gumb ni pritisnjen lastDebounceTime = currentTime; } // Gumb je bil pritisnjen za določen čas, če (((currentTime - lastDebounceTime)> debounceTimeout)) {// Če je časovna omejitev dosežena, je gumb pritisnjen! Serial.println ("Stisnjeno!"); }}

Zadnji blok kode vzame trenutni čas, odšteje zadnji čas debounce in ga primerja s časovno omejitvijo, ki smo jo nastavili. Če je večja, koda predpostavlja, da je bil za ta čas pritisnjen gumb in se odzove. Lepo!

Zaženite kodo in preverite, ali deluje. Če imate napake, preverite kodo!

Zdaj pa poglejmo praktični primer.

6. korak: Ustvarjanje menija

Gumbi so zanimivi, saj je z njimi toliko možnosti! V tem primeru bomo naredili meni. Recimo, da ste ustvarili to res odlično napravo in potrebujete, da lahko uporabniki spremenijo možnosti, da vklopijo ali izklopijo določene stvari ali določijo določeno vrednost nastavitve. Ta oblika treh gumbov lahko to stori!

Torej, za ta projekt potrebujemo:

• Trije gumbi
• Trije upori nastavljeni na 10 kΩ

Enega od teh že imamo, druga dva potrebujemo. Zato jih dodajte na tablo. Ožičenje je nekoliko bolj zapleteno, vendar samo zato, ker sem želel, da bi bil res kompakten. Lahko uporabite isti vzorec za prvi gumb ali sledite zgornji sliki.

Trije gumbi so možnost odpiranja/naslednjega menija, možnost spremembe (kot v, spremenite nastavitev) in gumb menija za shranjevanje/zapiranje.

Poveži, poglejmo kodo!

7. korak: Razčlenitev kode - globalno

V redu, to bo dolg korak, vendar bom šel skozi vsak del kode.

Najprej poglejmo potrebne globalne spremenljivke.

// Določimo konstante #define menuButton 2 #define menuSelect 3 #define menuSave 4 #define debounceTimeout 50 // Določimo spremenljivke int menuButtonPreviousState = LOW; int menuSelectPreviousState = NIZKO; int menuSavePreviousState = LOW; long int lastDebounceTime; // Možnosti menija char * menuOptions = {"Check Temp", "Check Light"}; bool featureSetting = {false, false}; bool menuMode = false; bool menuNeedsPrint = false; int optionSelected = 0;

Ti trije bloki so precej podobni tistemu, kar smo videli prej. V prvem sem definiral tri gumbe in časovno omejitev. Za ta del projekta sem ga nastavil na 50 ms, zato je za njegovo delovanje potreben namerni pritisk.

Drugi blok so vse spremenljivke. Spremljati moramo gumbPreviousState in slediti lastDebounceTime. Vse so spremenljivke tipa int, vendar je zadnja dolga, ker predvidevam, da potrebujemo prostor v pomnilniku.

Blok možnosti menija ima nekaj novih funkcij. Najprej char * (ja, to je namerna zvezdica), ki je dobesedna spremenljivka znak/niz. Je kazalec na statično shranjevanje v pomnilniku. Ne morete ga spremeniti (kot na primer v Pythonu). Ta vrstica char *menuOptions ustvari niz literalov nizov. Dodate lahko poljubno število elementov menija.

Spremenljivka bool featureSetting je le niz vrednosti, ki predstavlja vsako postavko menija. Da, lahko shranite karkoli želite, samo spremenite vrsto spremenljivke (vse morajo biti iste vrste). Morda obstajajo boljši načini za upravljanje tega, na primer slovarji ali torbice, vendar je to preprosto za to aplikacijo. Verjetno bi enega od slednjih ustvaril v uvedeni aplikaciji.

Spremljal sem menuMode, zato bi to lahko storil, če bi na svojem zaslonu želel druge stvari. Če bi imel logiko senzorja, bi to lahko med delovanjem menija začasno ustavil, v primeru, da bi kaj prišlo do spora. Imam spremenljivko menuNeedsPrint, ker želim natisniti meni ob določenem času, ne le ves čas. Končno imam spremenljivko optionSelected, tako da lahko spremljam izbrano možnost, ko do nje dostopam na številnih mestih.

Poglejmo naslednji niz funkcij.

8. korak: Razčlenitev kode - nastavitve in funkcije po meri

Funkcija setup () je dovolj preprosta, samo tri vhodne izjave:

void setup () {pinMode (menuSelect, INPUT); pinMode (menuSave, INPUT); pinMode (menuSelect, INPUT); Serial.begin (9600); }

Sledijo tri funkcije po meri. Poglejmo najprej dva, nato še zadnjega posebej.

Potrebujemo dve funkciji, ki vračata nekaj informacij. Razlog je v tem, da se želimo prepričati, da je to nekako berljivo za ljudi. Pomagalo bo tudi pri odpravljanju napak v kodi, če imamo težave. Koda:

// Funkcija za vrnitev trenutno izbrane možnostichar *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // možnost vrnitveIzbrano vrnitev menuOption; } // Funkcija za vrnitev stanja trenutno izbrane možnosti char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; if (optionSetting == false) {optionSettingVal = "False"; } else {optionSettingVal = "True"; } // Možnost vrnitveSetting return optionSettingVal; }

Funkcija char *ReturnOptionSelected () preveri izbrano možnost (če vidite zgoraj, nastavimo spremenljivko za sledenje temu) in potegne literalni niz iz matrike, ki smo jo ustvarili prej. Nato ga vrne kot tip znakov. To vemo, ker funkcija označuje vrsto vrnitve.

Druga funkcija, char *ReturnOptionStatus () prebere stanje možnosti, shranjene v matriki, in vrne literal, ki predstavlja vrednost. Na primer, če je shranjena nastavitev false, bi vrnil "False". To je zato, ker uporabniku pokažemo to spremenljivko in je bolje, da vso to logiko ohranimo skupaj. Lahko bi to storil pozneje, vendar je tukaj bolj smiselno.

// Funkcija za preklop trenutne optionbool ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; vrni true; }

Funkcija bool ToggleOptionSelected () je priročna funkcija za spreminjanje vrednosti nastavitve, ki smo jo izbrali v meniju. Samo obrne vrednost. Če bi imeli bolj zapleten nabor možnosti, bi bilo to lahko precej drugače. V tej funkciji vrnem true, ker moj povratni klic (klic pozneje v kodi, ki sproži to funkcijo) pričakuje pravilen/napačen odgovor. 100% sem prepričan, da bo to delovalo, zato nisem upošteval, da ne deluje, bi pa v razmeščeni aplikaciji (za vsak slučaj).

9. korak: Zanka …

Funkcija loop () je precej dolga, zato jo bomo izvajali po delih. V tej funkciji lahko domnevate vse, kar je spodaj:

void loop () {

// Tukaj delajte <-----}

Ok, to smo že videli:

// Preberite gumbe int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalno branje (menuSelect); int menuSavePressed = digitalRead (menuSave); // Pridobite trenutni čas dolg int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// Ponastavi čas štetja, medtem ko gumb ni pritisnjen zadnjiDebounceTime = currentTime; menuButtonPreviousState = NIZKO; menuSelectPreviousState = NIZKO; menuSavePreviousState = NIZKO; }

Tukaj sem moral samo dodati tri klice digitalRead () in se prepričati, da sem upošteval dejstvo, da moramo, če so vsi gumbi nizki, ponastaviti časovnik (lastDebounceTime = currentTime) in vsa prejšnja stanja nastaviti na nizko. Shranjujem tudi millis () v currentTime.

Naslednji razdelek gnezdi v vrstici

if ((((currentTime - lastDebounceTime)> debounceTimeout)) {

// Delajte tukaj <----}

Obstajajo trije odseki. Da, lahko bi jih premaknil v njihove lastne funkcije, vendar sem zaradi poenostavitve obdržal tri glavne algoritme gumbov.

if ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // Uporabniku sporočimo Serial.println ("Meni je aktiven"); } else if (menuMode == true && optionSelected = 1) {// Ponastavi možnost optionSelected = 0; } // Natisni meni menuNeedsPrint = true; // Preklop gumba prev. stanje samo za prikaz menija // če gumb spustite in znova pritisnete menuButtonPreviousState = menuButtonPressed; // bi bilo HIGH}

Ta prva obravnava, ko je menuButtonPressed visoko, ali ko pritisnete gumb menija. Prav tako preveri, ali je bilo prejšnje stanje NIZKO, tako da je bilo treba gumb pritisniti, preden ga znova pritisnete, kar prepreči, da bi program vedno znova sprožil isti dogodek.

Nato preveri, če ga meni ne aktivira, ga aktivira. Natisnil bo prvo izbrano možnost (ki je privzeto prva postavka v polju menuOptions. Če pritisnete gumb drugi ali tretji (itd.) Čas, boste dobili naslednjo možnost na seznamu. Nekaj, kar bi lahko popravil, je da, ko pride do konca, se vrne nazaj na začetek. To bi lahko prebralo dolžino matrike in olajšalo kolesarjenje nazaj, če bi spremenili število možnosti, vendar je bilo to zaenkrat preprosto.

Zadnji majhen odsek (// Natisne meni) očitno natisne meni, vendar tudi nastavi prejšnje stanje na VISOKO, tako da se ista funkcija ne ponovi (glejte mojo opombo zgoraj o preverjanju, če je bil gumb prej NIZK).

// menuSelect je pritisnjen, vnesite logicif ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// Spremenite izbrano možnost // Trenutno je to res/napačno // vendar lahko je karkoli bool toggle = ToggleOptionSelected (); if (preklop) {menuNeedsPrint = true; } else {Serial.println ("Nekaj je šlo narobe. Poskusite znova"); }} // Preklopi stanje, da se preklopi le, če ga spustite in znova pritisnete menuSelectPreviousState = menuSelectPressed; }

Ta del kode obravnava gumb menuSelectPressed na enak način, le da tokrat sprožimo samo funkcijo ToggleOptionSelected (). Kot sem že rekel, lahko to funkcijo spremenite, da naredi več, vendar to je vse, kar potrebujem.

Glavna stvar, ki jo je treba omeniti, je preklopna spremenljivka, ki sledi uspehu povratnega klica in natisne meni, če je res. Če ne vrne nič ali napačno, natisne sporočilo o napaki. Tukaj lahko uporabite povratni klic za druge stvari.

if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// Zapustite meni // Tu lahko naredite kakršno koli pospravljanje // ali shranite v EEPROM menuMode = false; Serial.println ("Izhod iz menija"); // Preklopi stanje, tako da meni izstopi le enkrat menuSavePreviousState = menuSavePressed; }}

Ta funkcija upravlja gumb SaveSave, ki zapušča meni. Tu bi lahko imeli možnost preklica ali shranjevanja, morda počistili ali shranili v EEPROM. Natisnem samo "Meni je zapustil" in stanje gumba nastavim na HIGH, da se ne vrti.

if (menuMode && menuNeedsPrint) {// Meni smo natisnili, zato, razen če se // kaj ne zgodi, ni potrebe po ponovnem tiskanju menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("Izbrano:"); Serial.print (optionActive); Serial.print (":"); Serial.print (optionStatus); Serial.println (); }

To je algoritem menuPrint, ki se sproži le, če je meni aktiven in ko je spremenljivka menuNeedsPrint nastavljena na true.

To bi vsekakor lahko premaknili v svojo funkcijo, a zaradi preprostosti..!

No, to je to! Za celoten kodni niz si oglejte naslednji korak.

10. korak: Končni blok kode

// Določimo konstante

#define menuButton 2 #define menuSelect 3 #define menuSave 4 #define debounceTimeout 50 int menuButtonPreviousState = LOW; int menuSelectPreviousState = NIZKO; int menuSavePreviousState = LOW; // Določimo spremenljivke long int lastDebounceTime; bool lightSensor = true; bool tempSensor = true; // Možnosti menija char * menuOptions = {"Check Temp", "Check Light"}; bool featureSetting = {false, false}; bool menuMode = false; bool menuNeedsPrint = false; int optionSelected = 0; // Nastavitvena funkcija

void setup () {pinMode (menuSelect, INPUT); pinMode (menuSave, INPUT); pinMode (menuSelect, INPUT); Serial.begin (9600); }

// Funkcija za vrnitev trenutno izbrane možnosti char *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // možnost vrnitveIzbrano vrnitev menuOption; } // Funkcija za vrnitev stanja trenutno izbrane možnosti char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; if (optionSetting == false) {optionSettingVal = "False"; } else {optionSettingVal = "True"; } // Možnost vrnitveSetting return optionSettingVal; } // Funkcija za preklop trenutne možnosti bool ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; vrni true; } // Glavna zanka

void loop () {// Preberite gumbe int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalno branje (menuSelect); int menuSavePressed = digitalRead (menuSave); // Pridobite trenutni čas dolg int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// Ponastavi čas štetja, medtem ko gumb ni pritisnjen zadnjiDebounceTime = currentTime; menuButtonPreviousState = NIZKO; menuSelectPreviousState = NIZKO; menuSavePreviousState = NIZKO; } if ((((currentTime - lastDebounceTime)> debounceTimeout)) {// Če je časovna omejitev dosežena, pritisnemo gumb!

// menuButton je pritisnjen, podaj logiko

// Sproži se le, če je bil gumb že sproščen, če ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // Uporabniku sporočimo Serial.println ("Meni je aktiven"); } else if (menuMode == true && optionSelected = 1) {// Ponastavi možnost optionSelected = 0; } // Natisni meni menuNeedsPrint = true; // Preklop gumba prev. stanje samo za prikaz menija // če gumb spustite in znova pritisnete menuButtonPreviousState = menuButtonPressed; // Bi bilo HIGH} // menuSelect je pritisnjeno, vnesite logiko if ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// Spremenite izbrano možnost // Trenutno je to samo true/false // lahko pa je karkoli bool toggle = ToggleOptionSelected (); if (preklop) {menuNeedsPrint = true; } else {Serial.print ("Nekaj je šlo narobe. Poskusite znova"); }} // Preklopi stanje, da se preklopi le, če ga spustite in znova pritisnete menuSelectPreviousState = menuSelectPressed; } if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// Izhod iz menija // Tu lahko naredite kakršno koli pospravljanje // ali shranite v EEPROM menuMode = false; Serial.println ("Izhod iz menija"); // Preklopi stanje, tako da meni izstopi le enkrat menuSavePreviousState = menuSavePressed; }} // Natisni trenutno možnost menija aktivno, vendar jo natisnite le enkrat, če (menuMode && menuNeedsPrint) {// Natisnili smo meni, zato, če se // nič ne zgodi, ni treba znova tiskati menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("Izbrano:"); Serial.print (optionActive); Serial.print (":"); Serial.print (optionStatus); Serial.println (); }}}

Vezje je na voljo na spletnem mestu Tinkercad. Spodaj sem vgradil vezje, da ga vidite tudi vi!

Kot vedno, če imate vprašanja ali težave, mi to sporočite!