Izvēlne Arduino un pogu lietošana: 10 soļi (ar attēliem)

2024 Autors: John Day | [email protected]. Pēdējoreiz modificēts: 2024-01-30 10:56

Manā Arduino 101 apmācībā jūs iemācīsit iestatīt savu vidi Tinkercad. Es izmantoju Tinkercad, jo tā ir diezgan spēcīga tiešsaistes platforma, kas ļauj studentiem demonstrēt dažādas prasmes shēmu veidošanai. Jūtieties brīvi veidot visas manas apmācības, izmantojot Arduino IDE un īstu Arduino!

Šajā apmācībā mēs uzzināsim par pogām! Mums jāzina:

• Kā tos savienot
• Lasot to vērtību
• Debounce un kāpēc tas ir svarīgi
• Praktisks pielietojums (izvēlnes izveide)

Lielākā daļa cilvēku domā, ka vispraktiskākā lieta, ko darīt ar pogu, ir gaismas ieslēgšana un izslēgšana. Mēs, nevis šeit! Mēs izmantosim savu, lai izveidotu izvēlni un iestatītu dažas iespējas Arduino.

Gatavs? Sāksim!

1. darbība: uzstādiet paneli

Pirmais solis ir ievietot Arduino un Breadboard Small prototipu veidošanas zonā. Pārbaudiet iepriekš redzamos attēlus, lai uzzinātu, kā pieslēgt strāvas sliedes.

Breadboard Mini ir divas jaudas sliedes augšpusē un apakšā. Mēs savienojam tos ar Arduino, lai mēs varētu nodrošināt jaudu vairākām sastāvdaļām. Vēlāk šajā apmācībā mēs izmantosim 3 pogas, tāpēc mums būs nepieciešama lielāka jauda. Jāatzīmē, ka uz mazas maizes dēļa jaudas sliedes iet horizontāli. Tas atšķiras no kolonnām galvenajā prototipēšanas zonā vidū; tie darbojas vertikāli. Jūs varat izmantot jebkuru no strāvas tapām, lai nodrošinātu barošanu jebkurai kolonnai galvenajā zonā vidū.

Pievienojot jaudu, izmantojiet melnos un sarkanos vadus attiecīgi negatīvajam un pozitīvajam. Beigās pievienojiet vadus, kas nodrošina strāvu, otrai dēļa pusei. Mēs neizmantosim šo pusi, bet tā ir laba prakse.

2. darbība: pievienojiet pogu un rezistoru

Pievienojiet nelielu spiedpogu no komponentu teknes. Tam vajadzētu izskatīties kā attēlā redzamajam. Pārliecinieties, ka tas nav slēdzis! Pievienojiet arī rezistoru. Noklikšķiniet uz tā un iestatiet tā vērtību uz 10 kΩ. Tas ir pietiekami, lai piespraustu tapu zemu, kad tā nav pievienota, kas ir ļoti svarīgi vēlāk kodā.

Novietojiet komponentu maizes dēļa vidū. Poga darbojas šādi:

• No stūra līdz stūrim poga nav pievienota. Nospiežot pogu, tiek aizvērti kontakti un savienoti stūri.
• Pogas malas ir savienotas. Ja pievienojat vadu augšējā kreisajā un apakšējā kreisajā stūrī, ķēde tiks slēgta.

Šī iemesla dēļ mēs ievietojam komponentu pa vidu. Tas nodrošina, ka stūri nav savienoti zem dēļa tapām.

Nākamais solis sniedz pāris attēlus, kas ilustrē šos punktus.

Novietojiet rezistoru no apakšējās labās tapas pāri kolonnām, lai tas būtu horizontāli.

3. solis: pogu savienojumi

Iepriekš redzamie attēli skaidri parāda, kā pogas savienojas. Tas vienmēr bija apjukuma punkts, kad jūs domājat, ka kaut kas ir labi un tas nedarbojas!

Tagad pievienosim vadus.

