En meny i Arduino, og hvordan du bruker knappene: 10 trinn (med bilder)

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:23

I min Arduino 101 -opplæring blir du lært hvordan du konfigurerer miljøet ditt i Tinkercad. Jeg bruker Tinkercad fordi det er en ganske kraftig online plattform som lar meg demonstrere en rekke ferdigheter for studenter for å bygge kretser. Bygg gjerne alle mine opplæringsprogrammer ved hjelp av Arduino IDE og en ekte Arduino!

I denne opplæringen skal vi lære om knapper! Vi trenger å vite:

• Hvordan koble dem til
• Leser verdien deres
• Avvise, og hvorfor det er viktig
• En praktisk applikasjon (lage en meny)

De fleste synes det mest praktiske å gjøre med en knapp er å slå lyset på og av. Vi kommer, ikke her! Vi skal bruke vår til å lage en meny og sette noen alternativer på Arduino.

Klar? La oss komme i gang!

Trinn 1: Sett opp brettet

Det første trinnet er å sette en Arduino og Breadboard Small på prototypingområdet. Sjekk bildene ovenfor for å se hvordan du kobler til strømskinnene.

En Breadboard Mini har to kraftskinner øverst og nederst. Vi kobler disse opp til Arduino slik at vi kan levere strøm til flere komponenter. Senere i denne opplæringen bruker vi 3 knapper, så vi trenger mer strøm. Det som er verdt å merke seg er at på et lite brødbrett går strømskinnene tvers over brettet, horisontalt. Dette er forskjellig fra kolonnene i hovedprototypingområdet i midten; disse går vertikalt. Du kan bruke hvilken som helst av strømpinnene for å gi strøm til en hvilken som helst kolonne i hovedområdet i midten.

Når du legger til strøm, bruker du svarte og røde ledninger til henholdsvis det negative og det positive. Legg til ledninger på enden som driver strøm til den andre siden av brettet. Vi vil ikke bruke den siden, men det er god praksis.

Trinn 2: Legg til knappen og motstanden

Legg til en liten trykknapp fra komponentbrettet. Det skal se ut som det på bildet. Sørg for at det ikke er en bryter! Legg til en motstand også. Klikk på den, og sett verdien til 10kΩ. Det er nok til å trekke pinnen lavt når den ikke er tilkoblet, noe som er veldig viktig senere i koden.

Plasser komponenten på midten av brødbrettet. Måten en knapp fungerer på er:

• Hjørne til hjørne, knappen er ikke tilkoblet. Trykk på knappen for å lukke kontaktene og koble hjørnene.
• Sidene på knappen er koblet til. Hvis du koblet en ledning øverst til venstre og nederst til venstre, ville kretsen være stengt.

Det er derfor vi setter komponenten på tvers av rommet i midten. Det sørger for at hjørnene ikke er koblet under pinnene i brettet.

Det neste trinnet gir et par bilder som illustrerer disse punktene.

Plasser motstanden fra nederste høyre pinne over kolonner, slik at den sitter horisontalt.

Trinn 3: Knappeforbindelser

Bildene ovenfor gjør det ganske tydelig hvordan knappene kobles til. Det var alltid et forvirringspunkt når du tror at noe er bra og at det ikke fungerer!

La oss legge til ledningene.

• Plasser en rød ledning fra en positiv strømpinne til samme kolonne som den nederste høyre pinnen på knappen
• Plasser en svart ledning fra en negativ strømnål til samme kolonne som motstanden.
• Plasser en farget ledning (ikke rød/svart) fra den øverste venstre pinnen til Digital Pin 2 på Arduino

Sjekk bildene ovenfor for å kontrollere at ledningene er riktige.

Trinn 4: Koden …

La oss se på koden for en grunnleggende knapp.

Åpne kodeditoren og endre fra Blokker til Tekst. Fjern advarselen som kommer. Vi er fornøyd med tekst!

Du kjenner det grunnleggende oppsettet, så la oss definere knappen og gjøre en grunnleggende lesning. Vi skriver ut utgangen til Serial.

