Arduino menüü ja nuppude kasutamine: 10 sammu (piltidega)

2024 Autor: John Day | [email protected]. Viimati modifitseeritud: 2024-01-30 08:48

Minu Arduino 101 õpetuses õpetatakse teile, kuidas oma keskkonda Tinkercadis seadistada. Kasutan Tinkercadi, kuna see on päris võimas veebiplatvorm, mis võimaldab mul demonstreerida õpilastele erinevaid oskusi vooluahelate ehitamiseks. Ehita julgelt kõik minu õpetused Arduino IDE ja tõelise Arduino abil!

Selles õpetuses õpime nuppude kohta! Peame teadma:

• Kuidas neid ühendada
• Nende väärtuse lugemine
• Debounce ja miks see on oluline
• Praktiline rakendus (menüü koostamine)

Enamik inimesi arvab, et kõige praktilisem asi, mida nupuga teha, on tule sisse- ja väljalülitamine. Meie, mitte siin! Kasutame oma menüü loomiseks ja Arduino jaoks mõne valiku seadistamiseks.

Valmis? Alustame!

Samm: paneeli seadistamine

Esimene samm on panna Arduino ja Breadboard Small prototüüpimise alale. Kontrollige ülaltoodud pilte, et näha, kuidas toitepiiret ühendada.

Breadboard Mini -l on kaks ülemist ja alumist toitepiiret. Me ühendame need Arduinoga, et saaksime toita rohkem komponente. Hiljem kasutame selles õpetuses kolme nuppu, nii et vajame rohkem energiat. Tähelepanuväärne on see, et väikese leivaplaadil jooksevad toitepiirded horisontaalselt üle laua. See erineb peamise prototüüpimisala veergudest keskel; need jooksevad vertikaalselt. Saate kasutada mis tahes toitenuppe, et toita toiteallikaid keskse põhiala igasse veergu.

Kui lisate toite, kasutage musta ja punast juhtmeid vastavalt negatiivsele ja positiivsele. Lisage otsa juhtmed, mis toovad voolu plaadi teisele küljele. Me ei kasuta seda poolt, kuid see on hea tava.

Samm: lisage nupp ja takisti

Lisage komponentide salve väike nupp. See peaks välja nägema nagu pildil. Veenduge, et see pole lüliti! Lisage ka takisti. Klõpsake seda ja määrake selle väärtuseks 10 kΩ. Sellest piisab, et tõmmata tihvt madalale, kui see pole ühendatud, mis on koodi hiljem väga oluline.

Asetage komponent leivalaua keskele. Nupp töötab järgmiselt.

• Nurk nurgani, nupp pole ühendatud. Nupu vajutamine sulgeb kontaktid ja ühendab nurgad.
• Nupu küljed on ühendatud. Kui ühendaksite juhtme vasakus ülanurgas ja all vasakul, oleks ahel suletud.

Sellepärast paneme komponendi üle ruumi keskel. See tagab, et nurgad ei ole tahvli tihvtide all ühendatud.

Järgmine samm pakub paar pilti, mis illustreerivad neid punkte.

Asetage takisti parempoolsest alumisest tihvtist üle veergude, nii et see asetseb horisontaalselt.

Samm: nupuühendused

Ülaltoodud piltidel on üsna selge, kuidas nupud ühenduvad. See oli alati segadusttekitav, kui arvate, et midagi on hästi ja see ei tööta!

Nüüd lisame juhtmed.

• Asetage positiivse toitepistiku punane juhe nupu alumise parema tihvtiga samasse veergu
• Asetage negatiivne toitetihvtist must juhe takistiga samasse veergu.
• Asetage värviline traat (mitte punane/must) ülemisest vasakust tihvtist Arduino digitaalsele tihvtile 2

Kontrollige ülaltoodud pilte, et veenduda juhtmestiku õigsuses.

Samm: kood:…

Vaatame põhinupu koodi.

Avage koodiredaktor ja muutke plokkidest tekstiks. Kustutage ilmuv hoiatus. Oleme tekstiga rahul!

Te teate põhiseadistust, nii et määratleme nupu ja teeme põhilugemise. Prindime väljundi seriaalile.