• Novietojiet sarkanu vadu no pozitīvas strāvas tapas tajā pašā kolonnā, kas atrodas pogas labajā apakšējā tapā
• Novietojiet melnu vadu no negatīvās strāvas tapas tajā pašā kolonnā kā rezistors.
• Novietojiet krāsainu vadu (nevis sarkanu/melnu) no augšējās kreisās tapas līdz Arduino digitālajai tapai 2

Pārbaudiet iepriekš redzamos attēlus, lai pārliecinātos, ka vadi ir pareizi.

4. darbība: kods…

Apskatīsim pamata pogas kodu.

Atveriet koda redaktoru un mainiet no Bloki uz Teksts. Notīriet parādīto brīdinājumu. Mēs esam apmierināti ar tekstu!

Jūs zināt pamata iestatījumus, tāpēc definēsim pogu un veiksim pamata lasīšanu. Mēs izdrukāsim izvadi uz sēriju.

Es ievietoju dažus papildu komentārus zemāk esošajā kodā, lai to būtu vieglāk lasīt nekā attēlu.

// Definēt konstantes

#define button 2 void setup () {pinMode (poga, INPUT); Sērijas sākums (9600); } void loop () {// Lasiet digitālo tapu, lai pārbaudītu pogas statusu int nospiests = digitalRead (poga); // Poga atgriež HIGH, ja tiek nospiesta, LOW, ja nē, ja (nospiests == HIGH) {Serial.println ("Nospiests!"); }}

Labi, tas darbojas!

Būtībā viss, ko mēs darām, ir pārbaudīt digitālās tapas statusu katru reizi, kad koda cilpas. Noklikšķinot uz Sākt simulāciju un nospiežot pogu, jūs redzēsit sērijas monitora (noklikšķiniet uz pogas zem koda) displeju "Nospiests!" atkārtoti.

Viena iezīme, ko redzēsit iepriekš minētajā kodā, ir nosacījuma if () novērtēšana. Viss, ko kods dara, ir uzdot jautājumu un novērtēt, vai tas šajā gadījumā ir taisnība. Mēs izmantojam vienādības (dubultās vienādības zīmes, piemēram: ==), lai pārbaudītu, vai mainīgā vērtība ir vienāda ar noteiktu vērtību. DigitalRead () atgriež HIGH vai LOW.

Izmantojot if () else if / else, mēs varam pārbaudīt daudzus nosacījumus vai visus nosacījumus, un, atgriežoties pie Arduino pamatiem, jūs redzēsit dažus salīdzinājumus, ko varat veikt.

Tagad … Mūsu kods var izskatīties pilnīgs … Bet mums ir problēma.

Redziet, tas tiešām darbojas simulatorā. Bet īstā elektrībā ir troksnis, it īpaši līdzstrāvas elektronika. Tāpēc mūsu poga dažreiz var atgriezt nepatiesu rādījumu. Un tā ir problēma, jo jūsu projekts, iespējams, neatbildēs lietotājam pareizi.

Labosim!

5. solis: neliela atkāpšanās

Mēs izmantojam procedūru, ko sauc par debounce, lai pārvarētu mūsu pogu problēmu. Tas būtībā gaida noteiktu laiku starp pogas nospiešanu un reālu reaģēšanu uz spiedienu. Lietotājam tas joprojām šķiet dabiski (ja vien nepadara laiku pārāk garu). Varat arī to izmantot, lai pārbaudītu preses ilgumu, lai katru reizi varētu reaģēt atšķirīgi. Jums nav jāmaina vadi!

Apskatīsim kodu:

#definēt pogu 2#define debounceTimeout 100

Pirmās izmaiņas attiecas uz globālo jomu. Jūs atcerēsities, ka šeit mēs definējam mainīgos, ko var izmantot daudzas mūsu funkcijas, vai tos, kurus nevar atiestatīt katru reizi, kad tiek aktivizēta cilpa. Tātad definētajām konstantēm mēs pievienojām debounceTimeout. Mēs izveidojām šo 100 (kas vēlāk tiks tulkots līdz 100 ms), bet tas varētu būt īsāks. Ilgāk, un tas jutīsies nedabiski.

long int lastDebounceTime;

