I denne opplæringen lærer vi hvordan du gjør grunnleggende Arduino-programmering gjennom eksempelkoder og eksempelprogrammer. Denne opplæringen kan være et ekstremt verdifullt kurs for alle nykommere som ønsker å forstå det grunnleggende gjennom et lett, forståelig språk.

Introduksjon

I følge wikipedia en mikrokontroller tilsvarer en mini-datamaskin innebygd i en enkelt IC-brikke, som har sin egen kjerneprosessor, programmerbare innganger, minne og periferiutstyr.

En mikrokontroller blir så nyttig for en bruker siden den tilbyr en innebygd prosessor, minne og inngangs- / utgangsporter (også kalt GPIO eller generelle inngangs- / utgangspinner) som vi kan styres av brukeren i henhold til ønsket spesifikasjon.

“hvilken elektrisk enhet som brukes til å konvertere spenningen til vekselstrømmen ”

I denne opplæringen vil vi jobbe med et Arduino Uno-bord for å lære og teste programmene. For å teste og integrere maskinvaresamling vil vi bruke et brødbrett.

La oss nå gå raskt og lære hvordan vi kommer i gang med en Arduino-programmering.

1.2 Installere programvaren (Windows)

For dette trenger du tilgang til internett, som du selvsagt vil ha på datamaskinen din. Gå til følgende lenke og last ned IDE-programvaren:

Windows ZIP-fil for ikke-installasjon

Etter nedlasting finner du Arduino-oppsettikonet i nedlastingsmappen, som ser slik ut:

Når du har fått dette, kan du bare dobbeltklikke på det og installere Arduino the Integrated Development Environment (IDE) på datamaskinen din. Hele prosessen kan visualiseres i følgende video:

https://youtu.be/x7AMn1paCeU

1.4 Starter med vår første krets

Før vi begynner å lære de faktiske programmeringsteknikkene, vil det for enhver nybegynner være nyttig å begynne med en grunnleggende komponent som en LED, og forstå hvordan du kobler den til en Arduino.

Som vi vet er en LED en lysdiode som har en polaritet og ikke vil lyse hvis den ikke er koblet til de riktige forsyningspolene.

Et annet aspekt ved lysdioder er at disse enhetene fungerer med lav strøm og kan bli skadet umiddelbart hvis en riktig beregnet motstand ikke er inkludert i serie med en av pinnene.

Som en tommelfingerregel er en 330 ohm 1/4 watt ganske ideell for hver 5V økning i forsyningsinngangen for å begrense strømmen til et nødvendig trygt nivå. Derfor for 5V kan det være 330 ohm, for 10V kan det være 680 ohm og så videre.

Bruke brødbrett til forsamlingen

Sørg for at du vet hvordan du bruker en brødbrett før du prøvde opplæringen som er forklart i dette kapittelet, siden vi bruker et brødbrett for alle eksperimentene her.

Det grunnleggende LED-tilkoblingsoppsettet kan sees nedenfor:

Du kan se 3 grunnleggende komponenter ovenfor:

En 5mm, 20mA LED
en 330 ohm 1/4 watt motstand
An Arduino Board

Bare monter systemet i henhold til diagrammet.

Deretter kobler du 5V fra datamaskinens USB til Arduino. Så snart du gjør dette, vil du se at LED-lampen lyser.

Jeg vet at det er ganske grunnleggende, men det er alltid bra å starte fra bunnen av. Vær trygg på at ting vil begynne å bli mer og mer interessante når vi går videre.

1.5 Kontrollerende LED med Arduino

Nå lærer vi hvordan du styrer en LED med et Arduino-program.

For å skrive et program må vi ha minst to funksjoner i hvert program.

En funksjon kan forstås som en serie programmeringsuttalelser som kan tilordnes et navn, som gitt nedenfor:

oppsett () dette kalles eller utføres under starten av programmet.
Løkke() dette kalles eller utføres gjentatt i løpet av hele Arduino-operasjonsperioden.

Derfor, selv om det kanskje ikke har noen praktisk funksjonalitet, kan teknisk sett et korteste legitime Arduino-program skrives som:

Enkleste program

void setup() { } void loop() { }

Du har kanskje lagt merke til at systemet i mange av programmeringsspråkene begynner med å vise en enkel utskrift, 'Hello, World' på skjermen

Den elektroniske ekvivalenten for dette uttrykket i tolkning av mikrokontroller er å blinke en LED på og av.

Dette er det mest grunnleggende programmet man kan skrive og implementere for å indikere at systemet fungerer korrekt.

Vi prøver å implementere og forstå prosedyren gjennom følgende kode:

Oppføring 1.2: led1 / led1.pde

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

OK, la oss nå forstå hva hver linje i koden betyr og hvordan det fungerer for å utføre funksjonen:

const int kPinLed = 13

Dette fungerer som en konstant som lar oss bruke den under hele programmeringskurset, uten at vi trenger å bruke den faktiske verdien som er satt mot den.

I henhold til standardreglene er slike konstanter gjenkjent med startbokstaven til . Selv om dette ikke er obligatorisk, gjør det ting tydeligere og lett forståelig når du har lyst til å gå gjennom kodedetaljene.

void setup() { pinMode(kPinLed, OUTPUT) }

Denne koden konfigurerer den spesifikke pinnen som LED-en vår er koblet til. Med andre ord, koden ber Arduino om å kontrollere 'skrive' -aspektet på denne pinnen, i stedet for å 'lese' den.

void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

Ovennevnte linjer angir den faktiske gjennomføringen av applikasjonen. Koden begynner med å skrive og gjengi en HIGH ut på den aktuelle LED-tilkoblingen, og slå LED på.

Her betyr begrepet HIGH ganske enkelt å få + 5V på den berørte pinnen på Arduino. Den kompletterende betegnelsen LAV indikerer ganske enkelt null eller 0V på den angitte pinnen.

Deretter kaller vi delay() hvis funksjon er å skape en forsinkelse gjennom millisekunder (1/1000 sekund). Siden tallet 500 er angitt, vil den implementerte forsinkelsen være i 1/2 sekund.

Så snart dette 1/2 sekundet er bortfalt, utføres neste linje som slår LED-lampen AV med LAV-termen på samme pinne.

Den påfølgende linjen genererer igjen 1/2 sekunders forsinkelse, slik at LED-lampen forblir AV i 1/2 sekunder.

Og prosessen fortsetter uendelig med utførelse av kodelinjene, så lenge Arduino holdes drevet.

Før du går videre til neste nivå, vil jeg anbefale deg å programmere koden ovenfor og kontrollere om du er i stand til å implementere LED ON / OF-sekvensen riktig eller ikke.

Siden standard-LED-en i Arduino er koblet til pin # 13, bør den umiddelbart svare på ovennevnte program og begynne å blinke. Men hvis du oppdager at den eksterne LED-en ikke blinker, kan det være en tilkoblingsfeil med LED-en, kan du prøve å snu polariteten til LED-en og forhåpentligvis også se at den blinker.

Du kan spille med forsinkelsestiden ved å endre '500' -figuren til en annen verdi og finne LED-en 'lytte' til kommandoene og få den til å blinke i henhold til de angitte forsinkelsesverdiene.

Men husk at hvis du ser at lysdioden ikke blinker med en konstant hastighet på 1 sekund, uavhengig av forsinkelsestidsendring, kan det indikere at koden ikke fungerer på grunn av en feil. Fordi Arduino som standard blir programmert med en blinkende hastighet på 1 sekund. Derfor må denne prisen varieres etter koden din for å bekrefte at den fungerer korrekt.

1.7 Kommentarer

Kodelinjene som vi forsto ovenfor, ble spesielt skrevet for programvaren.

For å sikre at brukeren er i stand til å henvise betydningen av linjene og forstå dem, kan det imidlertid ofte være nyttig og fornuftig å skrive forklaringen ved siden av de ønskede kodelinjene.

Disse kalles kommentarer som bare er skrevet for menneskelig eller brukerreferanse, og som er kodet for å gjøre det mulig for datamaskiner å ignorere det trygt.

Språket i disse kommentarene er skrevet i et par formater:

Blokkstilen for kommentaren, der kommentarbeskrivelsen er vedlagt under startsymbolet / * og avslutningssymbolet * /
Dette trenger ikke å begrense i en linje, men kan utvides til de neste påfølgende linjene, avhengig av lengden på kommentaren eller beskrivelsen, som vist i følgende eksempel:

/ * Dette er en kommentar * /

/ * Så er dette * /

/ * Og
* dette
* som
* vi vil */

For å skrive en hurtig beskrivelse av en enkelt linje for en kommentar, blir to skråstreker // symbol i starten tilstrekkelig. Dette forteller datamaskinen at denne linjen ikke har noe med den faktiske koden å gjøre, og at den må ignoreres. For eksempel:

// Dette er en kommentar som datamaskiner vil ignorere.

Her er et eksempel for referanse:

/* * Program Name: Blink * Author: Alan Smith * Description: * Turns an LED on for one half second, then off for one half second repeatedly. */

/* Pin Definitions */ const int kPinLed = 13 /* * Function Name: setup * Purpose: Run once when the system powers up. */ void setup() { pinMode(kPinLed, OUTPUT) } /* * Function name: loop * Purpose: Runs over and over again, as long as the Arduino has power */ void loop() { digitalWrite(kPinLed, HIGH) delay(500) digitalWrite(kPinLed, LOW) delay(500) }

1.8 Feilsøking

Hvis du finner at programmet ditt viser en 'feil' mens du kompilerer, eller et annet problem, vil følgende tips trolig hjelpe deg med å sjekke koden på nytt for å bli kvitt hinderet.

Programmets språk vil være skiftesensitivt. For eksempel uttrykket myVar kan ikke skrives som MyVar.
Alle slags hvite mellomrom som kan utføres av tastaturet ditt, blir til slutt gjengitt som et enkelt mellomrom, og det er kun synlig eller forstått av deg, datamaskinen tar ikke hensyn til dette. Enkelt sagt, ledige rom av noe slag vil ikke ha noen innvirkning på koderesultatene.
Hver blokk med kode må være vedlagt med venstre og høyre krøllete parentes, '{' og '}'
Tallsifre skal ikke skilles med komma. For eksempel kan 1000 ikke skrives som 1000.
Hver kodelinje som er lukket mellom krøllete parenteser, må avslutte med semikolon

Opprette interessant LED-lyssekvens med Arduino

I vårt forrige kapittel lærte vi å blinke en LED PÅ / AV kontinuerlig med en konstant forsinkelseshastighet.

Nå lærer vi hvordan forskjellige forsinkelsesmønstre kan utføres på samme LED ved å oppgradere programkoden.

Vi bruker ikke en ekstern LED, men bruker heller standard LED innebygd i Arduino-kortet på pin # 13. Du finner denne lille SMD-LED-en like bak USB-kontakten.

2.2 Forstå IF-uttalelser

I denne delen lærer vi hvordan kontrollstrukturer gjør det mulig for oss å kjøre individuelle koder, og en gang til og med repeterende, etter behov.