Jeg la inn noen ekstra kommentarer i koden nedenfor, så det er lettere å lese enn bildet.

// Definer konstanter

#define button 2 void setup () {pinMode (button, INPUT); Serial.begin (9600); } void loop () {// Les den digitale pinnen for å sjekke status for knappen int presset = digitalRead (knapp); // Knappen returnerer HØY hvis den trykkes, LAV hvis ikke hvis (trykkes == HØY) {Serial.println ("Presset!"); }}

Ok, det fungerer!

I hovedsak er alt vi gjør å sjekke statusen til den digitale pinnen hver gang koden sløyfer. Hvis du klikker på Start simulering og trykker på knappen, ser du Serial Monitor (klikk på knappen under koden) "Presset!" gjentatte ganger.

En funksjon du ser i koden ovenfor er evalueringen av tilstanden if (). Alt koden gjør er å stille et spørsmål og vurdere om det er sant, i dette tilfellet. Vi bruker er lik (dobbel likhetstegn, slik: ==) for å sjekke om verdien til variabelen er lik en viss verdi. En digitalRead () returnerer enten HIGH eller LOW.

Ved å bruke if () else if / else kan vi sjekke mange forhold eller alle forhold, og hvis du går tilbake til Arduino Basics, ser du noen av sammenligningene du kan gjøre.

Nå … Koden vår kan se fullstendig ut … Men vi har et problem.

Se, det fungerer veldig bra når du er i simulatoren. Men ekte elektrisitet har støy, spesielt likestrømselektronikk. Så vår knapp kan noen ganger returnere en falsk lesning. Og det er et problem, fordi prosjektet ditt kanskje ikke svarer på riktig måte for brukeren.

La oss fikse det!

Trinn 5: En liten debounce

Vi bruker en prosedyre som kalles debounce for å overvinne knappproblemet vårt. Dette venter i hovedsak en bestemt tid mellom når knappen ble trykket og faktisk reagerer på presset. Det føles fortsatt naturlig for brukeren (med mindre du gjør tiden for lang). Du kan også bruke den til å kontrollere trykklengden, slik at du kan svare annerledes hver gang. Du trenger ikke å bytte ledninger!

La oss se på koden:

#definere knapp 2#definere debounceTimeout 100

Den første endringen er på det globale omfanget. Du vil huske at det er der vi definerer variabler som mange av funksjonene våre kan bruke, eller de som ikke kan nullstilles hver gang sløyfen utløses. Så vi la til debounceTimeout til de definerte konstantene. Vi lagde denne 100 (som senere vil oversettes til 100 ms), men den kan være kortere. Noe lenger, og det vil føles unaturlig.

long int lastDebounceTime;

Denne variabelen er deklarert under konstantene. Dette er en lang int -type, som i utgangspunktet lar oss lagre lange tall i minnet. Vi kalte det lastDebounceTime.

Vi trenger ikke å endre noe i funksjonen for oppsett av tomrom (). La oss la den ligge.