Šis mainīgais ir deklarēts zem konstantēm. Tas ir garš int tips, kas būtībā ļauj mums saglabāt garus skaitļus atmiņā. Mēs to saucām par lastDebounceTime.

Funkcijā void setup () mums nekas nav jāmaina. Atstāsim to vienu.

void loop () {// Lasiet digitālo tapu, lai pārbaudītu pogas statusu int nospiests = digitalRead (poga); garš int pašreizējais laiks = milis (); // Pogas kods}

Pirmās izmaiņas, ko mēs veicam cilpas () funkcijā, ir zem aicinājuma lasīt pogu. Mums ir jāseko pašreizējam laikam. Funkcija millis () atgriež pulksteņa pašreizējo laiku kopš Arduino palaišanas milisekundēs. Mums tas jāsaglabā garā int tipa mainīgajā.

Tagad mums jāpārliecinās, ka esam informēti par laiku, kopš poga tika nospiesta, tāpēc mēs atiestatām taimeri, kad tas nav nospiests. Paskaties:

void loop () {// Lasiet digitālo tapu, lai pārbaudītu pogas statusu int nospiests = digitalRead (poga); garš int pašreizējais laiks = milis (); if (nospiests == LOW) {// Atiestatīt skaitīšanas laiku, kamēr poga nav nospiesta lastDebounceTime = currentTime; } // Pogas kods}

Ja (nospiests == LOW) algoritms pārbauda, vai poga nav nospiesta. Ja tā nav, kods saglabā pašreizējo laiku kopš pēdējās atvienošanas. Tādā veidā katru reizi, nospiežot pogu, mums ir noteikts laiks, no kura mēs varam pārbaudīt, kad poga tika nospiesta. Pēc tam mēs varam veikt ātru matemātisku aprēķinu, lai redzētu, cik ilgi poga tika nospiesta, un pareizi reaģēt. Apskatīsim pārējo kodu:

void loop () {// Lasiet digitālo tapu, lai pārbaudītu pogas statusu int nospiests = digitalRead (poga); garš int pašreizējais laiks = milis (); if (nospiests == LOW) {// Atiestatīt skaitīšanas laiku, kamēr poga nav nospiesta lastDebounceTime = currentTime; } // Poga uz noteiktu laiku ir nospiesta, ja ((((currentTime - lastDebounceTime)> debounceTimeout)) {// Ja taimauts ir sasniegts, poga ir nospiesta! Serial.println ("Nospiests!"); }}

Pēdējais koda bloks ņem pašreizējo laiku, atņem pēdējo atkāpšanās laiku un salīdzina to ar mūsu iestatīto taimautu. Ja tas ir lielāks, kods pieņem, ka poga ir tikusi nospiesta šajā laikā, un reaģē. Kārtīgi!

Palaidiet savu kodu un pārbaudiet, vai tas darbojas. Ja jums ir kļūdas, pārbaudiet savu kodu!

Tagad apskatīsim praktisku piemēru.

6. darbība. Izvēlnes izveide

Pogas ir interesantas, jo ar tām ir tik daudz iespēju! Šajā piemērā mēs izveidosim izvēlni. Pieņemsim, ka esat izveidojis šo patiešām lielisko ierīci un jums ir nepieciešams, lai lietotāji varētu mainīt opcijas, lai ieslēgtu vai izslēgtu noteiktas lietas, vai iestatīt noteiktu iestatījuma vērtību. Šis trīs pogu dizains to var izdarīt!

Tātad, šim projektam mums ir nepieciešams:

• Trīs pogas
• Trīs rezistori ir iestatīti uz 10 kΩ

Mums jau ir viens no šiem, mums vajag tikai pārējos divus. Tāpēc pievienojiet tos tāfelei. Elektroinstalācija ir nedaudz sarežģītāka, bet tikai tāpēc, ka es gribēju to saglabāt patiešām kompaktu. Jūs varētu ievērot to pašu modeli pirmajai pogai vai sekot iepriekš redzamajam attēlam.

Trīs pogas ir izvēlnes atvēršanas/nākamā opcija, mainīšanas opcija (tāpat kā, mainīt iestatījumu) un izvēlnes saglabāšanas/aizvēršanas poga.

Pieslēdziet vadu, apskatīsim kodu!

7. solis: koda sadalījums - globāls

Labi, tas būs garš solis, bet es eju cauri katrai koda sadaļai.

Vispirms apskatīsim nepieciešamos globālos mainīgos.

// Definēt konstantes #define menuButton 2 #define menuSelect 3 #define menuSave 4 #define debounceTimeout 50 // Definēt mainīgos int menuButtonPreviousState = LOW; int menuSelectPreviousState = LOW; int menuSavePreviousState = LOW; long int lastDebounceTime; // Izvēlnes opcijas char * menuOptions = {"Check Temp", "Check Light"}; bool featureSetting = {nepatiess, nepatiess}; bool menuMode = false; bool menuNeedsPrint = false; int optionSelected = 0;

Šie trīs bloki ir diezgan līdzīgi tam, ko esam redzējuši iepriekš. Pirmajā es definēju trīs pogas un taimautu. Šajā projekta daļā es to esmu iestatījis uz 50 ms, tāpēc, lai tas darbotos, ir nepieciešama apzināta prese.

Otrais bloks ir visi mainīgie. Mums ir jāseko pogaiPreviousState, un jāseko pēdējamDebounceTime. Tie visi ir int tipa mainīgie, bet pēdējais ir garš tips, jo es pieņemu, ka mums ir nepieciešama vieta atmiņā.

Izvēlnes opciju blokam ir dažas jaunas funkcijas. Pirmkārt, simbols * (jā, tā ir apzināta zvaigznīte), kas ir rakstzīmju/virkņu burtisks mainīgais. Tas ir rādītājs uz statisku atmiņas krātuvi. Jūs to nevarat mainīt (piemēram, piemēram, Python). Šī char *menuOptions rinda izveido virkņu literālu masīvu. Jūs varat pievienot tik daudz izvēlnes vienumu, cik vēlaties.

Bool featureSetting mainīgais ir tikai vērtību masīvs, kas attēlo katru izvēlnes vienumu. Jā, jūs varat uzglabāt visu, kas jums patīk, vienkārši mainiet mainīgā veidu (tiem visiem jābūt vienādiem). Tagad varētu būt labāki veidi, kā to pārvaldīt, piemēram, vārdnīcas vai kopas, taču šai lietojumprogrammai tas ir vienkārši. Es, iespējams, izveidotu kādu no pēdējām izvietotā lietojumprogrammā.

Esmu sekojis menuMode, tāpēc, ja es gribētu, lai manā displejā būtu citas lietas, es to varētu izdarīt. Turklāt, ja man būtu sensora loģika, es varētu to apturēt izvēlnes darbības laikā, tikai gadījumā, ja kaut kas ir pretrunā. Man ir menuNeedsPrint mainīgais, jo vēlos drukāt izvēlni noteiktā laikā, nevis tikai visu laiku. Visbeidzot, man ir opcija Selected mainīgais, lai es varētu izsekot izvēlētajai opcijai, piekļūstot tai vairākās vietās.

Apskatīsim nākamo funkciju kopumu.

8. solis: koda sadalījums - iestatīšana un pielāgotas funkcijas

Iestatīšanas () funkcija ir pietiekami vienkārša, tikai trīs ievades deklarācijas:

void setup () {pinMode (menuSelect, INPUT); pinMode (menuSave, INPUT); pinMode (menuSelect, INPUT); Sērijas sākums (9600); }

Tālāk ir trīs pielāgotas funkcijas. Apskatīsim pirmos divus, tad pēdējo atsevišķi.

Mums ir vajadzīgas divas funkcijas, kas atgriež kādu informāciju. Iemesls ir tāds, ka mēs vēlamies pārliecināties, ka tas ir cilvēka lasāms. Tas arī palīdzēs koda atkļūdošanā, ja mums ir problēma. Kods:

// Funkcija, lai atgrieztu pašreiz atlasīto opcijuchar *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // Atgriešanās opcijaIzvēlētā atgriešanās izvēlneOption; } // Funkcija pašreizējās atlasītās opcijas statusa atgriešanai char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; if (optionSetting == false) {optionSettingVal = "Nepareizi"; } else {optionSettingVal = "Patiess"; } // Atgriešanās opcija Atgriešanās opcijas iestatīšanaSettingVal; }

Funkcija char *ReturnOptionSelected () pārbauda atlasīto opciju (ja redzat iepriekš, mēs iestatām mainīgo, lai to izsekotu), un izvelk virkņu literālu no masīva, kuru izveidojām iepriekš. Pēc tam tas atgriež to kā char veidu. Mēs to zinām, jo funkcija norāda atgriešanās veidu.

Otrā funkcija char *ReturnOptionStatus () nolasa masīvā saglabātās opcijas statusu un atgriež virknes literālu, kas attēlo vērtību. Piemēram, ja iestatījums, kuru mēs esam saglabājuši, ir nepatiess, es atgrieztu “False”. Tas ir tāpēc, ka mēs parādām lietotājam šo mainīgo, un labāk ir saglabāt visu šo loģiku kopā. Es to varētu izdarīt vēlāk, bet ir jēga to darīt šeit.

// Funkcija, lai pārslēgtu pašreizējo opciju lodziņu ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; atgriezties patiesi; }

Funkcija bool ToggleOptionSelected () ir ērtības funkcija, lai mainītu izvēlnē atlasītā iestatījuma vērtību. Tas tikai apgāž vērtību. Ja jums būtu sarežģītāks iespēju kopums, tas varētu būt pavisam citādi. Šajā funkcijā es atgriežos true, jo mans atzvanīšana (zvans vēlāk kodā, kas aktivizē šo funkciju) sagaida patiesu/nepatiesu atbildi. Esmu 100% pārliecināts, ka tas darbosies, tāpēc es neuzskatīju, ka tas nedarbojas, bet es to darītu izvietotā lietojumprogrammā (katram gadījumam).

9. darbība: cilpa…

Cilpas () funkcija ir diezgan gara, tāpēc mēs to darīsim pa daļām. Šajā funkcijā varat pieņemt visu zemāk esošo ligzdu:

void loop () {

// Strādājiet šeit <-----}

Labi, mēs redzējām šo lietu iepriekš:

// Lasīt pogas int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalRead (menuSelect); int menuSavePressed = digitalRead (menuSave); // Iegūt pašreizējo laiku ilgi int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// Atiestatīt skaitīšanas laiku, kamēr poga nav nospiesta lastDebounceTime = currentTime; menuButtonPreviousState = LOW; menuSelectPreviousState = LOW; menuSavePreviousState = LOW; }

Viss, kas man bija jādara, bija pievienot trīs digitalRead () zvanus un pārliecināties, ka es ņemu vērā to, ka, ja visas pogas ir zemas, mums vajadzētu atiestatīt taimeri (lastDebounceTime = currentTime) un iestatīt visus iepriekšējos stāvokļus uz zemu. Es arī glabāju milis () pašreizējā laikā.

Nākamā sadaļa ligzdo līnijas iekšpusē

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

// Strādājiet šeit <----}

Ir trīs sadaļas. Jā, es būtu varējis tos pārvietot uz savām funkcijām, bet vienkāršības labad es šeit paturēju trīs galvenos pogu algoritmus.

ja ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // Ļaujiet lietotājam zināt Serial.println ("Izvēlne ir aktīva"); } cits if (menuMode == true && optionSelected = 1) {// Atiestatīt opciju optionSelected = 0; } // Izdrukāt izvēlnes izvēlniNeedsPrint = true; // Pārslēgt pogu iepriekš. valsts, lai parādītu tikai izvēlni // ja poga tiek atlaista un vēlreiz nospiesta menuButtonPreviousState = menuButtonPressed; // Būtu HIGH}

Šis pirmais rīkojas, ja menuButtonPressed ir HIGH vai nospiežot izvēlnes pogu. Tas arī pārbauda, vai iepriekšējais stāvoklis bija LOW, lai poga būtu jāatlaiž pirms tās atkārtotas nospiešanas, kas neļauj programmai pastāvīgi aktivizēt to pašu notikumu atkal un atkal.

Pēc tam tā pārbauda, vai, ja izvēlne nav aktīva, tā to aktivizē. Tas izdrukās pirmo atlasīto opciju (kas ir izvēlnes opciju masīva pirmais vienums pēc noklusējuma. Ja nospiežat pogu otro vai trešo reizi (utt.), Jūs saņemsiet nākamo opciju sarakstā. Kaut ko es varētu labot ka, sasniedzot beigas, tas atgriežas sākumā. Tas varētu nolasīt masīva garumu un atvieglot riteņbraukšanu, ja mainītu opciju skaitu, taču pagaidām tas bija vienkārši.

Pēdējā mazā sadaļa (// izdrukā izvēlni) acīmredzami izdrukā izvēlni, taču tā arī iestata iepriekšējo stāvokli uz HIGH, lai tā pati funkcija neradītu cilpu (skatiet manu piezīmi iepriekš par to, vai poga iepriekš bija LOW).

// menuSelect ir nospiests, norādiet logicif ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// Mainīt atlasīto opciju // Šobrīd tas ir tikai true/false // bet varētu būt jebkas bool toggle = ToggleOptionSelected (); if (pārslēgt) {menuNeedsPrint = true; } else {Serial.println ("Radās problēma. Lūdzu, mēģiniet vēlreiz"); }} // Pārslēgt stāvokli, lai pārslēgtos tikai tad, ja tas tiek atlaists un vēlreiz nospiests menuSelectPreviousState = menuSelectPressed; }

Šis koda bits apstrādā izvēlniSelectPressed poga tādā pašā veidā, izņemot šoreiz mēs vienkārši aktivizējam funkciju ToggleOptionSelected (). Kā jau teicu iepriekš, jūs varētu mainīt šo funkciju, lai tā paveiktu vairāk, bet tas ir viss, kas man ir nepieciešams.

Galvenais, kas jāņem vērā, ir pārslēgšanas mainīgais, kas izseko atzvanīšanas panākumus un izdrukā izvēlni, ja tā ir patiesa. Ja tas neatgriež neko vai nepatiesu, tas izdrukā kļūdas ziņojumu. Šeit jūs varat izmantot savu atzvanīšanu, lai veiktu citas darbības.

if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// Iziet no izvēlnes // Šeit jūs varētu veikt jebkuru sakārtošanu // vai saglabāt EEPROM menuMode = false; Serial.println ("Iziešana no izvēlnes"); // Pārslēgt stāvokli, lai izvēlne izietu tikai vienreiz menuSavePreviousState = menuSavePressed; }}

Šī funkcija apstrādā izvēlnes saglabāšanas pogu, kas tikai iziet no izvēlnes. Šeit jūs varētu izvēlēties atcelšanas vai saglabāšanas iespēju, varbūt veikt tīrīšanu vai saglabāt EEPROM. Es vienkārši izdrukāju "Izvēlne izgāja" un iestatīju pogas stāvokli uz HIGH, lai tā nerīkotos.

if (menuMode && menuNeedsPrint) {// Mēs esam izdrukājuši izvēlni, tādēļ, ja vien kaut kas // nenotiek, nav nepieciešams to vēlreiz izdrukāt menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("Atlasīts:"); Serial.print (opcijaActive); Serial.print (":"); Serial.print (optionStatus); Sērijas.println (); }

Šis ir menuPrint algoritms, kas tiek aktivizēts tikai tad, ja izvēlne ir aktīva un ja menuNeedsPrint mainīgais ir iestatīts uz true.

Šo noteikti varētu pārcelt uz savu funkciju, bet vienkāršības labad..!

Nu tas tā! Visu koda bloku skatiet nākamajā darbībā.

10. solis: galīgais koda bloks

// Definēt konstantes

#define menuButton 2 #define menuSelect 3 #define menuSave 4 #define debounceTimeout 50 int menuButtonPreviousState = LOW; int menuSelectPreviousState = LOW; int menuSavePreviousState = LOW; // Definēt mainīgos ilgi int lastDebounceTime; bool lightSensor = taisnība; bool tempSensor = true; // Izvēlnes opcijas char * menuOptions = {"Check Temp", "Check Light"}; bool featureSetting = {nepatiess, nepatiess}; bool menuMode = false; bool menuNeedsPrint = false; int optionSelected = 0; // Iestatīšanas funkcija

void setup () {pinMode (menuSelect, INPUT); pinMode (menuSave, INPUT); pinMode (menuSelect, INPUT); Sērijas sākums (9600); }

// Funkcija, lai atgrieztu pašreiz izvēlēto opciju char *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // Atgriešanās opcijaIzvēlētā atgriešanās izvēlneOption; } // Funkcija pašreizējās atlasītās opcijas statusa atgriešanai char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; if (optionSetting == false) {optionSettingVal = "Nepareizi"; } else {optionSettingVal = "Patiess"; } // Atgriešanās opcija Atgriešanās opcijas iestatīšanaSettingVal; } // Funkcija, lai pārslēgtu pašreizējo opciju bool ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; atgriezties patiesi; } // Galvenā cilpa

void loop () {// Izlasiet pogas int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalRead (menuSelect); int menuSavePressed = digitalRead (menuSave); // Iegūt pašreizējo laiku ilgi int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// Atiestatīt skaitīšanas laiku, kamēr poga nav nospiesta lastDebounceTime = currentTime; menuButtonPreviousState = LOW; menuSelectPreviousState = LOW; menuSavePreviousState = LOW; } if ((((currentTime - lastDebounceTime)> debounceTimeout)) {// Ja taimauts ir sasniegts, poga nospiesta!

// izvēlne Poga ir nospiesta, nodrošiniet loģiku

// Tiek aktivizēts tikai tad, kad poga ir iepriekš atlaista, ja ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // Ļaujiet lietotājam zināt Serial.println ("Izvēlne ir aktīva"); } cits if (menuMode == true && optionSelected = 1) {// Atiestatīt opciju optionSelected = 0; } // Izdrukāt izvēlnes izvēlniNeedsPrint = true; // Pārslēgt pogu iepriekš. valsts, lai parādītu tikai izvēlni // ja poga tiek atlaista un vēlreiz nospiesta menuButtonPreviousState = menuButtonPressed; // Vai būtu HIGH} // menuSelect ir nospiests, nodrošiniet loģiku, ja ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// Mainīt atlasīto opciju // Šobrīd tas ir tikai true/false // bet varētu būt jebkas bool toggle = ToggleOptionSelected (); if (pārslēgt) {menuNeedsPrint = true; } else {Serial.print ("Radās problēma. Lūdzu, mēģiniet vēlreiz"); }} // Pārslēgt stāvokli, lai pārslēgtos tikai tad, ja tas tiek atlaists un vēlreiz nospiests menuSelectPreviousState = menuSelectPressed; } if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// Iziet no izvēlnes // Šeit jūs varētu veikt jebkuru sakārtošanu // vai saglabāt EEPROM menuMode = false; Serial.println ("Iziešana no izvēlnes"); // Pārslēgt stāvokli, lai izvēlne izietu tikai vienreiz menuSavePreviousState = menuSavePressed; }} // Drukāt pašreizējo izvēlnes opciju aktīvu, bet izdrukāt to tikai vienu reizi, ja (menuMode && menuNeedsPrint) {// Mēs esam izdrukājuši izvēlni, tādēļ, ja vien kaut kas // nenotiek, nav nepieciešams to vēlreiz izdrukāt menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("Atlasīts:"); Serial.print (opcijaActive); Serial.print (":"); Serial.print (optionStatus); Sērijas.println (); }}}

Ķēde ir pieejama Tinkercad vietnē. Es esmu iegulusi zemāk esošo shēmu, lai jūs arī to varētu redzēt!

Kā vienmēr, ja jums ir jautājumi vai jautājumi, lūdzu, informējiet mani!