Lisasin allolevasse koodi mõned lisakommentaarid, et seda oleks lihtsam lugeda kui pilti.

// Määra konstandid

#define button 2 void setup () {pinMode (nupp, INPUT); Seriaalne algus (9600); } void loop () {// Loe digitaalset tihvti, et kontrollida nupu olekut int vajutatud = digitalRead (nupp); // Nupp tagastab vajutamisel HIGH, LOW kui mitte kui (vajutatud == HIGH) {Serial.println ("Pressitud!"); }}

Ok, see töötab!

Põhimõtteliselt kontrollime iga kord, kui kood kordub, digitaalse tihvti olekut. Kui klõpsate nuppu Alusta simulatsiooni ja vajutate nuppu, näete jadamonitori (klõpsake koodi all olevat nuppu) ekraanil "Pressitud!" korduvalt.

Üks funktsioon, mida näete ülaltoodud koodis, on tingimuste if () hindamine. Kogu kood teeb ainult küsimuse ja hindab, kas see on antud juhul tõsi. Kontrollime, kas muutuja väärtus on teatud väärtusega võrdne, kasutades võrdusmärki (topelt võrdusmärgid, näiteks see: ==). DigitalRead () tagastab kas HIGH või LOW.

Kasutades if () else if / else saame kontrollida paljusid tingimusi või kõiki tingimusi ja kui naasete Arduino põhitõdede juurde, näete mõningaid võrdlusi, mida saate teha.

Nüüd … Meie kood võib tunduda täielik … Aga meil on probleem.

Vaata, see töötab simulaatoris tõesti hästi. Kuid päris elektril on müra, eriti alalisvoolu elektroonika. Nii et meie nupp võib mõnikord vale näidu tagasi saata. Ja see on probleem, sest teie projekt ei pruugi kasutaja jaoks õigesti vastata.

Parandame ära!

5. samm: väike tagasilöök

Nupuprobleemi lahendamiseks kasutame protseduuri nimega debounce. See ootab sisuliselt teatud ajavahemikku nupu vajutamise ja vajutamisele tegelikult reageerimise vahel. See tundub kasutajale endiselt loomulik (kui te ei tee aega liiga pikaks). Saate seda kasutada ka vajutamise pikkuse kontrollimiseks, nii et saate iga kord erinevalt reageerida. Te ei pea ühtegi juhtmestikku vahetama!

Vaatame koodi:

#define nupp 2#define debounceTimeout 100

Esimene muudatus puudutab globaalset ulatust. Mäletate, et siin määratleme muutujad, mida paljud meie funktsioonid võivad kasutada, või need, mida ei saa iga kord käivitada. Niisiis lisasime määratud konstantidele debounceTimeout. Tegime selle 100 (mis hiljem tõlgitakse 100 ms -ks), kuid see võiks olla lühem. Veel kauem ja see tundub ebaloomulik.

long int lastDebounceTime;

See muutuja deklareeritakse konstantidest allapoole. See on pikk int -tüüp, mis põhimõtteliselt võimaldab meil pikki numbreid mällu salvestada. Me nimetasime seda lastDebounceTime.

Funktsioonis void setup () ei pea me midagi muutma. Jätame selle.