Uttalelsen hvis blir den første kontrollstrukturen. Følgende implementering viser hvordan den brukes:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { delayTime = delayTime - 100 if(delayTime <= 0){ // If the delay time is zero or less, reset it. delayTime = 1000 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

Vi vil prøve å forstå ovennevnte kode trinnvis og lære hvordan dette kan brukes til andre lignende henrettelser.

Kodene mellom 1. og 7. linje er nøyaktig lik vårt opprinnelige program.

Den første modifikasjonen skjer faktisk på 8. linje.

int delayTime = 1000

Du kan finne at dette ligner på koden på første linje, uten at det mangler begrepet konst.

Dette er ganske enkelt fordi denne koden ikke er en konstant. I stedet er dette definert som en variabel , som har egenskapen til en variabel verdi i løpet av programmeringen.

I eksemplet ovenfor kan du se at denne variabelen tilskrives verdien 1000. Husk at slike variabler som er lukket i krøllete parenteser, må skrives strengt innenfor par krøllete parenteser, og blir referert til som 'lokale' variabler.

Alternativt er variabler som skal være utenfor krøllete parenteser, som den vi diskuterer nå, anerkjent som 'global', og kan utføres omtrent hvor som helst innenfor en programkode.

Når du går videre, kan du se at kodene mellom linje 9 og 11 også ligner på det første programmet, likevel begynner ting å bli interessante etter linje 11. La oss se hvordan!

delayTime = delayTime - 100

I denne koden ser vi at standardverdien for forsinkelsestid blir modifisert ved å trekke 100 fra den.

Betydningen 100 trekkes fra den opprinnelige verdien på 1000, og gir den en ny verdi på 900.

Gjennom det følgende bildet vil vi prøve å forstå noen få av matematikkoperatørene som brukes i Arduino-språk.

La oss nå vurdere kodene mellom linje 13 og 15.

if(delayTime <= 0){ // If the delay time is zero or less, reset it. delayTime = 1000 }

Hovedmålet med ovennevnte kode er å sikre at LED-lampen fortsetter å blinke uten avbrudd.

På grunn av at 100 trekkes fra originalen forsinkelsestid , forhindrer det at LED-lampen blinker fra å nå null og gjør at blinkingen kan fortsette kontinuerlig.

Følgende bilde viser noen få sammenligningsoperatører som vi bruker i kodene våre:

sammenligningsoperatør for arduino-koder

I koden ovenfor kunne vi ha testet koden til å være if(delayTime == 0).

Men fordi det å være negativt kan være like dårlig, gikk vi ikke etter det, og dette er en anbefalt praksis.

Tenk hva som kunne ha vært resultatet hvis vi hadde prøvd å trekke 300 i stedet for 100 fra delayTime

Så nå har du kanskje innsett at hvis delayTime er skrevet som mindre eller lik null, vil forsinkelsestiden settes tilbake til opprinnelig figur 1000.

digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime)

De siste 4 linjene i koden som vist ovenfor blir ansvarlige for å slå LED på / av, på / av kontinuerlig.

Her kan du tydelig merke at i stedet for å bruke et antall figurer, har vi brukt en variabel for å tildele forsinkelsestiden, slik at vi kan justere den som vi vil i løpet av den operative perioden av koden. Det er kult, ikke sant?

2.3 ELSE-uttalelser

Her vil vi lære hvorfor og hvordan en hvis sikt kan ha en klausul ellers slik at den avgjør situasjonen i tilfelle hvis uttalelse er falsk.

Jeg beklager hvis det høres for forvirrende ut, ikke bekymre deg, vi prøver å forstå det med følgende eksempel:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { if(delayTime <= 100){ // If it is less than or equal to 100, reset it delayTime = 1000 } else{ delayTime = delayTime - 100 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

I det ovennevnte kan du godt se at i den 10. linjekoden utføres bare når delayTime er mindre eller lik 100, hvis ikke, så blir koden i den 13. linjen utført, men begge sammen kan aldri skje, verken den 10. linjen eller den 13. linjekoden vil bli implementert, aldri begge.

Du har kanskje lagt merke til at i motsetning til det vi gjorde i forrige avsnitt 2.2, her sammenlignet vi ikke med 0, snarere sammenlignet med 100. Dette er fordi i dette eksemplet sammenlignet FØR vi trakk 100, motsatt i avsnitt 2.2, sammenlignet vi ETTER at vi trukket. Kan du fortelle hva som kunne ha skjedd hvis vi hadde sammenlignet 0 i stedet for 100?

2.4 MILJØ uttalelser

TIL samtidig som uttalelse er ganske lik hvis uttalelse, bortsett fra sannheten om at det forårsaker gjentatt kjøring til en blokk med kode (som kan være mellom krøllete parenteser) så lenge forholdene er gjeldende, og dette fungerer uten en ellers uttalelse.

Følgende eksempel vil hjelpe deg med å forstå dette bedre

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } int delayTime = 1000 void loop() { while(delayTime > 0){ // while delayTime is greater than 0 digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) delayTime = delayTime - 100 } while(delayTime <1000){ // while delayTime is less than 1000 delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0 digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) } }

Kan du gjette hva ovennevnte kode er programmert til å gjøre? Vel, den er designet for å blinke lysdioden raskere og deretter langsommere.

2.5 Hva er sant og usant?

På programmeringsspråk, falsk refererer til null (0). Egentlig brukes ikke 'sant', i stedet antas det at når ingenting er falskt, så er alt som er inkludert sant.

Det ser litt rart ut, men det gjør jobben ganske pent.

Vi vil prøve å forstå situasjonen gjennom følgende eksempel.

Noen ganger kan du komme over en kode som gitt nedenfor:

while (1){ digitalWrite(kPinLed, HIGH) delay(100) digitalWrite(kPinLed, LOW) delay(100) }

Dette er kodet ser ut som om LED-utførelsen vil fortsette å sykle for alltid, så lenge strøm er tilgjengelig.

Imidlertid kan en ulempe med denne typen kode oppstå når brukeren ved et uhell bruker a = i stedet for ==.

Jeg er sikker på at du allerede vet at = betyr en oppgave, noe som betyr at den brukes til å betegne en valgt verdi til en variabel, mens a == brukes til å håndheve en test hvis verdien var den samme.

Anta for eksempel at du krevde at en LED skulle blinke med et fortgående mønster og gjentatte ganger, men feil brukt en = i stedet for ==.

Koden vil da vises som denne:

int delayTime = 1000 void loop() { if(delayTime = 0){ // WRONG!!! the = should have been == delayTime = 1000 } digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) delayTime = delayTime - 100 }

Feilen vil tildele 0 til delayTime, og føre til hvis uttalelse for å sjekke om 0 var sant eller ikke. Siden 0 refererer til falsk, vil den tro at det ikke er sant, og vil stoppe håndhevelsen av delayTime = 1000, men i stedet funksjonen delayTime holdes 0 i løpet av loop ().

Dette ser veldig uønsket ut !!

Så sjekk alltid programmet ditt for å forsikre deg om at du ikke har gjort slike tåpelige feil.

2.6 Kombinasjoner

Noen ganger kan du føle behovet for å teste flere ting sammen. Som det kan være lurt å undersøke om en variabel var mellom to tall. Selv om dette kan implementeres ved hjelp av if-setningen flere ganger, kan det være mer praktisk å bruke logiske kombinasjoner for bedre og enklere lesing.

Implementering av kombinasjoner på logiske vilkår kan gjøres med tre metoder, som vist i følgende tabell:

tabell som viser Arduino kombinasjonsmetoder

Det ville være interessant å vite at NOT-operatøren kan fungere som en bryter for en variabel som kan være utpekt til å være en av dem ekte eller falsk (eller LAV eller HØY).

Følgende eksempel illustrerer tilstanden:

int ledState = LOW void loop() { ledState = !ledState // toggle value of ledState digitalWrite(kPinLed, ledState) delay(1000) }

Her er ledState vil være LAV, og deretter så snart ledState = !ledState, vil den bli HØY. Følgende sløyfe vil forårsake ledState å være HØY når ledState = !ledState er lav.

2.7 FOR uttalelser

Nå skal vi prøve å forstå om en annen kontrollstruktur som er en til Løkke. Dette kan være veldig nyttig når du vil implementere noe flere ganger.

La oss forstå dette med følgende eksempel:

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { for(int i = 0 i <4 i++){ digitalWrite(kPinLed, HIGH) delay(200) digitalWrite(kPinLed, LOW) delay(200) } delay(1000) // 1 second }

Du kan finne noe unikt i tråd med til.

Det er koden jeg ++? . Dette er nyttig for programmerere som er ganske late og ønsker å implementere koding gjennom praktiske snarveier

Ovennevnte begrep er kjent som sammensatte operatører, siden de gjør jobben med å kombinere en oppdragsoperatør med en annen oppdragsoperatør. De mest populære av disse kan visualiseres i følgende tabell:

Du vil finne at det er 3 underuttalelser i en for uttalelse. Den er strukturert som vist nedenfor:

for (statement1conditionstatement2){ // statements }

Uttalelsen nr. 1 forekommer rett i begynnelsen og bare en gang. Tilstanden testes hver gang i løpet av løkken. Når det er ekte innenfor krøllete parenteser blir den påfølgende uttalelsen nr. 2 håndhevet. I tilfelle en falsk, systemet hopper til neste kodeblokk.

Koble til flere lysdioder

OK, nå får vi se hvordan vi kan koble til flere antall LEds for å få mer interessante effekter.

Vennligst koble lysdiodene og Arduino som vist nedenfor. Den røde ledningen er faktisk ikke nødvendig, men siden det alltid er lurt å ha begge forsyningsskinnene inkludert i brødplaten, er oppsettet fornuftig.

La oss nå fikse et program som gjør det mulig for oss å sjekke om maskinvaren vår er riktig konfigurert eller ikke.

Det anbefales alltid å kode og utføre små biter av programmer trinnvis for å sjekke om de respektive hardwares er koblet riktig eller ikke.

Dette hjelper med å feilsøke en mulig feil raskt.

Kodeeksemplet nedenfor gir LED 2 til 5 et bestemt mønster ved å snu dem etter hverandre på en syklisk måte.

const int kPinLed1 = 2 const int kPinLed2 = 3 const int kPinLed3 = 4 const int kPinLed4 = 5 void setup() { pinMode(kPinLed1, OUTPUT) pinMode(kPinLed2, OUTPUT) pinMode(kPinLed3, OUTPUT) pinMode(kPinLed4, OUTPUT) } void loop() { // turn on each of the LEDs in order digitalWrite(kPinLed1, HIGH) delay(100) digitalWrite(kPinLed2, HIGH) delay(100) digitalWrite(kPinLed3, HIGH) delay(100) digitalWrite(kPinLed4, HIGH) delay(100) // turn off each of the LEDs in order digitalWrite(kPinLed1, LOW) delay(100) digitalWrite(kPinLed2, LOW) delay(100) digitalWrite(kPinLed3, LOW) delay(100) digitalWrite(kPinLed4, LOW) }

Som du kanskje legger merke til, er det ikke noe galt med koden, bortsett fra at den ser lang og derfor utsatt for feil.

Det er selvfølgelig bedre måter å skrive ovennevnte kode på, den følgende delen vil avsløre den.

2.9 Introduksjon av arrays

Arrays kan være en gruppe variabler som kan indekseres med indeksnummer. Følgende eksempel vil hjelpe oss til å forstå det bedre.

const int k_numLEDs = 4 const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5 void setup() { for(int i = 0 i pinMode(kPinLeds[i], OUTPUT) } } void loop() { for(int i = 0 i digitalWrite(kPinLeds[i], HIGH) delay(100) } for(int i = k_numLEDs - 1 i >= 0 i--){ digitalWrite(kPinLeds[i], LOW) delay(100) } }

OK, la oss nå gå gjennom hver seksjon og forstå hvordan de faktisk fungerer.

const int k_numLEDs = 4

Ovennevnte kode definerer hvor mange maksimale elementer vi skal ha i matrisen. Denne koden hjelper oss i de påfølgende delene for å sikre at alt er skrevet i en matrise og ingenting når matrisen slutter.

const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

I denne neste linjen setter vi opp matrisestrukturen. Tallene innenfor braketten angir antall elementer i matrisen. Selv om den faktiske mengden kunne vært skrevet, fungerer skriving som konstanter bedre. Verdiene kan normalt sees inne i parentes med komma og betegne verdiene til matrisen.

Når du finner en matrise indeksert med tallet 0, indikerer dette det aller første elementet i matrisen, som vist i code: k_LEDPins is k_LEDPins[0].

På samme måte vil det siste elementet bli vist som k_LEDPins[3], ettersom antallet fra 0 til 3 er 4.

void setup() { for(int i = 0 i pinMode(kPinLeds[i], OUTPUT) } }

Ovennevnte kode viser bruken av loop for å fortsette gjennom hvert arrayelement og for å sette dem som OUTPUTS. Vi implementerer firkantede parenteser sammen med indeksen for å nå hvert av elementene i matrisen.

Hvis du lurer på om det er mulig å bruke pinne nr. 2 til pinne nr. 5 uten matriser, er svaret ja, det er mulig. Men i dette eksemplet blir det ikke gjort fordi vi ikke gjorde det på den måten. I de følgende avsnittene kan du eliminere matematikktilnærmingen hvis de valgte utgangspinnene ikke er i linje.

La oss se hva neste kodeblokk gjør:

for(int i = 0 i digitalWrite(kPinLeds[i], HIGH) delay(100) }

Her fortsetter koden gjennom hver av LED-lampene for å slå dem på sekvensielt med et gap eller forsinkelse på 100 millisekunder.

for(int i = k_numLEDs - 1 i >= 0 i--){ digitalWrite(kPinLeds[i], LOW) delay(100) }

Bruk av ovennevnte kode viser hvordan anvendelsen av for løkke kan brukes til å bevege seg gjennom løkken selv i omvendt rekkefølge.

Det begynner fra k_numLEDs - 1 fordi matriser er nullindeksert. Vi starter ikke fra k_LEDPins[4] fordi det vil resultere i å krysse målstreken til matrisen.

Koden bruker> = 0 for å sjekke slik at det første elementet i indeks 0 ikke blir savnet eller ignorert.

kapittel 3

Hva er en inngang

Så har vi lært hvordan du bruker ting ved hjelp av Arduino. I dette kapittelet vil vi diskutere hvordan du kan fornemme den virkelige verden ved å grense innganger fra eksterne parametere.

3.1 Bruke trykknapper

Vi vet alle hva en trykknapp er og hvordan den fungerer. Det er en slags bryter eller knapp som forbinder et signal fra ett kretsstadium til et annet kort tid mens det er i deprimert tilstand, og bryter signalet når det slippes.

“hva er en cdi -boks på en motorsykkel ”

3.1.1 Én knapp og en LED

Vi kobler Arduino med en trykknapp med Arduino i henhold til de ovennevnte detaljene og lærer grunnleggende arbeid og implementering av oppsettet.

Den angitte trykknappen, som også kalles en mikrobryter, har totalt 4 pinner (2 par på hver side). Når du skyver, blir hvert par tapper sammenføyd internt og muliggjør en tilkobling eller ledning over dem.

I dette eksemplet bruker vi bare ett par av disse pinnene eller kontaktene, det andre paret er irrelevant og blir derfor ignorert.

La oss fortsette å bruke følgende kode og sjekke den fungerer!

const int kPinButton1 = 2 const int kPinLed = 9 void setup() { pinMode(kPinButton1, INPUT) digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor pinMode(kPinLed, OUTPUT) } void loop() { if(digitalRead(kPinButton1) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

Du kan finne noen få ting som ser uvanlige ut her. La oss finne ut av dem trinnvis.

void setup() { pinMode(kPinButton1, INPUT) digitalWrite(kPinButton1, HIGH) // turn on pull-up resistor pinMode(kPinLed, OUTPUT) }

Det første vi gjør er å fikse buttonPin som INNGANG. Vel, det er ganske grunnleggende, vet jeg.

Deretter tildeler vi HØY til INNGANG pin. Du er rart, hvordan det kan være mulig å skrive noe ved inngangen? Visst, dette kan være interessant.

Når du tildeler en HIGH til en Arduino-inngang, slås en intern 20k Ohm pull-up-motstand PÅ (en LOW på denne pinnen slår den AV).

Et annet spørsmål du kan ha er hva som er en motstand som kan trekkes opp. Jeg har dekket et omfattende innlegg om pull-up motstander som du lær det her .

OK, la oss se på hovedløkkekoden:

void loop() { if(digitalRead(kPinButton1) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

Når du trykker på trykknappen, kobles den kablede stiften til bakken, noe som gir en LAV til den nålen. Og mens du er i upresset tilstand, holdes den samme pinnen HØY eller + 5V via 20K intern opptrekksmotstand.

Her vil vi at Arduino skal lyse opp LED når trykknappen trykkes (LAV), derfor skriver vi HØY for utgangen for hvert svar på et LAV fra trykknappen, mens den trykkes.

3.1.2 To knapper og en LED

Vel, du lurer kanskje på at ovennevnte handling kunne ha blitt utført uten en Arduino også. Jeg forstår, men dette er en stepping stone for å lære hvordan trykknapp kan brukes med Arduno.

Inntil dette punktet har vi studert å skrive koder for enten å slå PÅ (HØY) eller å slå AV (LAV) en LED.

La oss nå se hvordan lysstyrken på LED kan kontrolleres med en Arduino.

Det kan gjøres ved å bruke to metoder:

Ved å begrense strømmen til LED-lampen
Ved bruk av PWM eller pulsbreddemodulasjon, der tilførselen til LED-en blir slått PÅ / AV med en ønsket hastighet veldig raskt, og gir en gjennomsnittlig belysning hvis intensitet vil avhenge av PWM.

I et Arduino-kort er PWM-støtte tilgjengelig på pinner merket med en tilde (~), som er pinner 3, 4,5,9,10 og 11) ved 500Hz (500 ganger i sekundet). Brukeren er i stand til å gi en hvilken som helst verdi mellom 0 og 255, hvor 0 refererer til ingen HØY eller ingen + 5V, og 255 ber Arduino om å få en HØY eller + 5V hele tiden. For å starte disse kommandoene må du få tilgang til analogWrite () med ønsket verdi.

Du kan anta at PWM er x / 255 der x er ønsket verdi du vil sende via analogWrite().

Sett opp Arduino og andre parametere som vist ovenfor.

const int kPinButton1 = 2 const int kPinButton2 = 3 const int kPinLed = 9 void setup() { pinMode(kPinButton1, INPUT) pinMode(kPinButton2, INPUT) pinMode(kPinLed, OUTPUT) digitalWrite(kPinButton1, HIGH) // turn on pullup resistor digitalWrite(kPinButton2, HIGH) // turn on pullup resistor } int ledBrightness = 128 void loop() { if(digitalRead(kPinButton1) == LOW){ ledBrightness-- } else if(digitalRead(kPinButton2) == LOW){ ledBrightness++ } ledBrightness = constrain(ledBrightness, 0, 255) analogWrite(kPinLed, ledBrightness) delay(20) }

Du kan finne tre linjer her som trenger forklaring.

ledBrightness = constrain(ledBrightness, 0, 255) 25 analogWrite(kPinLed, ledBrightness) 26 delay(20)

Linjen: ledBrightness = constrain(ledBrightness, 0, 255) illustrerer en unik funksjon i Arduino kjent som constrain ().

Denne interne funksjonen inneholder kode som ligner på følgende:

int begrense (int verdi, int min, int maks)
{ if(value > max){ value = max } if(value value = min } return value }

Alle koder diskutert før dette begynte med tomrom , som betydde ikke å returnere noe (ugyldig). Mens ovennevnte kode begynner med int , som indikerer at den returnerer et helt tall. Vi vil diskutere mer om i de senere avsnittene, for øyeblikket bare husk at et helt tall ikke har noen brøkdeler.

Riktig, så dette antyder, koden: ledBrightness = constrain(ledBrightness, 0, 255) tildeler ledBrightness to be within the range of 0 and 255.

Den neste linjen bruker analogWrite til kommandoer til Arduino om å bruke PWM på den valgte pinnen med ønsket verdi.

Den neste linjen skaper en forsinkelse på 20 millisekunder, dette er for å sikre at vi ikke justerer spiste raskere enn 50 Hz eller 50 ganger i sekundet. Dette er fordi mennesker kan være mye tregere enn en Arduino. Derfor, hvis forsinkelsen ikke blir gjort, kan programmet få oss til å føle at ved å trykke på den første knappen slo LED av og trykke på den andre knappen slå den PÅ (prøv å bekrefte det selv).

3.2 Potensiometre

La oss gå videre og lære å bruke potensiometre med Arduino.

For å vite hvordan potensiometer eller en gryte fungerer, kan du lese dette artikkel .

Koble de viste parametrene til Arduino som vist ovenfor.

En pott vil ha 3 terminaler. Den midterste terminalen vil koble seg til ANALOG IN 0 på Arduino. De to andre ytre terminalene kan være koblet til + 5V og 0V forsyningsskinner.

La oss programmere og sjekke resultatene:

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinPot, INPUT) pinMode(kPinLed, OUTPUT) } void loop() { int ledBrightness int sensorValue = 0 sensorValue = analogRead(kPinPot) ledBrightness = map(sensorValue, 0, 1023, 0, 255) analogWrite(kPinLed, ledBrightness) }

Du finner et par ting som kan se helt nye ut og ikke er inkludert i noen av våre tidligere koder.

Konstanten kPinPot er tildelt A0, hvor A er snarveien for å beskrive en av de analoge pinnene. Imidlertid refererer A0 også til pinne nr. 14, A1 til pinne nr. 15 og så videre, og disse lar deg brukes som digitale innganger / utganger i tilfelle du går tom for pinner for et eksperiment. Men husk at du ikke kan bruke digitale pinner som analoge pinner.
Linjen: ledBrightness = map(sensorValue, 0, 1023, 0, 255) presenterer en ny innside-funksjon i Arduino kjent som kart(). Denne funksjonen kalibrerer fra et gitt område til et annet, betegnet som kart (verdi, fra lav, fra høy, til lav, til høy). Dette kan bli avgjørende siden analogueRead gir en verdi i området 0-1023, men analogWrite er i stand til å akseptere en verdi fra 0-255.

Du tenker kanskje at siden det er mulig å kontrollere lysstyrken til en LED gjennom en skiftende motstand, kan bare en gryte ha vært tilstrekkelig for formålet, hvorfor bruken av Arduino. Vel, igjen er det bare fundamentet, for å vise hvordan en pott kan konfigureres med en Arduino.

Ingen problemer, nå skal vi gjøre noe som ikke kan gjøres uten en Arduino.

I dette eksperimentet vil vi se hvordan en grytes varierende motstand kan brukes til å kontrollere blinkhastigheten eller hastigheten til en LED.

Her er programmet:

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinLed, OUTPUT) } void loop() { int sensorValue sensorValue = analogRead(kPinPot) digitalWrite(kPinLed, HIGH) delay(sensorValue) digitalWrite(kPinLed, LOW) delay(sensorValue) }

3.2.3 Unngå forsinkelse ()

Ovennevnte kode ser bra ut, men LED-lampen kan ikke kontrollere pottenes verdi før den går gjennom hver hele syklus. For lengre forsinkelser blir denne prosessen lenger, og brukeren må vente på å se potetsvaret mens han beveger den. Denne forsinkelsen kan unngås med noen intelligente programmeringer, slik at den lar brukeren sjekke verdien uten minimale forsinkelser. Her er koden.

const int kPinPot = A0 const int kPinLed = 9 void setup() { pinMode(kPinLed, OUTPUT) } long lastTime = 0 int ledValue = LOW void loop() { int sensorValue sensorValue = analogRead(kPinPot) if(millis() > lastTime + sensorValue){ if(ledValue == LOW){ ledValue = HIGH } else{ ledValue = LOW } lastTime = millis() digitalWrite(kPinLed, ledValue) } }

Så hva er det annerledes i ovennevnte kode? Det er følgende linje som utgjør forskjellen.

long lastTime = 0

Fram til denne delen har vi diskutert om variabelen int. Imidlertid kan det være mange flere typer variabler du kan få tilgang til. Listen kan leses nedenfor:

For tiden kan det bare være avgjørende å vite at for lagring av relativt stort antall for int variabel, kan du bruke begrepet lang eller a lang int.

Her kan du se en annen interessant funksjon kalt millis ().

Dette produserer tidsperioden i millisekunder som Arduino jobbet i løpet av driften fra begynnelsen (dette tilbakestilles til 0 etter hver 50. dag). Her returnerer det lenge fordi hvis det returnerte int , er det ikke mulig å telle i lange perioder. Kan du svare nøyaktig hvor lenge? Svaret er 32,767 sekunder.

Derfor, i stedet for å bruke forsinkelse (), ser vi etter millis (), og så snart det bestemte antall millisekunder går ut, bytter vi LED. Derfor lagrer vi tiden vi endret den sist i sist variabel, slik at den lar oss sjekke den igjen når det er ønskelig.

3.3 RGB-lysdioder

Så langt har vi spilt med enfarget LED. Selv om LED-farge kan endres ved å erstatte LED-en med en annen farge, men hva med å bruke RGB-lysdioder for å endre LED-farger uten å skifte lysdioder?

En RGB LED er i utgangspunktet en LED som har en rød, grønn og blå LED innebygd og slått sammen til en enkelt LED. Den har en felles ledning som går til bakken eller 0V forsyningsskinne mens de andre 3 ledningene mates med diversifiserte PWM-positive signaler for å implementere den tiltenkte fargeblanding .

Du kan koble til oppsettet som vist nedenfor:

Det kan se litt komplekst ut, men faktisk er det en kopi av vår tidligere LED-kontrolldesign ved bruk av PWM.

Her er en praksisprogramkode:

const int kPinPot1 = A0 const int kPinPot2 = A1 const int kPinPot3 = A2 const int kPinLed_R = 6 const int kPinLed_G = 10 const int kPinLed_B = 11 void setup() { pinMode(kPinLed_R, OUTPUT) pinMode(kPinLed_G, OUTPUT) pinMode(kPinLed_B, OUTPUT) } void loop() { int potValue int ledValue potValue = analogRead(kPinPot1) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_R, ledValue) potValue = analogRead(kPinPot2) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_G, ledValue) potValue = analogRead(kPinPot3) ledValue = map(potValue, 0, 1023, 0, 255) analogWrite(kPinLed_B, ledValue) }

Etter at du har lastet opp denne koden, er det bare å se hvordan pottejusteringene skaper interessant lyseffekt på RGB, det kan være veldig morsomt.

Du vil oppdage at når alle de tre pottene flyttes maksimale posisjoner, vil du se rødt i stedet for en hvit farge. Dette er fordi rød farge er den mest fremtredende blant de tre fargene og derfor dominerer i denne situasjonen. Du kan imidlertid eksperimentere med funksjonen kart() , før du kjører den til den røde delen av LED-en, for å skape en mer fornuftig balanse.

Lyd med Arduino

I denne delen lærer vi hvordan du legger til grunnleggende lyd og musikk til et Arduino-oppsett.

Vi får se hvordan du bytter et signal til en tilkoblet høyttaler med ønsket frekvens.

For å være mer presis, vil en midt A-note bli prøvd, som er en 440 Hz frekvensnotat.

For å gjøre dette, spiller vi ganske enkelt et midt A-notat og optimaliserer sinusbølgesignalet med firkantbølgen.

Vi beregner også hvor lenge en høyttaler kan være PÅ ved å saksøke formelen:

timeDelay = 1 sekund / 2 x toneFrekvens.

timeDelay = 1 sekund / 2 x 440

timeDelay = 1136 mikrosekunder

4.1 La oss koble opp Arduino Board

4.2 Legge til en enkel merknad

Vi har allerede diskutert om funksjonen forsinkelse() der enheten er i millisekunder (sekund / 1000), men du vil finne enda en funksjon delayMicroseconds() der enheten er i mikrosekunder, (millisekunder / 1000).

For det nåværende oppsettet programmerer vi en kode for å slå 5V PÅ / AV på den valgte pinnen som er koblet til høyttaleren, med en hastighet på 440 pulser per sekund.

Husk, i den siste diskusjonen bestemte vi verdien 1136 mikrosekund for den tiltenkte lydnoten.

Så her er programmet for dette, som lar deg høre et lydnotat på 440 Hz så snart du programmerer arduinoen med en tilkoblet høyttaler.

const int kPinSpeaker = 9 const int k_timeDelay = 1136 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { digitalWrite(kPinSpeaker, HIGH) delayMicroseconds(k_timeDelay) digitalWrite(kPinSpeaker, LOW) delayMicroseconds(k_timeDelay) }

Med applikasjonen ovenfor er det mulig å lage et lydnotat, noe som også betyr at vi kan lage en musikk etter eget valg.

Fra koden forstår vi at Arduino inkluderer et par integrerte funksjoner som i tillegg bidrar til å skape musikk.

Den første er tone() som fungerer med to elementer sammen med et tredje valgfritt element, betegnet som tone (pin, frekvens, varighet). eller tone (pin, frekvens)

Begge er utpekt for å utføre henholdsvis den tidsperioden du har tildelt.

I mangel av en tidsperiode vil musikken fortsette å spilles til samtalen tone() kjøres på nytt, eller til du kjører ikke en ().

Dette må gjøres ved hjelp av en forsinkelsesfunksjon i tilfelle musikk å spille er det eneste grunnleggende du implementerer.

Tidsvarigheten kan være avgjørende siden det gir deg tid til hvor lenge musikken spilles, så kan du fritt gjøre andre ting. Så snart varigheten går bort, stopper musikken.

Den neste funksjonen ikke en () håndterer en enkelt parameter og stopper den valgte tonen på en bestemt tildelt pin.

En merkelig advarsel: Når som helst tone() funksjonen er implementert, vil PWM-funksjonen på pin 3 og 11 slutte å fungere.

Derfor, når du bruker et høyttalervedlegg i programmet, må du passe på å ikke bruke den nevnte pinnen til høyttalerne, i stedet prøve noen andre pinner for høyttalervestet.

OK så her er programmet for implementering av musikk på en høyttaler, selv om det ikke er en ekte musikk, snarere en basiskala C-note.

#define NOTE_C4 262 #define NOTE_D4 294 #define NOTE_E4 330 #define NOTE_F4 349 #define NOTE_G4 392 #define NOTE_A4 440 #define NOTE_B4 494 #define NOTE_C5 523 const int kPinSpeaker = 9 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { tone(kPinSpeaker, NOTE_C4, 500) delay(500) tone(kPinSpeaker, NOTE_D4, 500) delay(500) tone(kPinSpeaker, NOTE_E4, 500) delay(500) tone(kPinSpeaker, NOTE_F4, 500) delay(500) tone(kPinSpeaker, NOTE_G4, 500) delay(500) tone(kPinSpeaker, NOTE_A4, 500) delay(500) tone(kPinSpeaker, NOTE_B4, 500) delay(500) tone(kPinSpeaker, NOTE_C5, 500) delay(500) noTone(kPinSpeaker) delay(2000) }

I koden ovenfor har du kanskje lagt merke til noe nytt, og det er det #definere .

Dette begrepet fungerer som et søk og erstat kommando for datamaskinen mens kompilering blir gjort.

Når den finner den første tingen før et mellomrom, erstatter den den med den gjenværende delen av linjen (kalt makroer).

Så innenfor dette eksemplet når datamaskinen ser MERK_E4 den erstatter den raskt med mengden 330.

For flere notater og tilpasning kan du henvise til en fil på USB-pinnen som heter plasser.h , der de fleste frekvensene kan bli funnet etter dine preferanser.

4.4 Musikk med funksjoner

Koden ovenfor ser bra ut, men ser ut til å ha mange repetisjoner. Det burde være noen metode for å forkorte disse repetisjonene, ikke sant?

Så langt har vi jobbet med to viktige funksjoner som følger med Arduino. Nå kan det være på tide at vi oppretter våre egne funksjoner.

Hver funksjon må begynne med typen variabel den kan være assosiert med. For eksempel funksjonen tomrom refererer til typen som ikke returnerer noe, derav navnet ugyldig. Merk at vi allerede har diskutert en liste over variabler i våre tidligere seksjoner. Det kan være lurt å henvise dem.

Følgelig får det spesielle funksjonsnavnet en åpen parentes '(' etterfulgt av en liste over kommaskilte parametere.

Hver av parameterne får sin type sammen med et navn, og til slutt en avslutning ')' parentes.

Disse parametrene kan brukes i funksjonen i form av variabler.

La oss se et eksempel nedenfor der vi utvikler en funksjon som heter ourTone () designet for å slå sammen tone() med forsinkelse() linjer, på en måte som funksjonen slutter å returnere til tonen er ferdig med å spille tonen.

Vi implementerer disse funksjonene i vår forrige kode, og får programmet nedenfor, se de siste linjene:

Funksjoner kan være svært nyttige for å gjøre et program lettere å forstå.

Følgende er et eksempel der vi er i stand til å spesifisere valget av tone vi vil spille ved hjelp av to matriser. Den ene matrisen for å beholde notene, den andre for å beholde taktene.

#include 'pitches.h' int kPinSpeaker = 9 #define NUM_NOTES 15 const int notes[NUM_NOTES] = // a 0 represents a rest { NOTE_C4, NOTE_C4, NOTE_G4, NOTE_G4, NOTE_A4, NOTE_A4, NOTE_G4, NOTE_F4, NOTE_F4, NOTE_E4, NOTE_E4, NOTE_D4, NOTE_D4, NOTE_C4, 0 } const int beats[NUM_NOTES] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4 } const int beat_length = 300 void setup() { pinMode(kPinSpeaker, OUTPUT) } void loop() { for (int i = 0 i if (notes[i] == 0) { delay(beats[i] * beat_length) // rest } else { ourTone(notes[i], beats[i] * beat_length) } // pause between notes noTone(kPinSpeaker) delay(beat_length / 2) } } void ourTone(int freq, int duration) { tone(kPinSpeaker, freq, duration) delay(duration) }

Du kan tydelig se innledningen på første linje #inkludere uttalelse. Jobben med denne uttalelsen er å plukke opp hele filen mellom anførselstegnene og plassere den i posisjonen til #inkludere uttalelse. I henhold til standardreglene er disse strengt plassert i starten av programmet.

Kapittel 5

Måling av temperatur

Bare husk, i stedet for å skrive store programmer helt, er det alltid lurt å skrive og analysere små deler av koder, noe som hjelper deg med å spore feil raskt.

5.1 Seriell skjerm

Inntil nå ser kodene vi diskuterte ikke ut som enklere for å muliggjøre rask feilsøking. Her vil vi prøve å gjøre ting enklere for overvåking og enklere løsning av et mulig problem.

Arduino har en funksjon som gjør det mulig å 'snakke tilbake' med datamaskinen. Du kan bli observert at pin0 og pin1 er merket som RX en TX ved siden av hverandre. Disse pinnene blir faktisk sporet av en egen IC i Arduino, som oppgraderer dem til å lese over USB-kabelen mens den er koblet til PCen.

Avsnittet nedenfor viser et fullverdig program. Vennligst gå gjennom det, vi lærer om de nye oppføringene i koden etterpå. Denne koden er den samme som uttrykt i avsnitt 2.2, bortsett fra at den inneholder ekstra data for å la oss identifisere hva den er kodet for.

const int kPinLed = 13 void setup() { pinMode(kPinLed, OUTPUT) Serial.begin(9600) } int delayTime = 1000 void loop() { delayTime = delayTime - 100 if(delayTime <= 0){ // If it would have been zero or less, reset it. delayTime = 1000 } Serial.print('delayTime = ') Serial.println(delayTime) digitalWrite(kPinLed, HIGH) delay(delayTime) digitalWrite(kPinLed, LOW) delay(delayTime) }

Du kan identifisere to nye ting her, en ny linje i oppsett () funksjon.

Serial.begin(9600)

Denne linjen uttrykker ganske enkelt nødvendigheten av å bruke Seriell1 kode for å håndheve den med 9600 baud. (her refererer seriell til biter sendes etter hverandre, og baud betyr hastigheten den sendes med). Denne baudverdien og den som er inne i den serielle skjermen (vi får vite dette senere) må være lik, ellers vil dataene i den serielle skjermen vise søppel. 9600 blir standarden blir mer praktisk å bruke.

Den andre nye oppføringen er som følger

Serial.print('delayTime = ') Serial.println(delayTime)

Her antyder den andre linjen at den påfølgende tingen som kommer ut fra serieporten starter på neste linje. Det er slik den andre linjen er forskjellig fra knyttneven.

En ting til du kan se er sitater ('). Dette er kjent som en streng, som bare brukes som konstanter her, fordi videre diskusjon om dette emnet kan være for omfattende og utenfor omfanget.

OK, vi kan nå laste opp ovennevnte kode i Arduino og se hva som skjer.

Hva, Ups ingenting ser ut til å ha skjedd, Arduino pin # 13 LED blinket og stoppet, mens Tx LED fortsatte å blinke.

Vel, det er fordi vinduet Serial Monitor ikke er løst ennå.

Du må klikke på Serial Monitor-boksen i IDE som vist ovenfor. Ikke glem å sjekke overføringshastigheten nederst til høyre, som standard skal den være 9600, og vil matche koden. Hvis det ikke er, må du velge 9600.

Følgende videoklipp forklarer hvordan det gjøres.

https://youtu.be/ENg8CUyXm10

La oss nå gå videre og lære hvordan ovennevnte Serial Monitor-funksjon kan hjelpe deg med å behandle måling av temperatur ved bruk av Arduino

Vi bruker IC TMP36 som temperatursensor, med et område på -40 til 150 grader Celsius.

Oppsettet kan sees nedenfor:

Følgende kode vil starte måling av temperatur ved å lese utgangen fra TMP36-sensoren, og ved å sende dem til den serielle skjermen på ID.

const int kPinTemp = A0 void setup() { Serial.begin(9600) } void loop() { float temperatureC = getTemperatureC() Serial.print(temperatureC) Serial.println(' degrees C') // now convert to Fahrenheit float temperatureF = convertToF(temperatureC) Serial.print(temperatureF) Serial.println(' degrees F') delay(500) } float getTemperatureC() { int reading = analogRead(kPinTemp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 } float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

La oss forstå koden fra toppen.

float temperatureC = getTemperatureC()

Her kan du se at vi har tatt med variabeltypen flyte.

Dette er den eneste variabeltypen som har lagring av alt unntatt heltall (tall uten desimal- eller brøkdeler).

Nøyaktigheten fra en flottørvariabel kan være opptil 6 til 7 sifre.

Den tilstøtende koden getTemperatureC() er vår egen funksjon som matematisk beregner og konverterer den registrerte spenningsforskjellen fra TMP36-sensoren til grader Celsius.

float getTemperatureC() { int reading = analogRead(kPinTemp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 }

I neste del av kodene, siden begrepet analogIn() er gitt til å returnere et tall mellom 1 og 1023, blir det mulig for oss å vurdere spenningen fra sensoren ved å multiplisere avlesningen vår med 5 og deretter dele den med 1024.

Sensoren TMP36 er spesifisert for å generere en 0,5V ved 0 grader Celsius, og genererer deretter 10mV for hver eneste økning i grad Celsius.

Her er tilnærmingen som vi kan generere gjennom beregningene:

Du kan vurdere å være din første funksjon som returnerer noen verdi (merk at alle de gjenværende funksjonene så langt ikke returnerte noen verdi siden de har vært av typen tomrom ).

Du kan forstå at for å få en verdi fra en funksjon, trenger du bare å legge til komme tilbake etterfulgt av ønsket nummer du vil returnere.

Når vi sier komme tilbake det betyr at funksjonen returnerer et svar eller et svar når det kalles, som kan brukes på en variabel.

Når dette sendes til Serial Monitor, blir lesingen konvertert til Fahrenheit gjennom convertToF ().

float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

Denne funksjonen plukker opp Celsius-serien og konverterer den til Fahrenheit.

For å konvertere Fahrenheit til Celsius implementerer vi formelen Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Grensesnitt mellom en LCD-skjerm

La oss nå studere hvordan du kan grensesnitt eller koble til en LCD-skjerm med Arduino for å få visuell visning for de nødvendige utgangene.

I vår applikasjon skal vi bruke en 84x48 grafisk LCD, med en 84 piksler eller prikker horisontalt, og 48 piksler vertikal oppløsning. Siden en dedikert kontroller er avgjørende for alle LCD-skjermer, inneholder den nåværende enheten også en i form av PCD8544-kontroller.

I denne veiledningen kobler vi den ovennevnte LCD-modulen med Arduino, og bruker visse rutiner for å lage tekstmeldinger på skjermen.

I figuren nedenfor kan du finne detaljer om grensesnittet til LCD-skjermen, sammen med en liten 3,3V spenningsregulator . Denne regulatoren er nødvendig siden LCD-skjermen er spesifisert for å fungere med en 3,3 V forsyning.

Du kan også se 8 pinouts fra LCD-modulen, pinout-spesifikasjonene kan studeres fra følgende tabell:

La oss nå se hvordan vi kan koble LCD-skjermen og de relevante parametrene til Arduino. Detaljene kan visualiseres i illustrasjonen nedenfor:

5.4 Kommunisere til LCD-skjermen

Selv om det er mulig å skrive forseggjorte coeds for interaksjon med LCD fra Arduino, vil vi heller lære å gjøre det samme ved hjelp av biblioteker.

Biblioteker består av et utvalg koder som raskt kan brukes til et valgt Arduino-program.

Dette gjør det mulig for brukeren å ringe en funksjon uanstrengt uten å måtte gå gjennom komplisert kodearbeid.

5.4.1 Hvordan installere biblioteket

For dette må du opprette en katalog som heter biblioteker på datamaskinen din Arduino IDE, som forklart her

5.4.2 Implementere LCD-funksjonene

“4 -polet dobbeltkastbryter skjematisk ”

Akkurat som vår forrige tilnærming, vil vi først sjekke hele koden og deretter prøve å forstå detaljene i de enkelte linjene.

#include const int kPin_CLK = 5 const int kPin_DIN = 6 const int kPin_DC = 7 const int kPin_RESET = 8 PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) void setup() { lcd.init() lcd.setCursor(0,0) lcd.print('Hello, World!') } void loop() { lcd.setCursor(0,1) lcd.print(millis()) }

Linjen inkluderer koden #include

Koden #include instruerer PCen om å hente den nevnte filen og erstatte #include-elementet med filinnholdet i løpet av kompilering av programmet.

Elementet # inkluderer kan ha vinkelparenteser som indikerer søking i bibliotekkatalogen, alternativt kan det også ha anførselstegn som indikerer søking i samme katalog som programmet ligger i.

De påfølgende kodelinjene uttrykker LCD-pinouts, og så skriver vi en ny form for variabel:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Her uttrykker vi en variabel med navnet lcd som har typen PCD8544 og instruerer PCen om å omorganisere pinouts tilknyttet Arduino.

I denne prosessen beskriver vi variabelen til PC-en ved å instruere hvordan pin clk, din, dc og reset er grensesnittet med Arduino.

void setup() { lcd.init() lcd.setCursor(0,0) lcd.print('Hello, World!') }

Linjen lcd.init() initialiserer LCD-operasjonen. Når dette er utført, tvinger neste linje en markør øverst til venstre på skjermen. Og neste påfølgende linje prøver å skrive ut meldingen 'Hallo, Verden'.

Dette ser ganske identisk ut med teknikken der vi sendte meldinger over den serielle skjermen. Den eneste forskjellen er bruk av koden lcd.print i stedet for serial.print.

Neste kodeblokk kalles faktisk repeterende.

void loop() { lcd.setCursor(0,1) lcd.print(millis()) }

Bruker denne linjen lcd.setCursor(0,1) vi fikser markøren til den 0te kolonnen helt til venstre på 1. rad, over LCD-skjermen.

Den neste linjen bruker en snarvei: lcd.print(millis())

Hvis du husker at vi har jobbet med millis() i våre tidligere koder kunne vi ha brukt det samme her også gjennom kodene:

long numMillis = millis() lcd.print(numMillis)

Men på grunn av det faktum at ingen tidsperioder i millisekunder er involvert, oppnår vi det ved å sende millis() funksjon direkte til lcd.print() .

5.5 Kombinere helheten

OK, la oss nå kombinere alle kodene vi lærte ovenfor for å lage LCD-temperaturkretsen, og la oss se hvordan det ser ut:

#include const int kPin_CLK = 5 const int kPin_DIN = 6 const int kPin_DC = 7 const int kPin_RESET = 8 const int kPin_Temp = A0 PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET) void setup() { lcd.init() lcd.setCursor(10,0) lcd.print('Temperature:') } void loop() { float temperatureC = getTemperatureC() // now convert to Fahrenheit float temperatureF = convertToF(temperatureC) lcd.setCursor(21,1) lcd.print(temperatureC) lcd.print(' C') lcd.setCursor(21,2) lcd.print(temperatureF) lcd.print(' F') delay(100) } float getTemperatureC() { int reading = analogRead(kPin_Temp) float voltage = (reading * 5.0) / 1024 // convert from 10 mv per degree with 500mV offset // to degrees ((voltage - 500mV) * 100) return (voltage - 0.5) * 100 } float convertToF(float temperatureC) { return (temperatureC * 9.0 / 5.0) + 32.0 }

Alt ser standard ut i programmet ovenfor, bortsett fra bruk av funksjonen setCursor () . Dette brukes til å justere teksten så langt som mulig rundt midten av skjermen.

Flott! Og gratulerer, du har nettopp programmert din egen lille LCD temperaturindikator ved hjelp av Arduino.

Praktiske Arduino-applikasjoner

Siden vi på dette tidspunktet har grundig dekket de forskjellige programmeringsteknikkene i detalj, er det på tide å gjennomgå dem ved å bruke dem på noen nyttige praktiske implementeringer.

Vi begynner med sensorer og ser hvordan sensorenheter kan brukes med Arduino ved å utføre noen få prøvekoder.

7.1 Introduksjon til sensorer

I denne opplæringen vil vi lære om det store utvalget av sensorer som kan brukes med Arduino. Disse kan omfatte enheter som lyssensor LDR, magnetisk hall-effektsensor, vippesensorer, vibrasjonssensor, trykksensor etc.

Vi begynner med grensesnittet mellom lyssensor LDR med Arduino, som vist i følgende diagram:

Som vi alle vet, er LDR en lysavhengig motstandsenhet hvis motstand avhenger av intensiteten til den omgivende hendelsen på overflaten.

Lysintensiteten er omvendt proporsjonal med motstandsavlesningen til LDR.

Her vil vi lære hvordan denne egenskapen kan integreres med Arduino for å utføre en nyttig applikasjon:

Den komplette programkoden kan visualiseres som gitt nedenfor:

const int kPin_Photocell = A0 void setup() { Serial.begin(9600) } void loop() { int value = analogRead(kPin_Photocell) Serial.print('Analog Reading = ') Serial.print(value) if(value <200){ Serial.println(' - Dark') }else if(value <400){ Serial.println(' - Dim') } else if(value <600){ Serial.println(' - Light') } else if(value <800){ Serial.println(' - Bright') } else{ Serial.println(' - Very Bright') } delay(1000) }

Alle parametrene som er brukt i koden har allerede blitt diskutert i kurset vårt som vi har lært så langt. Du kan sjekke linjene ved å referere til de aktuelle delene.

Verdiene ble valgt tilfeldig, du kan enkelt endre i henhold til dine egne preferanser.

Vippesensor

En vippesensor er en enkel enhet som kan brukes til å oppdage en vippehandling på ethvert objekt der den er installert. Enheten har i utgangspunktet en metallkule inni, som ved vipping ruller over et par kontakter som forårsaker en ledning over disse kontaktene. Disse kontaktene blir avsluttet som ledningene til vippebryteren, og brukes med en ekstern krets for å oppdage ledningen på grunn av en vippehandling og aktivere ønsket utgangsapplikasjon.

La oss nå se hvordan en vippesensor enheten kan kobles til. Bildet nedenfor gir oss en ide om den komplette konfigurasjonen:

const int kPin_Tilt = 3 const int kPin_LED = 13 void setup() { pinMode(kPin_Tilt, INPUT) digitalWrite(kPin_Tilt, HIGH) // turn on built-in pull-up resistor pinMode(kPin_LED, OUTPUT) } void loop() { if(digitalRead(kPin_Tilt) == HIGH){ digitalWrite(kPin_LED, LOW) } else{ digitalWrite(kPin_LED, HIGH) } }

I dette eksemplet brukes standard pin # 13 LED som tiltindikator.

Du kan tydelig se inkluderingen av opptrekksmotstanden her, ganske lik det vi gjorde i avsnitt 3.1. Derfor indikerer begrepet LAV at vippefunksjonen ikke er utløst.

7.4 Reed Switch Relay (Miniature Magnet Activated Relay)

La oss nå se hvordan du kobler til en relébryter eller en magnetfeltsensor med Arduino. Et sivrelé er en slags bryter som aktiverer eller utfører når et magnetfelt eller en magnet bringes i nærheten av det. I utgangspunktet har den et par ferromagnetiske kontakter inne i et miniatyrglasskabinett som går sammen eller tar kontakt på grunn av magnetisk trekk når en magnetisk er i nærheten av den. Når dette skjer, viser kontaktene på ledning på grunn av lukking av kontaktene.

Også her bruker vi pinnen nr. 13 LED for å indikere responsen. Du kan koble til en ekstern LED fra denne pinnen hvis det er nødvendig i henhold til våre tidligere forklaringer.

const int kPinReedSwitch = 2 const int kPinLed = 13 void setup() pinMode(kPinReedSwitch, INPUT) digitalWrite(kPinReedSwitch, HIGH) // turn on pullup resistor pinMode(kPinLed, OUTPUT) } void loop() { if(digitalRead(kPinReedSwitch) == LOW){ digitalWrite(kPinLed, HIGH) } else{ digitalWrite(kPinLed, LOW) } }

Kodeuttrykkene skal være kjent og selvforklarende.

7.5 Vibrasjonssensor ved bruk av Piezo Transducer

I neste prøveprogram ser vi hvordan en piezo-svinger kan brukes som en vibrasjonssensor for å belyse en LED gjennom Arduino.

Et piezo-element er faktisk en enhet som genererer vibrasjon eller svingning når en frekvens påføres over terminalene. Imidlertid kan den samme piezo brukes i omvendt prosess for generere elektriske pulser som svar på vibrasjoner på kroppen. Denne vibrasjonen kan være i form av et bank eller slag på overflaten av piezo.

Sett opp Arduino og et piezo-element som gitt i figuren nedenfor

bruker piezo som vibrasjonssensor med Arduino

const int kPinSensor = A5 const int kPinLed = 13 const int k_threshold = 100 int ledState = LOW // variable used to store the last LED status, to toggle the light void setup() { pinMode(kPinLed, OUTPUT) // declare the ledPin as as OUTPUT } void loop() { int val = analogRead(kPinSensor) if (val >= k_threshold) { ledState = !ledState // toggle the value of ledState digitalWrite(kPinLed, ledState) delay(20) // for debouncing } }

Terskelen 100 er introdusert bare for å sikre at Arduino bare reagerer på de ekte vibrasjonene gjennom slag, og ikke andre mindre vibrasjoner som fra høye lyder eller horn.

Valget av A5-pin er ikke obligatorisk, du kan velge andre analoge innganger etter eget ønske og ved å matche den i programkoden.

Bruker servomotor med Arduino

En servomotor er en type DC-motor som kan roteres til presise vinkler i henhold til behovet til en bestemt applikasjon. Det kan gjøres ved å bruke en beregnet kommando på de aktuelle inngangene til motoren for å produsere en nøyaktig rotasjons- eller svingevinkel innen motorens 180 grader.

Vanligvis har en servomotor tre ledninger eller innganger. De positive ledningene er vanligvis røde i fargen, den negative eller jordede ledningen er svart, som kommandotråden eller signaltråden vanligvis er hvit eller gul i fargen.

Arduino muliggjør servomotorkontroll gjennom innebygd støttespråk som gjør kontroll veldig praktisk og ideell for servomotorer.

Følgende eksempel viser oss det grunnleggende oppsettprogrammet for implementering av servomotorstyring gjennom Arduino:

Koden er gitt nedenfor:

#include Servo servo1 const int kPinPot = A0 const int kPinServo1 = 9 void setup() { servo1.attach(kPinServo1) } void loop() { int val = analogRead(kPinPot) val = map(val, 0, 1023, 0, 180) servo1.write(val) delay(15) }

Vi kan se et par nye oppføringer her. En som forteller den festede ledningen til servoen til hvilken pin den er tildelt. Den andre er koden som gir pinnen en verdi mellom 0 og 180 for å bestemme rotasjonsvinkelen på servoen.

Konklusjon

Arduino-emnet kan være uendelig langt, og derfor utenfor omfanget av denne artikkelen. Imidlertid håper jeg ovennevnte opplæringen absolutt burde hjulpet deg med å lære det grunnleggende om Arduino, og forstå viktige parametere gjennom de forskjellige eksemplene på applikasjonskoder.

Forhåpentligvis kan mer informasjon oppdateres fra tid til annen her, når den er tilgjengelig.

I mellomtiden kos deg med programmeringskurset ditt, Happy Arduinoing to you !!

Forrige: Alkoholdetektormålerkrets ved bruk av MQ-3 sensormodul Neste: Mobiltelefonstyrt hundematerkrets