void loop () {// Les den digitale pinnen for å sjekke status for knappen int presset = digitalRead (knapp); lang int currentTime = millis (); // Knappkode}

Den første endringen vi gjør i loop () -funksjonen er under oppfordringen om å lese knappen. Vi må holde styr på den nåværende tiden. Millis () -funksjonen returnerer gjeldende tid på klokken siden Arduino startet opp i millisekunder. Vi må lagre dette i en lang variabel av typen int.

Nå må vi sørge for at vi er klar over tiden siden knappen ble trykket, så vi tilbakestiller timeren når den ikke trykkes. Ta en titt:

void loop () {// Les den digitale pinnen for å sjekke status for knappen int presset = digitalRead (knapp); lang int currentTime = millis (); if (presset == LOW) {// Tilbakestill telletiden mens knappen ikke trykkes lastDebounceTime = currentTime; } // Knappkode}

If (presset == LOW) algoritmen sjekker om knappen ikke trykkes. Hvis det ikke er det, lagrer koden gjeldende tid siden forrige debounce. På den måten har vi hver gang du trykker på knappen et tidspunkt hvor vi kan kontrollere når knappen ble trykket. Vi kan deretter gjøre en rask matematisk beregning for å se hvor lenge knappen ble trykket på, og svare riktig. La oss se på resten av koden:

void loop () {// Les den digitale pinnen for å sjekke status for knappen int presset = digitalRead (knapp); lang int currentTime = millis (); if (presset == LOW) {// Tilbakestill telletiden mens knappen ikke trykkes lastDebounceTime = currentTime; } // Knappen har blitt trykket på en gitt tid hvis (((currentTime - lastDebounceTime)> debounceTimeout)) {// Hvis tidsavbruddet er nådd, trykkes knappen! Serial.println ("Presset!"); }}

Den siste blokkblokken tar den nåværende tiden, trekker fra den siste avvisningstiden og sammenligner den med tidsavbruddet vi satte. Hvis den er større, antar koden at knappen har blitt trykket på den gangen og svarer. Ryddig!

Kjør koden din og sjekk at den fungerer. Hvis du har feil, sjekk koden din!

La oss nå se på et praktisk eksempel.

Trinn 6: Lage en meny

Knapper er interessante, fordi det er så mange muligheter med dem! I dette eksemplet skal vi lage en meny. La oss si at du har opprettet denne virkelig flotte enheten, og at brukerne må kunne endre alternativer for å slå bestemte ting på eller av, eller angi en bestemt verdi for en innstilling. Denne treknappsdesignen kan gjøre det!

Så for dette prosjektet trenger vi:

• Tre knapper
• Tre motstander satt til 10kΩ

Vi har allerede en av disse, vi trenger bare de to andre. Så legg dem til på tavlen. Kabling er litt mer komplisert, men bare fordi jeg ønsket å beholde det veldig kompakt. Du kan følge samme mønster for den første knappen, eller følge bildet ovenfor.

De tre knappene er et menyåpent/neste alternativ, et alternativ for endring (som i, endre innstillingen) og en lagre/lukk menyknapp.

Koble det til, la oss se på koden!

Trinn 7: Kodebrudd - globalt

Ok, dette kommer til å bli et langt skritt, men jeg skal gå gjennom hver del av koden.

La oss først se på de globale variablene som trengs.

// Definer konstanter #definere menuButton 2 #define menuVelg 3 #definere menuSave 4 #define debounceTimeout 50 // Definer variabler int menuButtonPreviousState = LOW; int menuSelectPreviousState = LAV; int menuSavePreviousState = LAV; long int lastDebounceTime; // Menyalternativer char * menuOptions = {"Check Temp", "Check Light"}; bool featureSetting = {false, false}; bool menuMode = false; bool menuNeedsPrint = false; int optionSelected = 0;

Disse tre blokkene er ganske like det vi har sett før. I den første har jeg definert de tre knappene og tidsavbruddet. For denne delen av prosjektet har jeg satt det til 50 ms, så det tar en bevisst press for å få det til å fungere.

Den andre blokken er alle variablene. Vi må holde oversikt over knappenPreviousState, og vi må holde styr på sisteDebounceTime. Dette er alle variabler av typen int, men den siste er en lang type fordi jeg antar at vi trenger plass i minnet.

Menyalternativblokken har noen få nye funksjoner. Først røyen * (ja, det er en bevisst stjerne), som er en bokstavlig/streng -variabel. Det er en pekepinn til en statisk lagring i minnet. Du kan ikke endre det (slik du kan for eksempel i Python). Denne char *menuOptions -linjen oppretter en rekke strenglitteraler. Du kan legge til så mange menyelementer du vil.

Bool featureSetting -variabelen er bare en rekke verdier som representerer hvert menyelement. Ja, du kan lagre alt du liker, bare endre variabeltypen (alle må være av samme type). Nå kan det være bedre måter å håndtere dette på, som ordbøker eller tupler, men dette er enkelt for denne applikasjonen. Jeg vil sannsynligvis lage en av sistnevnte i en distribuert applikasjon.

Jeg har holdt styr på menuMode, så hvis jeg ville ha andre ting på skjermen min, kunne jeg gjøre det. Også, hvis jeg hadde sensorlogikk, kan jeg stoppe det under menyoperasjon, bare hvis noe skulle komme i konflikt. Jeg har en menuNeedsPrint -variabel fordi jeg vil skrive ut menyen på bestemte tidspunkter, ikke bare hele tiden. Til slutt har jeg en optionSelected variabel, slik at jeg kan holde oversikt over det valgte alternativet når jeg får tilgang til det på en rekke steder.

La oss se på det neste settet med funksjoner.

Trinn 8: Kodebrudd - Oppsett og tilpassede funksjoner

Oppsett () -funksjonen er enkel nok, bare tre inngangserklæringer:

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

Neste er de tre egendefinerte funksjonene. La oss se på de to første, deretter den siste separat.

Vi trenger to funksjoner som gir litt informasjon. Årsaken er at vi vil sørge for at dette er slags lesbart for mennesker. Det vil også hjelpe med feilsøking av koden hvis vi har et problem. Kode:

// Funksjon for å returnere gjeldende valgt alternativ *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // Returalternativ Valgt returmeny Valg; } // Funksjon for å returnere status for gjeldende valgt alternativ char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; hvis (optionSetting == false) {optionSettingVal = "False"; } else {optionSettingVal = "True"; } // Return optionSetting return optionSettingVal; }

Char *ReturnOptionSelected () -funksjonen sjekker alternativet som er valgt (hvis du ser ovenfor, setter vi en variabel for å holde styr på det), og trekker strengen bokstavelig fra matrisen vi opprettet tidligere. Den returnerer den deretter som en røyetype. Vi vet dette fordi funksjonen angir returtypen.

Den andre funksjonen, char *ReturnOptionStatus () leser statusen til alternativet som er lagret i matrisen og returnerer en streng som betyr verdien. For eksempel, hvis innstillingen vi har lagret er feil, vil jeg returnere "Falsk". Dette er fordi vi viser brukeren denne variabelen, og det er bedre å holde all denne logikken sammen. Jeg kunne gjøre det senere, men det er mer fornuftig å gjøre det her.

// Funksjon for å veksle nåværende optionbool ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; returner sant; }

Funksjonen bool ToggleOptionSelected () er en bekvemmelighetsfunksjon for å endre verdien til innstillingen vi har valgt i menyen. Det bare vender verdien. Hvis du hadde et mer komplekst sett med alternativer, kan dette være ganske annerledes. Jeg returnerer true i denne funksjonen, fordi min tilbakeringing (samtalen senere i koden som utløser denne funksjonen) forventer et sant/usant svar. Jeg er 100% sikker på at dette vil fungere, så jeg regnet ikke med at det ikke fungerte, men jeg ville gjort det i en distribuert applikasjon (for sikkerhets skyld).

Trinn 9: Loop …

Loop () -funksjonen er ganske lang, så vi gjør det i deler. Du kan anta alt nedenfor reir i denne funksjonen:

void loop () {

// Arbeid her <-----}

Ok, vi så dette før:

// Les knappene int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalRead (menuSelect); int menuSavePressed = digitalRead (menuSave); // Få gjeldende tid lang int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// Tilbakestill telletiden mens knappen ikke trykkes lastDebounceTime = currentTime; menuButtonPreviousState = LAV; menuSelectPreviousState = LAV; menuSavePreviousState = LAV; }

Alt jeg måtte gjøre her var å legge til de tre digitalRead () -samtalene, og sørge for at jeg redegjorde for at hvis alle knappene var lave, skulle vi tilbakestille timeren (lastDebounceTime = currentTime) og sette alle tidligere tilstander til lav. Jeg lagrer også millis () i currentTime.

Den neste delen hekker inne i linjen

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

// Arbeid her <----}

Det er tre seksjoner. Ja, jeg kunne ha flyttet dem til sine egne funksjoner, men for enkelhets skyld beholdt jeg de tre hovedknappalgoritmene her inne.

if ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // Gi brukeren beskjed om Serial.println ("Menyen er aktiv"); } annet hvis (menuMode == true && optionSelected = 1) {// Tilbakestill option optionSelected = 0; } // Skriv ut menyen menuNeedsPrint = true; // Veksle knappen forrige. oppgi å bare vise meny // hvis knappen slippes og trykkes igjen menuButtonPreviousState = menuButtonPressed; // Ville være HØY}

Denne første håndteres når menuButtonPressed er HIGH, eller når du trykker på menyknappen. Den kontrollerer også at den forrige tilstanden var LAV, slik at knappen måtte slippes før den ble trykket på igjen, noe som forhindrer at programmet stadig avfyrer den samme hendelsen om og om igjen.

Den kontrollerer deretter at hvis menyen ikke er aktiv, aktiveres den. Det vil skrive ut det første alternativet som er valgt (som er det første elementet i menyen Valg -array som standard. Hvis du trykker på knappen en eller annen gang (osv.), Får du det neste alternativet i listen. Noe jeg kan fikse er at når det kommer til slutten, går det tilbake til begynnelsen. Dette kan lese lengden på matrisen og gjøre det lettere å sykle tilbake hvis du endret antall alternativer, men dette var enkelt for nå.

Den siste lille delen (// Skriver ut menyen) skriver tydeligvis ut menyen, men den setter også den forrige tilstanden til HØY, slik at den samme funksjonen ikke går i loop (se notatet mitt ovenfor om å kontrollere om knappen tidligere var LAV).

// menuSelect er trykket, gi logicif ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// Endre det valgte alternativet // For øyeblikket er dette bare sant/usant // men kan være alt bool toggle = ToggleOptionSelected (); hvis (veksle) {menuNeedsPrint = true; } else {Serial.println ("Noe gikk galt. Prøv igjen"); }}} // Bytt tilstand for å bare bytte hvis den slippes og trykkes på nytt menuSelectPreviousState = menuSelectPressed; }

Denne koden behandler menuSelectPressed -knappen på samme måte, bortsett fra at denne gangen bare skyter vi ToggleOptionSelected () -funksjonen. Som jeg sa før, kan du endre denne funksjonen så den gjør mer, men det er alt jeg trenger for å gjøre det.

Det viktigste å merke seg er vekselvariabelen, som sporer suksessen til tilbakeringingen og skriver ut menyen hvis den er sann. Hvis det ikke returnerer noe eller usant, vil det skrive ut feilmeldingen. Det er her du kan bruke tilbakeringingen til å gjøre andre ting.

if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// Gå ut av menyen // Her kan du gjøre opprydning // eller lagre i EEPROM menuMode = false; Serial.println ("Meny avsluttet"); // Bytt tilstand slik at menyen bare går ut menySavePreviousState = menuSavePressed; }}

Denne funksjonen håndterer menyen Lagre -knappen, som nettopp går ut av menyen. Det er her du kan ha et alternativ for avbestilling eller lagring, kanskje du kan rydde opp eller lagre i EEPROM. Jeg skriver bare ut "Meny avsluttet" og setter knappestatus til HØY, så den ikke går i sløyfe.

if (menuMode && menuNeedsPrint) {// Vi har skrevet ut menyen, så med mindre det skjer noe // trenger du ikke å skrive den ut igjen menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("Utvalgt:"); Serial.print (optionActive); Serial.print (":"); Serial.print (optionStatus); Serial.println (); }

Dette er menuPrint -algoritmen, som bare utløses når menyen er aktiv og når varianten menuNeedsPrint er satt til true.

Dette kan definitivt flyttes til sin egen funksjon, men for enkelhetens skyld..!

Vel, det er det! Se neste trinn for hele kodeblokken.

Trinn 10: Endelig kodeblokk

// Definer konstanter

#define menuButton 2 #define menuVelg 3 #define menuSave 4 #define debounceTimeout 50 int menuButtonPreviousState = LOW; int menuSelectPreviousState = LAV; int menuSavePreviousState = LAV; // Definer variabler long int lastDebounceTime; bool lightSensor = true; bool tempSensor = true; // Menyalternativer char * menuOptions = {"Check Temp", "Check Light"}; bool featureSetting = {false, false}; bool menuMode = false; bool menuNeedsPrint = false; int optionSelected = 0; // Oppsettfunksjon

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

// Funksjon for å returnere gjeldende valgt alternativ char *ReturnOptionSelected () {char *menuOption = menuOptions [optionSelected]; // Returalternativ Valgt returmeny Valg; } // Funksjon for å returnere status for gjeldende valgt alternativ char *ReturnOptionStatus () {bool optionSetting = featureSetting [optionSelected]; char *optionSettingVal; hvis (optionSetting == false) {optionSettingVal = "False"; } else {optionSettingVal = "True"; } // Return optionSetting return optionSettingVal; } // Funksjon for å veksle nåværende alternativ bool ToggleOptionSelected () {featureSetting [optionSelected] =! FeatureSetting [optionSelected]; returner sant; } // Hovedløkken

void loop () {// Les knappene int menuButtonPressed = digitalRead (menuButton); int menuSelectPressed = digitalRead (menuSelect); int menuSavePressed = digitalRead (menuSave); // Få gjeldende tid lang int currentTime = millis (); if (menuButtonPressed == LOW && menuSelectPressed == LOW && menuSavePressed == LOW) {// Tilbakestill telletiden mens knappen ikke trykkes lastDebounceTime = currentTime; menuButtonPreviousState = LAV; menuSelectPreviousState = LAV; menuSavePreviousState = LAV; } if (((currentTime - lastDebounceTime)> debounceTimeout)) {// Hvis tidsavbruddet er nådd, trykkes på knappen!

// menyknappen er trykket, gi logikk

// Avfyres bare når knappen tidligere er sluppet hvis ((menuButtonPressed == HIGH) && (menuButtonPreviousState == LOW)) {if (menuMode == false) {menuMode = true; // Gi brukeren beskjed om Serial.println ("Menyen er aktiv"); } annet hvis (menuMode == true && optionSelected = 1) {// Tilbakestill option optionSelected = 0; } // Skriv ut menyen menuNeedsPrint = true; // Veksle knappen forrige. oppgi å bare vise meny // hvis knappen slippes og trykkes igjen menuButtonPreviousState = menuButtonPressed; // Ville være HØY} // menuSelect er trykket, gi logikk hvis ((menuSelectPressed == HIGH) && (menuSelectPreviousState == LOW)) {if (menuMode) {// Endre det valgte alternativet // For øyeblikket er dette bare sant/usant // men kan være noe bool toggle = ToggleOptionSelected (); hvis (veksle) {menuNeedsPrint = true; } else {Serial.print ("Noe gikk galt. Prøv igjen"); }}} // Bytt tilstand for å bare bytte hvis den slippes og trykkes på nytt menuSelectPreviousState = menuSelectPressed; } if ((menuSavePressed == HIGH) && (menuSavePreviousState == LOW)) {// Gå ut av menyen // Her kan du gjøre opprydning // eller lagre i EEPROM menuMode = false; Serial.println ("Meny avsluttet"); // Bytt tilstand slik at menyen bare går ut menySavePreviousState = menuSavePressed; }} // Skriv ut det gjeldende menyalternativet aktivt, men bare skriv det ut én gang hvis (menuMode && menuNeedsPrint) {// Vi har skrevet ut menyen, så med mindre noe // skjer, er det ikke nødvendig å skrive det ut igjen menuNeedsPrint = false; char *optionActive = ReturnOptionSelected (); char *optionStatus = ReturnOptionStatus (); Serial.print ("Utvalgt:"); Serial.print (optionActive); Serial.print (":"); Serial.print (optionStatus); Serial.println (); }}}

Kretsen er tilgjengelig på Tinkercad -nettstedet. Jeg har innebygd kretsen nedenfor for at du også skal se!

Som alltid, vennligst gi meg beskjed hvis du har spørsmål eller problemer!