void loop () {// Loe digitaalset tihvti, et kontrollida nupu olekut int vajutatud = digitalRead (nupp); pikk int praegune aeg = millis (); // Nupu kood}

Esimene muudatus funktsioonis loop () on nupu lugemise kutse all. Peame jälgima praegust aega. Funktsioon millis () tagastab kella praeguse aja pärast Arduino käivitamist millisekundites. Peame selle salvestama pika int tüüpi muutujaga.

Nüüd peame veenduma, et oleme teadlikud ajast, mis möödus nupu vajutamisest, nii et lähtestame taimeri, kui seda ei vajutata. Vaata:

void loop () {// Loe digitaalset tihvti, et kontrollida nupu olekut int vajutatud = digitalRead (nupp); pikk int praegune aeg = millis (); if (vajutatud == LOW) {// Lähtesta loendusaeg, kui nuppu ei vajutata lastDebounceTime = currentTime; } // Nupu kood}

Kui (vajutatud == LOW) algoritm kontrollib, kas nuppu ei vajutata. Kui ei, siis salvestab kood praeguse aja pärast viimast väljalülitamist. Nii on meil iga kord, kui nuppu vajutatakse, ajahetk, millest alates saame kontrollida, millal nuppu vajutati. Seejärel saame teha kiire matemaatilise arvutuse, et näha, kui kaua nuppu vajutati, ja vastata õigesti. Vaatame ülejäänud koodi:

void loop () {// Loe digitaalset tihvti, et kontrollida nupu olekut int vajutatud = digitalRead (nupp); pikk int praegune aeg = millis (); if (vajutatud == LOW) {// Lähtesta loendusaeg, kui nuppu ei vajutata lastDebounceTime = currentTime; } // Nuppu on teatud aja jooksul vajutatud, kui ((((currentTime - lastDebounceTime)> debounceTimeout)) {// Kui aeg on täis, vajutage nuppu! Serial.println ("Vajutatud!"); }}

Viimane koodiplokk võtab praeguse aja, lahutab viimase tagasilükkamisaja ja võrdleb seda meie määratud ajalõpuga. Kui see on suurem, eeldab kood, et nuppu on selle aja jooksul vajutatud, ja vastab. Korralik!

Käivitage oma kood ja kontrollige, kas see töötab. Kui teil on vigu, kontrollige oma koodi!

Vaatame nüüd praktilist näidet.

6. samm: menüü koostamine

Nupud on huvitavad, sest nendega on nii palju võimalusi! Selles näites teeme menüü. Oletame, et olete loonud selle tõeliselt suurepärase seadme ja vajate, et kasutajad saaksid muuta teatud asjade sisse- ja väljalülitamise valikuid või määrata konkreetsele väärtusele. See kolme nupuga disain suudab seda teha!

Niisiis, selle projekti jaoks vajame:

• Kolm nuppu
• Kolm takistit on seatud väärtusele 10 kΩ

Üks neist on meil juba olemas, vajame lihtsalt kahte teist. Nii et lisage need tahvlile. Juhtmestik on natuke keerulisem, kuid ainult sellepärast, et tahtsin selle tõesti kompaktsena hoida. Esimese nupu puhul võite järgida sama mustrit või ülaltoodud pilti.

Kolm nuppu on menüü avamise/järgmise valiku valik, muutmise suvand (nagu on muudetud seadistust) ja menüü salvestamise/sulgemise nupp.

Ühendage see juhtmega, vaatame koodi!

7. samm: koodi jaotus - globaalne

Ok, see saab olema pikk samm, kuid ma lähen läbi iga koodiosa.

Kõigepealt vaatame vajalikke globaalseid muutujaid.

// Defineeri konstandid #define menuButton 2 #define menuSelect 3 #define menuSave 4 #define debounceTimeout 50 // Määra muutujad int menuButtonPreviousState = LOW; int menuSelectPreviousState = LOW; int menuSavePreviousState = LOW; long int lastDebounceTime; // Menüüvalikud char * menuOptions = {"Check Temp", "Check Light"}; bool featureSetting = {vale, vale}; bool menuMode = vale; bool menuNeedsPrint = false; int optionSelected = 0;

Need kolm plokki on üsna sarnased sellega, mida oleme varem näinud. Esimeses olen määratlenud kolm nuppu ja ajalõpu. Selle projekti osa jaoks olen määranud selle 50 ms, nii et selle toimimiseks on vaja tahtlikku pressi.

Teine plokk on kõik muutujad. Peame jälgima nuppuPreviousState ja peame jälgima lastDebounceTime. Need kõik on int tüüpi muutujad, kuid viimane on pikk tüüp, sest eeldan, et vajame mäluruumi.

Menüüvalikute plokil on mõned uued funktsioonid. Esiteks char * (jah, see on tahtlik tärn), mis on tegelase/stringi sõnasõnaline muutuja. See on osuti staatilisele mäluruumile. Te ei saa seda muuta (nagu näiteks Pythonis). See rida char *menuOptions loob rea stringide literaale. Saate lisada nii palju menüüelemente kui soovite.

Muutuja bool featureSetting on lihtsalt väärtuste massiiv, mis esindab iga menüüelementi. Jah, võite salvestada kõike, mis teile meeldib, muutke lihtsalt muutuja tüüpi (kõik peavad olema sama tüüpi). Nüüd võib selle haldamiseks olla paremaid viise, nagu sõnaraamatud või numbrid, kuid see on selle rakenduse jaoks lihtne. Tõenäoliselt looksin ühe viimastest juurutatud rakenduses.

Olen jälginud menüürežiimi, nii et kui ma sooviksin oma ekraanile muid asju, saaksin seda teha. Samuti, kui mul oleks anduriloogika, võin selle menüü toimimise ajal peatada, juhuks kui midagi vastu peaks. Mul on menuNeedsPrint muutuja, sest soovin menüüd printida kindlatel aegadel, mitte ainult kogu aeg. Lõpuks on mul ka muutuja optsioon

Vaatame järgmist funktsioonide komplekti.

8. samm: koodi jaotus - seadistamine ja kohandatud funktsioonid

Funktsioon setup () on piisavalt lihtne, vaid kolm sisenddeklaratsiooni:

void setup () {pinMode (menuSelect, INPUT); pinMode (menuSave, INPUT); pinMode (menuSelect, INPUT); Seriaalne algus (9600); }

Järgmisena on kolm kohandatud funktsiooni. Vaatame kahte esimest, seejärel viimast eraldi.

Vajame kahte funktsiooni, mis tagastavad teatud teabe. Põhjus on selles, et tahame veenduda, et see on inimesele loetav. See aitab ka koodi silumisel, kui meil on probleem. Kood:

// Funktsioon praeguse valitud suvandi tagastamisekschar *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // TagastamisvalikValitud tagastamismenüüOption; } // Funktsioon praeguse valitud valiku oleku tagastamiseks char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; if (optionSetting == false) {optionSettingVal = "Vale"; } else {optionSettingVal = "Tõsi"; } // TagastamisvalikTagastusvaliku seadmineSettingVal; }

Funktsioon char *ReturnOptionSelected () kontrollib valitud suvandit (kui näete ülal, seadistame selle muutmiseks muutuja) ja tõmbab stringi literaali varem loodud massiivist. Seejärel tagastab see sümbolitüübina. Me teame seda, sest funktsioon näitab tagastamise tüüpi.

Teine funktsioon char *ReturnOptionStatus () loeb massiivi salvestatud suvandi oleku ja tagastab väärtuse tähistava stringi literaali. Näiteks kui meie salvestatud säte on vale, tagastaksin ma „False”. Seda seetõttu, et näitame kasutajale seda muutujat ja parem on kogu see loogika koos hoida. Ma saaksin seda hiljem teha, kuid siin on seda mõttekam teha.

// Funktsioon praeguse valikukasti vahetamiseks ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; tagastama tõene; }

Funktsioon bool ToggleOptionSelected () on mugavusfunktsioon, mille abil saab muuta menüüs valitud sätte väärtust. See lihtsalt pöörab väärtuse ümber. Kui teil oleks keerulisem valikute komplekt, võib see olla hoopis teistsugune. Selle funktsiooni korral vastan tõele, sest minu tagasihelistamine (kõne selle funktsiooni käivitanud koodis hiljem) ootab tõelist/vale vastust. Olen 100% kindel, et see töötab, nii et ma ei arvestanud sellega, et see ei tööta, kuid kasutan seda juurutatud rakenduses (igaks juhuks).

Samm: silmus…

Funktsioon loop () on üsna pikk, seega teeme seda osade kaupa. Selle funktsiooni raames saate eeldada kõike, mis on allpool:

void loop () {

// Tee tööd siin <-----}

Ok, me nägime seda asja varem:

// Loe nuppe int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalRead (menuSelect); int menuSavePressed = digitalRead (menuSave); // Hangi praegune aeg long int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// Lähtesta loendusaeg, kui nuppu ei vajutata lastDebounceTime = currentTime; menuButtonPreviousState = LOW; menuSelectPreviousState = LOW; menuSavePreviousState = LOW; }

Kõik, mida ma pidin siin tegema, oli lisada kolm digitalRead () kõnet ja veenduda, et võtsin arvesse asjaolu, et kui kõik nupud on madalad, peaksime taimeri (lastDebounceTime = currentTime) lähtestama ja seadma kõik eelmised olekud madalaks. Samuti salvestan millis () praeguses ajas.

Järgmine jagu pesitseb liini sees

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

// Tee tööd siin <----}

Seal on kolm sektsiooni. Jah, ma oleksin võinud need oma funktsioonidesse üle viia, kuid lihtsuse huvides jätsin siia kolm peamist nuppude algoritmi.

if ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // Andke kasutajale teada Serial.println ("Menüü on aktiivne"); } else if (menuMode == true && optionSelected = 1) {// Lähtesta valikuvõimalusSelected = 0; } // Prindi menüümenüüNeedsPrint = true; // Lülita nupp sisse eelmine. olek ainult menüü kuvamiseks // kui nupp vabastatakse ja uuesti vajutatakse menuButtonPreviousState = menuButtonPressed; // Oleks HIGH}

See esimene saab hakkama, kui menuButtonPressed on HIGH või kui vajutatakse menüünuppu. Samuti kontrollitakse, kas eelmine olek oli LOW, nii et nupp tuli vabastada enne selle uuesti vajutamist, mis takistab programmil pidevalt sama sündmust uuesti käivitada.

Seejärel kontrollib see, et kui menüü pole aktiivne, aktiveerib see selle. See prindib esimese valitud valiku (mis on vaikimisi menüü Valikud massiiv üksus. Kui vajutate nuppu teist või kolmandat korda (jne), saate loendist järgmise valiku. Midagi, mida saaksin parandada, on et kui see jõuab lõpuni, liigub see tagasi algusesse. See võib lugeda massiivi pikkust ja lihtsustada jalgrattasõitu, kui muudate valikute arvu, kuid see oli praegu lihtne.

Viimane väike sektsioon (// prindib menüü) ilmselgelt prindib menüü, kuid seab ka eelmisele olekule HIGH, nii et sama funktsioon ei hakka ringlema (vt minu ülaltoodud märkust selle kohta, kas nupp oli varem LOW).

// menuSelect on vajutatud, anna logifif ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// Muuda valitud valikut // Hetkel on see lihtsalt tõene/vale // aga võib olla mis tahes bool toggle = ToggleOptionSelected (); if (toggle) {menuNeedsPrint = true; } else {Serial.println ("Midagi läks valesti. Palun proovige uuesti"); }} // Lülitage olek sisse või välja ainult siis, kui see vabastatakse ja uuesti vajutatakse menuSelectPreviousState = menuSelectPressed; }

See koodibitt tegeleb menüügaSelectPressed nupp samamoodi, välja arvatud see kord, kui käivitame funktsiooni ToggleOptionSelected (). Nagu ma juba ütlesin, saate seda funktsiooni muuta, nii et see teeb rohkem, kuid see on kõik, mida ma vajan.

Peamine asi, mida tuleb märkida, on lülitusmuutuja, mis jälgib tagasihelistamise edukust ja prindib menüü, kui see on tõene. Kui see ei tagasta midagi või vale, prindib see veateate. Siin saate tagasihelistamist kasutada muude asjade tegemiseks.

if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// Menüüst väljumine // Siin saate teha mis tahes korrastamist // või salvestada EEPROM -i menuMode = false; Serial.println ("Menüü väljus"); // Lülita olek sisse, nii et menüü väljub menüüst ainult üks kord menuSavePreviousState = menuSavePressed; }}

See funktsioon käsitleb menüü salvestamise nuppu, mis väljub menüüst. Siin saate valida tühistamise või salvestamise võimaluse, võib -olla koristada või salvestada EEPROM -i. Prindin lihtsalt välja "Menüü väljus" ja määran nuppude olekuks KÕRGE, nii et see ei muutuks silmusena.

if (menuMode && menuNeedsPrint) {// Menüü on trükitud, nii et kui midagi // ei juhtu, pole vaja seda uuesti printida menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("Valitud:"); Serial.print (optionActive); Serial.print (":"); Serial.print (optionStatus); Serial.println (); }

See on menuPrint algoritm, mis käivitub ainult siis, kui menüü on aktiivne ja kui muutuja menuNeedsPrint on seatud väärtusele true.

Selle võiks kindlasti oma funktsioonile üle viia, kuid lihtsuse huvides..!

Noh, see on kõik! Vaadake kogu koodiploki järgmist sammu.

10. samm: lõplik koodiplokk

// Määra konstandid

#define menüüNupp 2 #defineerimismenüüValige 3 #define menüüSalvesta 4 #define debounceTimeout 50 int menuButtonPreviousState = LOW; int menuSelectPreviousState = LOW; int menuSavePreviousState = LOW; // Määra muutujad long int lastDebounceTime; bool lightSensor = tõsi; bool tempSensor = tõsi; // Menüüvalikud char * menuOptions = {"Check Temp", "Check Light"}; bool featureSetting = {vale, vale}; bool menuMode = vale; bool menuNeedsPrint = false; int optionSelected = 0; // Seadistusfunktsioon

void setup () {pinMode (menuSelect, INPUT); pinMode (menuSave, INPUT); pinMode (menuSelect, INPUT); Seriaalne algus (9600); }

// Funktsioon praeguse valitud suvandi tagastamiseks char *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // TagastamisvalikValitud tagastamismenüüOption; } // Funktsioon praeguse valitud valiku oleku tagastamiseks char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; if (optionSetting == false) {optionSettingVal = "Vale"; } else {optionSettingVal = "Tõsi"; } // TagastamisvalikTagastusvaliku seadmineSettingVal; } // Funktsioon praeguse suvandi booli vahetamiseks ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; tagastama tõene; } // Põhisilmus

void loop () {// Loe nuppe int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalRead (menuSelect); int menuSavePressed = digitalRead (menuSave); // Hangi praegune aeg long int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// Lähtesta loendusaeg, kui nuppu ei vajutata lastDebounceTime = currentTime; menuButtonPreviousState = LOW; menuSelectPreviousState = LOW; menuSavePreviousState = LOW; } if ((((currentTime - lastDebounceTime)> debounceTimeout)) {// Kui aeg on täis, vajutage nuppu!

// menüünuppu vajutatakse, andke loogika

// Käivitub ainult siis, kui nupp on eelnevalt vabastatud, kui ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // Andke kasutajale teada Serial.println ("Menüü on aktiivne"); } else if (menuMode == true && optionSelected = 1) {// Lähtesta valikuvõimalusSelected = 0; } // Prindi menüümenüüNeedsPrint = true; // Lülita nupp sisse eelmine. olek ainult menüü kuvamiseks // kui nupp vabastatakse ja uuesti vajutatakse menuButtonPreviousState = menuButtonPressed; // oleks HIGH} // menuSelect on vajutatud, anna loogika, kui ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// Muuda valitud suvandit // Praegu on see just tõene/vale // aga võib olla ükskõik milline bool toggle = ToggleOptionSelected (); if (toggle) {menuNeedsPrint = true; } else {Serial.print ("Midagi läks valesti. Palun proovige uuesti"); }} // Lülitage olek sisse või välja ainult siis, kui see vabastatakse ja uuesti vajutatakse menuSelectPreviousState = menuSelectPressed; } if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// Menüüst väljumine // Siin saate teha mis tahes korrastamist // või salvestada EEPROM -i menuMode = false; Serial.println ("Menüü väljus"); // Lülita olek sisse, nii et menüü väljub menüüst ainult üks kord menuSavePreviousState = menuSavePressed; }} // Printige praegune menüüvalik aktiivseks, kuid printige see ainult üks kord, kui (menuMode && menuNeedsPrint) {// Oleme menüü printinud, nii et kui midagi // ei juhtu, pole vaja seda uuesti printida menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("Valitud:"); Serial.print (optionActive); Serial.print (":"); Serial.print (optionStatus); Serial.println (); }}}

Vooluring on saadaval Tinkercadi saidil. Olen lisanud alloleva vooluringi ka teile vaatamiseks!

Nagu alati, kui teil on küsimusi või probleeme, palun andke mulle sellest teada!