Learning Basic Arduino Programming - Tutorial for the Newcomers

I denne vejledning lærer vi, hvordan man laver grundlæggende Arduino-programmering gennem eksempelkoder og prøveprogrammer. Denne vejledning kan være et yderst værdifuldt kursus for alle de nyankomne, der ønsker at forstå det grundlæggende gennem et let, forståeligt sprog.

Introduktion

Ifølge wikipedia en mikrocontroller svarer til en mini-computer, der er indbygget i en enkelt IC-chip, der har sin egen kerneprocessor, programmerbare indgange, hukommelse og outputudstyr.

En mikrocontroller bliver så nyttig for en bruger, da den tilbyder en indbygget processor, hukommelse og input / output-porte (også kaldet GPIO eller input / output-pins til generelle formål), som vi kan styres af brugeren i henhold til de ønskede specifikationer.

I denne vejledning arbejder vi med et Arduino Uno-kort til indlæring og test af programmerne. Til test og integrering af hardware-samling bruger vi et breadboard.

Lad os nu bevæge os hurtigt og lære at komme i gang med en Arduino-programmering.

1.2 Installation af softwaren (Windows)

Til dette har du brug for adgang til internet, som du naturligvis ville have på din computer. Gå til følgende link og download IDE-softwaren:

Windows ZIP-fil til installation uden administrator

Efter download finder du installationsikonet til Arduino i downloadmappen, som ser sådan ud:

Når du først har fået dette, kan du blot dobbeltklikke på det og installere Arduino the Integrated Development Environment (IDE) på din computer. Den komplette proces kan visualiseres i følgende video:

1.4 Starter med vores første kredsløb

Før vi begynder at lære de faktiske programmeringsteknikker, ville det for enhver nybegynder være nyttigt at begynde med en grundlæggende komponent såsom en LED og forstå, hvordan man forbinder den med en Arduino.

Som vi ved er en LED en lysdiode, der har en polaritet og ikke lyser, hvis den ikke er forbundet med de rigtige forsyningspoler.

Et andet aspekt ved lysdioder er, at disse enheder fungerer med lav strøm og kan blive beskadiget med det samme, hvis en passende beregnet modstand ikke er inkluderet i serie med en af ​​dens ben.

Som en tommelfingerregel er en 330 ohm 1/4 watt ret ideel til hver 5V stigning i forsyningsindgangen for at begrænse strømmen til et krævet sikkert niveau. Derfor kan det for 5V være 330 ohm, for 10V kan det være 680 ohm og så videre.

Brug af brødbræt til samlingen

Sørg for, at du ved, hvordan du bruger en brødbræt inden du prøver den tutorial, der er forklaret i dette kapitel, da vi ville bruge et brødbræt til alle eksperimenterne her.

Den grundlæggende LED-forbindelsesopsætning kan ses nedenfor:

Du kan se 3 grundlæggende komponenter ovenfor:

1. En 5mm, 20mA LED
2. en 330 ohm 1/4 watt modstand
3. An Arduino Board

Saml bare systemet i henhold til diagrammet.

Tilslut derefter 5V fra USB-computer til Arduino. Så snart du gør dette, vil du se, at LED'en lyser op.

Jeg ved, det er ret grundlæggende, men det er altid godt at starte fra bunden. Vær sikker på at tingene begynder at blive mere og mere interessante, når vi går videre.

1.5 Kontrollerende LED med Arduino

Nu lærer vi at styre en LED med et Arduino-program.

For at skrive et program skal vi have mindst 2 funktioner i hvert program.

En funktion kan forstås som en række programmeringsudsagn, der kan tildeles et navn som angivet nedenfor:

1. Opsætning() dette kaldes eller udføres under programmets start.
2. løkke () dette kaldes eller udføres gentagne gange i hele Arduino's operationelle periode.

Derfor, selvom det muligvis ikke har nogen praktisk funktionalitet, kan teknisk set et korteste legitime Arduino-program skrives som:

Enkleste program

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

Du har måske bemærket, at systemet på mange af programmeringssprogene begynder med at vise et enkelt print, 'Hello, World' på displayskærmen

Den elektroniske ækvivalent for denne sætning i mikrokontrollerfortolkning er at blinke en LED TIL og FRA.

Dette er det mest basale program, man kan skrive og implementere for at indikere, at systemet fungerer korrekt.

Vi forsøger at implementere og forstå proceduren gennem følgende stykke kode:

Liste 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, lad os nu forstå, hvad hver linje i koden betyder, og hvordan det fungerer til at udføre funktionen:

const int kPinLed = 13

Dette fungerer som en konstant, der giver os mulighed for at bruge det under det komplette programmeringskursus uden behov for at bruge den aktuelle værdi, der er indstillet på den.

I henhold til standardreglerne genkendes sådanne konstanter med startbrevet til . Selvom dette ikke er obligatorisk, gør det tingene klarere og let forståelige, når du har lyst til at gennemgå kodedetaljerne.

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

Denne kode konfigurerer den specifikke pin, som vores LED er tilsluttet. Med andre ord fortæller koden Arduino at styre 'skrive'-aspektet på denne pin i stedet for at' læse 'det.

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

Ovenstående linjer angiver den faktiske udførelse af applikationen. Koden begynder med at skrive og gengive en HIGH ud på den relevante LED-forbindelse og tænde LED'en.

Her betyder udtrykket HIGH simpelthen at få + 5V på den berørte pin af Arduino. Det supplerende udtryk LAV indikerer simpelthen et nul eller 0V på den udpegede pin.

Dernæst kalder vi delay() hvis funktion er at skabe en forsinkelse gennem millisekunder (1/1000 sekund). Da tallet 500 er indtastet, vil den implementerede forsinkelse være i et 1/2 sekund.

Så snart dette 1/2 sekund er bortfaldet, udføres den næste linje, der slukker for LED'en med LOW-termen på den samme pin.

Den efterfølgende linje genererer igen 1/2 sekunders forsinkelse for at lade LED'en forblive slukket i 1/2 sekunder.

Og processen fortsætter uendeligt med udførelsen af ​​kodelinjerne, så længe Arduino holdes drevet.

Før jeg fortsætter til det næste niveau, vil jeg anbefale dig at programmere ovenstående kode og kontrollere, om du er i stand til at implementere LED ON / OF-sekvensen korrekt eller ej.

Da standard-LED'en i Arduino er forbundet med pin nr. 13, skal den straks reagere på ovenstående program og begynde at blinke. Men hvis du finder ud af, at din eksterne LED ikke blinker, kan der være en forbindelsesfejl med din LED, kan du prøve at vende polariteten på din LED og forhåbentlig også se, at den blinker.

Du kan spille med forsinkelsestiden ved at ændre '500'-figuren til en anden værdi og finde LED'en' lytte 'til kommandoerne og få den til at blinke i henhold til de angivne forsinkelsesværdier.

Men husk, hvis du ser, at LED'en ikke blinker med en konstant hastighed på 1 sekund, uanset din forsinkelsestidsændring, kan det indikere, at koden ikke fungerer på grund af en eller anden fejl. Fordi Arduino som standard programmeres med en blinkende hastighed på 1 sekund. Derfor skal denne sats varieres efter din kode for at bekræfte, at den fungerer korrekt.

1.7 Kommentarer

Linjerne med koder, som vi forstod ovenfor, blev specifikt skrevet til computersoftwaren.

For at sikre, at brugeren er i stand til at henvise betydningen af ​​linjerne og forstå dem, kan det ofte være nyttigt og fornuftigt at skrive forklaringen ved siden af ​​de ønskede kodelinjer.

Disse kaldes kommentarer som kun er skrevet til menneskelig eller brugerreference og er kodet for at gøre det muligt for computere at ignorere det sikkert.

Sprog i disse kommentarer er skrevet i et par formater:

1. Blokformatet for kommentaren, hvor kommentarbeskrivelsen er lukket under startsymbolet / * og slutningssymbolet * /
2. Dette behøver ikke at være begrænset i en linje, men kunne udvides til de næste efterfølgende linjer afhængigt af længden af ​​kommentaren eller beskrivelsen, som vist i følgende eksempel:

/ * Dette er en kommentar * /

/ * Så er dette * /

/ * Og
* det her
* som
* godt */

For at skrive en hurtig beskrivelse af en enkelt linje til en kommentar bliver to skråstreg // symbol i starten tilstrækkelige. Dette fortæller computeren, at denne linje ikke har noget at gøre med den aktuelle kode og skal ignoreres. For eksempel:

// Dette er en kommentar, som computere vil ignorere.

Her er et eksempel til reference:

/*
* 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 Fejlfinding

Hvis du finder ud af, at dit program viser en 'fejl' under kompilering eller et andet problem, vil følgende tip sandsynligvis hjælpe dig med at kontrollere din kode igen med at slippe af med forhindringen.

1. Dit programsprog er store og små bogstaver. For eksempel udtrykket myVar kan ikke skrives som MyVar.
2. Alle slags hvide mellemrum, der kan udføres af dit tastatur, bliver i sidste ende gengivet som et enkelt mellemrum, og det er kun synligt eller forstået af dig, computeren tager ikke dette i betragtning. Enkelt sagt vil ledige rum af enhver art ikke have nogen indvirkning på koderesultaterne.
3. Hver blok kode skal være lukket med venstre og højre krøllede parenteser, '{' og '}'
4. Talcifre skal ikke adskilles med kommaer. For eksempel kan 1000 ikke skrives som 1.000.
5. Hver kodelinje, der er lukket mellem de krøllede parenteser, skal slutte med et semikolon

Oprettelse af interessant LED-lyssekvens med Arduino

I vores forrige kapitel lærte vi, hvordan man kontinuerligt blinker en LED TIL / FRA med en konstant forsinkelseshastighed.

Nu lærer vi, hvordan forskellige forsinkelsesmønstre kunne udføres på den samme LED ved at opgradere programkoden.

Vi bruger ikke en ekstern LED, snarere bruger vi standard-LED'en, der er indbygget i Arduino-kortet på pin nr. 13. Du kan finde denne lille SMD LED lige bag USB-stikket.

2.2 Forståelse af IF-udsagn

I dette afsnit lærer vi, hvordan kontrolstrukturer gør det muligt for os at køre individuelle koder og engang endda gentagne gange efter behov.

Erklæringen hvis bliver den første kontrolstruktur. Følgende implementering viser, hvordan den bruges:

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 at forstå ovenstående kode trinvis og lære, hvordan dette kan bruges til andre lignende henrettelser.

Koderne mellem 1. og 7. linje svarer nøjagtigt til vores oprindelige program.

Den første ændring sker faktisk på 8. linje.

int delayTime = 1000

Du kan finde ud af, at dette svarer til koden på 1. linje, uden at det mangler udtrykket konst.

Dette er simpelthen fordi denne kode ikke er en konstant. I stedet defineres dette som en variabel , som har egenskaben af ​​en variabel værdi i løbet af programmeringen.

I eksemplet ovenfor kan du se, at denne variabel tilskrives en værdi på 1000. Husk, at sådanne variabler, der er lukket inden for krøllede parenteser, kun skal skrives inden for par krøllede parenteser og betegnes som 'lokale' variabler.

Alternativt anerkendes variabler, som formodes at være uden for krøllede parenteser, som den, vi diskuterer nu, som 'globale' og kunne udføres næsten hvor som helst inden for en programkode.

Når du går videre, kan du se, at koder mellem linje 9 og 11 også ligner det første program, alligevel begynder tingene at blive interessante efter linje 11. Lad os se hvordan!

delayTime = delayTime - 100

I denne kode ser vi, at standardværdien af forsinkelse ændres ved at trække 100 fra den.

Betydning 100 trækkes fra sin oprindelige værdi på 1000, hvilket giver den en ny værdi på 900.

Gennem det følgende billede vil vi forsøge at forstå et par af de matematikoperatører, der bruges på Arduino-sprog.

Lad os nu vurdere koderne mellem linje 13 og 15.

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

Hovedformålet med ovenstående stykke kode er at sikre, at LED'en fortsætter med at blinke uden afbrydelse.

På grund af det faktum, at 100 trækkes fra originalen forsinkelse , forhindrer det, at LED-lampen blinker fra at komme til nul, og gør det muligt at blinke konstant.

Følgende billede viser et par sammenligningsoperatører, som vi ville bruge i vores koder:

I vores ovenstående kode kunne vi have testet koden til at være if(delayTime == 0).

Men fordi det at være negativt kan være lige så dårligt, gik vi ikke efter det, og dette er en anbefalet praksis.

Tænk hvad der kunne have været resultatet, hvis vi havde forsøgt at trække 300 i stedet for 100 fra delayTime

Så nu har du måske indset, at hvis delayTime er skrevet som mindre eller lig med nul, så vil forsinkelsestiden blive sat tilbage til det oprindelige tal 1000.

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

De sidste 4 linjer i koden som vist ovenfor bliver ansvarlige for at tænde / slukke for LED, ON / OFF kontinuerligt.

Her kan du tydeligt bemærke, at i stedet for at bruge et antal tal, har vi brugt en variabel til at tildele forsinkelsestiden, så vi kan justere den, som vi ønsker, i kodenes operationelle periode. Det er sejt, ikke?

2.3 ELSE-erklæringer

Her lærer vi hvorfor og hvordan en hvis term kan have en klausul andet så det afgør situationen i sagen hvis udsagn er falsk.

Jeg er ked af, hvis det lyder for forvirrende, skal du ikke bekymre dig, vi prøver at 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 ovenstående kan du godt se, at i den 10. linjekode kun udføres, når delayTime er mindre eller lig med 100, hvis ikke så udføres koden i den 13. linje, men begge sammen kan aldrig ske, hverken den 10. linje eller den 13. linjekode vil blive implementeret, aldrig begge.

Du har måske bemærket, at i modsætning til hvad vi gjorde i vores forrige afsnit 2.2, her sammenlignede vi ikke med 0, snarere sammenlignet med 100. Dette skyldes, at i dette eksempel sammenlignet FØR vi trak 100, modsat i afsnit 2.2, sammenlignede vi EFTER at vi trukket fra. Kan du fortælle, hvad der kunne være sket, hvis vi havde sammenlignet 0 i stedet for 100?

2.4 HVILKE udsagn

TIL mens udsagn er meget lig hvis udsagn, bortset fra sandheden, at det forårsager gentagen udførelse af en blok kode (som kan være mellem krøllede parenteser) så længe betingelserne er gældende, og dette fungerer uden en andet udmelding.

Følgende eksempel hjælper dig med at 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 gætte, hvad ovenstående kode er programmeret til at gøre? Nå, det er designet til at blinke LED hurtigere og derefter langsommere.

2.5 Hvad er sandt og falsk?

På programmeringssprog, falsk henviser til nul (0). Faktisk bruges 'sand' ikke, men i stedet antages det, at når intet er falsk, er alt, hvad der er inkluderet, sandt.

Det ser lidt underligt ud, men det gør jobbet ret pænt.

Vi prøver at forstå situationen gennem følgende eksempel.

Du kan undertiden støde på en kode som angivet nedenfor:

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

Dette er kodet ser ud til, at LED-udførelsen fortsætter med at cykle for evigt, da der er lang strøm til rådighed.

Imidlertid kan en ulempe ved denne type kode opstå, når brugeren ved et uheld anvender a = i stedet for ==.

Jeg er sikker på, at du allerede ved, at = betyder en opgave, hvilket betyder, at den bruges til at betegne en valgt værdi til en variabel, mens a == bruges til at håndhæve en test, hvis værdien var den samme.

Antag for eksempel, at du har krævet, at en LED blinker med et sekventielt hastighedsmønster og gentagne gange, men ukorrekt brugte en = i stedet for ==.

Koden vises derefter 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
}

Fejlen tildeler 0 til delayTime og fører til hvis erklæring for at kontrollere, om 0 var sandt eller ej. Da 0 refererer til falsk, vil det tro, at det ikke er sandt, og vil stoppe håndhævelsen af ​​delayTime = 1000, men i stedet funktionen delayTime holdes ved 0 i løbet af loop ().

Dette ser meget uønsket ud !!

Så tjek altid dit program altid for at sikre, at du ikke har lavet sådanne fjollede fejl.

2.6 Kombinationer

Nogle gange kan du føle behovet for at teste flere ting sammen. Som du måske vil undersøge, om en variabel var mellem to tal. Selvom dette kan implementeres ved hjælp af if-sætningen flere gange, kan det være mere praktisk at bruge logiske kombinationer til bedre og lettere læsning.

Implementering af kombinationer på logiske vilkår kunne gøres med 3 metoder, som vist i følgende tabel:

Det ville være interessant at vide, at NOT-operatøren kan arbejde som switcher for en variabel, der kan betegnes som en af ​​dem sand eller falsk (eller LAV eller HØJ).

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 derefter, så snart ledState = !ledState, bliver den HØJ. Den følgende sløjfe vil medføre ledState at være HØJ, når ledState = !ledState er lavt.

2.7 FOR erklæringer

Nu vil vi forsøge at forstå om en anden kontrolstruktur, som er en til løkke. Dette kan være meget praktisk, når du vil implementere noget flere gange.

Lad os 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 finde noget unikt i tråd med til.

Det er koden jeg ++? . Dette er nyttigt for programmører, der er ret dovne og ønsker at implementere kodning gennem praktiske genveje

Ovenstående betegnelse er kendt som sammensatte operatører, da de gør jobbet med at kombinere en tildelingsoperatør med en anden tildelingsoperatør. De mest populære af disse kan visualiseres i følgende tabel:

Du finder ud af, at der er 3 underudsagn i en for-erklæring. Den er struktureret som vist nedenfor:

for (statement1conditionstatement2){
// statements
}

Erklæringen nr. 1 forekommer lige i starten og kun en gang. Tilstanden testes hver gang i løbet af løkken. Når det er sand inden i krøllede parenteser bliver den efterfølgende erklæring nr. 2 håndhævet. I tilfælde af en falsk, systemet springer til den næste blok kode.

Tilslutning af flere lysdioder

OK, nu ser vi, hvordan vi kan forbinde flere antal LEds for at få mere interessante effekter.

Forbind venligst lysdioderne og Arduino som vist nedenfor. Den røde ledning er faktisk ikke nødvendig, men da det altid er en god idé at have begge forsyningsskinner inkluderet i brødbrættet, giver opsætningen mening.

Lad os nu rette et program, der gør det muligt for os at kontrollere, om vores hardware er korrekt konfigureret eller ej.

Det anbefales altid at kode og udføre små bits af programmer trinvis for at kontrollere, om de respektive hardwares er tilsluttet korrekt eller ej.

Dette hjælper med at fejlfinde en mulig fejl hurtigt.

Kodeeksemplet nedenfor giver LED 2 til 5 et specifikt mønster ved at dreje dem efter hinanden på en cyklisk måde.

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 måske bemærker, er der ikke noget galt med koden, undtagen det faktum, at den ser lang ud og derfor er tilbøjelig til fejl.

Der er selvfølgelig bedre måder at skrive ovenstående kode på, det følgende afsnit afslører det.

2.9 Introduktion af arrays

Arrays kan være en gruppe af variabler, som kan indekseres med indeksnumre. Følgende eksempel hjælper os med at 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, lad os nu gennemgå hvert afsnit og forstå, hvordan de rent faktisk fungerer.

const int k_numLEDs = 4

Ovenstående kode definerer, hvor mange maksimale elementer vi skal have i arrayet. Denne kode hjælper os i de efterfølgende sektioner med at sikre, at alt er skrevet inden for et array og intet, når arrayet slutter.

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

I denne næste linje opretter vi array-strukturen. Tallene inde i parentes angiver antallet af elementer i arrayet. Skønt den faktiske mængde kunne være skrevet, fungerer skrivning som konstanter bedre. Værdierne kan normalt ses inden for parentes med kommaer og angive værdierne til arrayet.

Når du finder et array indekseret med tallet 0, angiver dette det allerførste element i arrayet, som vist i code: k_LEDPins is k_LEDPins[0].

Tilsvarende vil det sidste element blive vist som k_LEDPins[3], da antallet fra 0 til 3 er 4.

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

Ovenstående kode viser brugen af ​​loop til at gå gennem hvert array-element og til at indstille dem som OUTPUTS. Vi implementerer firkantede parenteser sammen med indekset for at nå hvert af elementerne i arrayet.

hvis du spekulerer på, om det er muligt at bruge pin nr. 2 til pin nr. 5 uden arrays, er svaret ja, det er muligt. Men i dette eksempel gøres det ikke, fordi vi ikke gjorde det på den måde. I de følgende sektioner kan du fjerne array-tilgangen, hvis de valgte output-pins ikke er i linje.

Lad os se, hvad den næste kode kode gør:

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

Her fortsætter koden gennem hver af LED'erne for at tænde dem sekventielt med et mellemrum eller forsinkelse på 100 millisekunder.

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

Brug af ovenstående kode viser, hvordan anvendelsen af til løkke kunne bruges til at bevæge sig gennem løkken selv i omvendt rækkefølge.

Det begynder fra k_numLEDs - 1 fordi arrays er nulindekseret. Vi starter ikke fra k_LEDPins[4] fordi det ville resultere i at krydse finishen af ​​arrayet.

Koden bruger> = 0 til at kontrollere, så det første element i indeks 0 ikke går glip af eller ignoreres.

Kapitel 3

Hvad er en input

Så er vi lært, hvordan man betjener ting ved hjælp af Arduino. I dette kapitel vil vi diskutere, hvordan man fornemmer den virkelige verden ved at interfacere input fra eksterne parametre.

3.1 Brug af trykknapper

Vi ved alle, hvad en trykknap er, og hvordan den fungerer. Det er en slags switch eller knap, der forbinder et signal fra et kredsløbstrin til et andet kortvarigt, mens det er i deprimeret tilstand, og bryder signalet, når det frigives.

3.1.1 Én knap og en LED

Vi forbinder Arduino med en trykknap med Arduino ifølge ovenstående detaljer og lærer den grundlæggende funktion og implementering af opsætningen.

Den angivne trykknap, der også kaldes en mikrokontaktknap, har i alt 4 ben (2 par på hver side). Når der skubbes, er hvert par stifter forbundet internt og muliggør en forbindelse eller ledning på tværs af dem.

I dette eksempel bruger vi kun et par af disse ben eller kontakter, det andet par er irrelevant og ignoreres derfor.

Lad os fortsætte med at anvende følgende kode og tjekke 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 finde et par ting, der ser usædvanlige ud her. Lad os finde ud af dem trinvis.

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

Den første ting vi gør er at rette op på buttonPin som den INDGANG. Nå, det er ret grundlæggende, det ved jeg.

Derefter tildeler vi HØJ til INDGANG pin. Du undrer dig over, hvordan det kan være muligt at skrive noget ved input? Sikker på, dette kan være interessant.

Faktisk skifter tildeling af en HIGH til en Arduino-indgang en intern 20k Ohm pull-up-modstand TIL (en LOW på denne pin slår den fra).

Et andet spørgsmål, du måtte have, er, hvad der er en pull-up-modstand. Jeg har dækket et omfattende indlæg om pull-up modstande, som du lær det her .

OK, fortsæt, lad os nu se på hovedsløjfekoden:

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

Når du trykker på trykknappen, forbindes den kablede pin til jorden, hvilket gengiver en LAV til den pin. Og i ukomprimeret tilstand holdes den samme stift ved HØJ eller + 5V via 20K intern pull-up modstand.

Her vil vi have Arduino til at tænde LED'en, når der trykkes på trykknappen (LOW), derfor skriver vi HIGH for output for hvert svar fra et LOW fra trykknappen, mens den trykkes.

3.1.2 To knapper og en LED

Nå, du kan undre dig over, at ovenstående viste handling også kunne have været udført uden en Arduino. Jeg forstår dog dette er en stepping stone for at lære, hvordan trykknap kunne bruges med Arduno.

Indtil dette punkt har vi studeret skrivning af koder til enten at tænde (HIGH) eller at slå OFF (LOW) til en LED.

Lad os nu se, hvordan lysstyrken på LED kunne styres med en Arduino.

Det kan gøres ved hjælp af to metoder:

1. Ved at begrænse strømmen til LED
2. Ved hjælp af PWM eller pulsbreddemodulation, hvor forsyning til LED'en tændes / slukkes med en ønsket hastighed meget hurtigt, hvilket giver en gennemsnitlig belysning, hvis intensitet vil afhænge af PWM.

På et Arduino-kort fås PWM-understøttelse på ben markeret med en tilde (~), som er ben 3, 4,5,9,10 og 11) ved 500Hz (500 gange i sekundet). Brugeren er i stand til at give en hvilken som helst værdi mellem 0 og 255, hvor 0 refererer til ingen HIGH eller ingen + 5V, og 255 fortæller Arduino at få en HIGH eller + 5V hele tiden. For at starte disse kommandoer skal du få adgang til analogWrite () med den ønskede værdi.

Du antager muligvis, at PWM er x / 255, hvor x er den ønskede værdi, du vil sende via analogWrite()

Opsæt Arduino og andre parametre 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 finde 3 linjer her, der har brug for en forklaring.

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

Linjen: ledBrightness = constrain(ledBrightness, 0, 255) illustrerer en unik funktion inde i Arduino kendt som constrain ().

Denne interne funktion omfatter kode, der ligner følgende:

int begrænsning (int værdi, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Alle koder diskuteret før dette begyndte med ugyldig , hvilket betød ikke at returnere noget (ugyldigt). Mens ovenstående kode begynder med int , hvilket indikerer, at det returnerer et heltal. Vi diskuterer mere om i de senere afsnit, i øjeblikket skal du bare huske, at et heltal ikke har nogen brøkdele.

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

Den næste linje anvender analogWrite til kommandoer til Arduino om at anvende PWM på den valgte pin med den ønskede værdi.

Den næste linje skaber en forsinkelse på 20 millisekunder, dette er for at sikre, at vi ikke justerer spiste hurtigere end 50 Hz eller 50 gange i sekundet. Dette skyldes, at mennesker kan være meget langsommere end en Arduino. Derfor, hvis forsinkelsen ikke er foretaget, kan programmet få os til at føle, at ved at trykke på den første knap slukkede lysdioden og trykke på den anden knap tændte den (prøv det selv for at bekræfte).

3.2 Potentiometre

Lad os gå videre og lære at bruge potentiometre med Arduino.

For at vide, hvordan potentiometer eller en gryde fungerer, kan du læse dette artikel .

Forbind de viste parametre med din Arduino som vist ovenfor.

En gryde har 3 terminaler. Den midterste terminasl forbinder med ANALOG IN 0 på Arduino. De to andre ydre terminaler kan være tilsluttet + 5V og 0V forsyningsskinner.

Lad os programmere og tjekke resultaterne:

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 finder et par ting, der kan se helt nye ud og ikke inkluderet i nogen af ​​vores tidligere koder.

1. Konstanten kPinPot er tildelt som A0, hvor A er genvejen til at beskrive en af ​​de analoge ben. Imidlertid refererer A0 også til pin nr. 14, A1 til pin nr. 15 og så videre, og disse giver dig mulighed for at blive brugt som digitale indgange / udgange, hvis du løber tør for ben til et eksperiment. Men husk at du ikke kan bruge digitale ben som analoge ben.
2. Linjen: ledBrightness = map(sensorValue, 0, 1023, 0, 255) præsenterer en ny indvendig funktion i Arduino kendt som kort(). Denne funktion kalibrerer igen fra et givet interval til et andet, betegnet som kort (værdi, fromLow, fromHigh, toLow, toHigh). Dette kan blive afgørende, da analogueRead giver en værdi inden for området 0-1023, men analogWrite er i stand til at acceptere en værdi fra 0-255.

Du tror måske, at da det er muligt at kontrollere lysstyrken på en LED gennem en skiftende modstand, kunne simpelthen en gryde have været tilstrækkelig til formålet, hvorfor brugen af ​​Arduino. Nå, det er igen kun grundlaget for at vise, hvordan en gryde kunne konfigureres med en Arduino.

Ingen problemer, nu gør vi noget, der ikke kan gøres uden en Arduino.

I dette eksperiment vil vi se, hvordan en grydes varierende modstand kan bruges til at kontrollere en LEDs blinkhastighed eller hastighed.

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 Undgå forsinkelse ()

Ovenstående kode ser godt ud, men LED'en kan ikke kontrollere potværdien, før den går gennem hver fulde cyklus. Ved længere forsinkelser bliver denne proces længere, brugeren skal vente med at se puljesvaret, mens han bevæger det. Denne forsinkelse kan undgås med en vis intelligent programmering, så det giver brugeren mulighed for at kontrollere værdien uden 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å hvad er der anderledes i ovenstående kode? Det er den følgende linje, der gør forskellen.

long lastTime = 0

Indtil dette afsnit har vi diskuteret om variablen int. Der kan dog være mange flere typer variabler, som du kan få adgang til. Listen kan læses nedenfor:

I øjeblikket kan det kun være afgørende at vide, at til lagring af relativt stort antal til int variabel, kan du bruge udtrykket lang eller a lang int.

Her kan du se en anden interessant funktion kaldet millis ().

Dette producerer den tidsperiode i millisekunder, som Arduino arbejdede i sin løbetid fra starten (dette nulstilles til 0 efter hver 50 dag). Her vender det tilbage længe, ​​for hvis det vendte tilbage int , tælling i lange perioder er muligvis ikke mulig. Kan du svare nøjagtigt hvor længe? Svaret er 32,767 sekunder.

Derfor kontrollerer vi for millis (), i stedet for at bruge forsinkelse (), og så snart det bestemte antal millisekunder bortfalder, skifter vi LED. Derfor gemmer vi den tid, vi ændrede den sidst i sidste gang variabel, så det giver os mulighed for at kontrollere det igen, når det ønskes.

3.3 RGB-lysdioder

Indtil videre har vi spillet med en enkeltfarvet LED. Selvom LED-farve kunne ændres ved at erstatte LED med en anden farve, men hvad med at bruge RGB-LED'er? for at skifte LED-farver uden at skifte lysdioder?

En RGB-LED er dybest set en LED, der har en rød, grøn og blå LED indlejret og flettet i en enkelt LED. Den har en fælles ledning, der går til jorden eller 0V forsyningsskinne, mens de andre 3 ledninger fodres med diversificerede PWM positive signaler til implementering af den tilsigtede farve blanding .

Du kan tilslutte opsætningen som vist nedenfor:

Det kan se lidt kompleks ud, men faktisk er det en replika af vores tidligere LED-kontroldesign ved hjælp af PWM.

Her er en øvelsesprogramkode:

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)
}

Efter uploaden af ​​denne kode skal du bare se, hvordan pottejusteringerne skaber interessant lyseffekt på RGB, det kan være rigtig sjovt.

Du vil opdage, at når alle de 3 gryder flyttes maksimale positioner, i stedet for en hvid farve, vil du se rødt. Dette skyldes, at rød farve er den mest fremtrædende blandt de 3 farver og derfor dominerer i denne situation. Du kan dog eksperimentere med funktionen kort() , før den udføres til den røde del af LED'en for at skabe en mere fornuftig balance.

Audio med Arduino

I dette afsnit lærer vi, hvordan du tilføjer grundlæggende lyd og musik til en Arduino-opsætning.

Vi vil se, hvordan man skifter et signal til en tilsluttet højttaler med den ønskede frekvens.

For at være mere præcis vil en mellem A-note blive prøvet, hvilket er en 440 Hz-frekvensnote.

For at gøre dette spiller vi simpelthen en midterste A-note og optimerer sinusbølgesignalet med firkantbølge.

Vi beregner også hvor lang tid en højttaler kan forblive tændt ved at sagsøge formlen:

timeDelay = 1 second / 2 x toneFrequency.

timeDelay = 1 second / 2 x 440

timeDelay = 1136 microseconds

4.1 Lad os tilslutte Arduino Board

4.2 Tilføjelse af en simpel note

Vi har allerede diskuteret om funktionen forsinke() hvor enheden er i millisekunder (sekund / 1000), vil du dog finde endnu en funktion delayMicroseconds() hvor enheden er i mikrosekunder (millisekund / 1000).

Til den nuværende opsætning programmerer vi en kode til at tænde / slukke for + 5V på den valgte pin, der er forbundet med højttaleren, med en hastighed på 440 impulser pr. Sekund.

Husk, i den sidste diskussion bestemte vi værdien 1136 mikrosekund for den tilsigtede lydnote.

Så her er programmet til dette, som giver dig mulighed for at høre en lydnote på 440 Hz, så snart du programmerer arduino med en tilsluttet højttaler.

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 ovenstående applikation er det muligt at lave en lydnote, hvilket også betyder, at vi kan oprette en musik efter eget valg.

Fra koden forstår vi, at Arduino inkluderer et par integrerede funktioner, der desuden bidrager til skabelsen af ​​musik.

Den første er tone() der fungerer med 2 elementer sammen med et 3. valgfrit element, der er udpeget som tone (pin, frekvens, varighed). eller tone (pin, frekvens)

Begge er udpeget til at udføre henholdsvis den tidsperiode, du har tildelt.

I mangel af en tidsperiode fortsætter musikken med at afspille indtil opkaldet tone() udføres igen, eller indtil du udfører ikke en ().

Dette skal gøres ved hjælp af en forsinkelsesfunktion, hvis musikafspilning er den eneste grundlæggende ting, du implementerer.

Tidsvarigheden kan være afgørende, da det giver mulighed for at give en tid til, hvor længe musikken afspilles, så kan du frit gøre andre ting. Så snart varigheden er bortfaldet, stopper musikken.

Den næste funktion ikke en () håndterer en enkelt parameter og stopper den valgte tone på en bestemt tildelt pin.

En ejendommelig advarsel: Når som helst tone() funktion implementeres, stopper PWM-funktionen på pin 3 og 11 med at fungere.

Derfor, hver gang der bruges en højttalertilslutning i programmet, skal du sørge for ikke at bruge den nævnte pin til højttalerne, men i stedet prøve nogle andre ben til højttalertilslutningen.

OK, så her er programmet til implementering af musik på en højttaler, selvom det ikke er en ægte musik, snarere en basisskala 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 ovenstående kode har du måske bemærket noget nyt, og det er det #Definere .

Dette udtryk fungerer som en kommando til søgning og erstatning til computeren, mens kompilering udføres.

Når den finder den første ting inden et mellemrum, erstatter den den med den resterende del af linjen (kaldet makroer).

Så inden for dette eksempel når computeren ser BEMÆRK_E4 det erstatter det hurtigt med mængden 330.

For flere noter og tilpasning kan du henvise til en fil på din USB-stick med navnet pladser.h , hvor de fleste af frekvenserne kunne findes efter dine præferencer.

4.4 Musik med funktioner

Koden ovenfor ser godt ud, men ser ud til at have mange gentagelser, der skal være en metode til at forkorte disse gentagelser, ikke?

Indtil videre har vi arbejdet med to vigtige funktioner inkluderet i Arduino. Nu kan det være på tide, at vi opretter vores egne funktioner.

Hver funktion skal begynde med den type variabel, den kan være tilknyttet. For eksempel funktionen ugyldig henviser til type, der ikke returnerer noget, deraf navnet ugyldigt. Bemærk, vi har allerede diskuteret en liste over variabler i vores tidligere sektioner, du vil måske henvise dem.

Derfor får det bestemte funktionsnavn en åben parentes '(' efterfulgt af en liste med komma-adskilte parametre.

Hver af parametrene erhverver sin type sammen med et navn og til sidst en lukning ')' parentes.

Disse parametre kan anvendes inden for funktionen i form af variabler.

Lad os se et eksempel nedenfor, hvor vi udvikler en kaldet funktion ourTone () designet til at fusionere tone() med forsinke() linjer, på en måde som funktionen stopper med at vende tilbage, indtil tonen er afsluttet med at afspille tonen.

Vi implementerer disse funktioner i vores tidligere kode og får nedenstående program, se de sidste linjer:

#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)
}
void ourTone(int freq, int duration)
{
tone(kPinSpeaker, freq, duration)
delay(duration)
}

Funktioner kan være ekstremt praktiske for at gøre et program lettere at forstå.

Følgende er et eksempel, hvor vi er i stand til at specificere det valg af tone, vi vil spille ved hjælp af to arrays. Et array til at bevare noterne, det andet til at bevare beats.

#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 tydeligt se introduktionen af ​​på første linje #omfatte udmelding. Opgaven med denne erklæring er at samle hele filen mellem citaterne og placere den i positionen for #omfatte udmelding. I henhold til standardreglerne er disse strengt placeret i starten af ​​programmet.

Kapitel 5

Måling af temperatur

Bare husk, i stedet for at skrive store programmer helt, er det altid klogt at skrive og analysere små dele af koder, hvilket hjælper med at spore fejl hurtigt.

5.1 Seriel skærm

Indtil nu ser de koder, vi diskuterede, ikke så let ud til at muliggøre hurtig fejlfinding. Her forsøger vi at gøre tingene lettere for overvågning og lettere løsning af et muligt problem.

Arduino har en funktion, der gør det muligt at 'tale tilbage' med computeren. Du kan blive observeret, at pin0 og pin1 er markeret som RX en TX ved siden af ​​hinanden. Disse ben spores faktisk af en separat IC i Arduino, som opgraderer dem til at læse hen over USB-kablet, mens det er tilsluttet pc'en.

Nedenstående afsnit viser et fuldt udbygget program. Gå dog igennem det, vi lærer om de nye poster i koden derefter. Denne kode er den samme som udtrykt i afsnit 2.2 bortset fra, at den indeholder nogle ekstra data, der giver os mulighed for at identificere, hvad den er kodet til.

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 identificere to nye ting her, en ny linje i Opsætning() fungere.

Serial.begin(9600)

Denne linje udtrykker simpelthen nødvendigheden af ​​at bruge Seriel1 kode for at håndhæve den med 9600 baud. (her seriel henviser til bits sendes efter hinanden, og baud betyder den hastighed, hvormed den sendes). Denne baudværdi og den inde i den serielle skærm (vi lærer dette senere) skal være ens, ellers vil dataene i den serielle skærm vise affald. 9600 er standarden, bliver mere praktisk at bruge.

Den anden nye post er som følger

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

Her foreslår den anden linje, at den efterfølgende ting, der kommer ud fra den serielle port, starter på den næste linje. Sådan adskiller den anden linje sig fra knytnævelinjen.

En ting mere, du kan se, er citater ('). Dette er kendt som en streng, der kun bruges som konstanter her, fordi yderligere diskussion om dette emne kan være for omfattende og uden for anvendelsesområdet.

OK, vi kan nu uploade ovenstående kode i Arduino og se, hvad der sker.

Hvad, der ser ikke ud til, at der er sket noget, Arduino pin # 13 LED blinkede og stoppede, mens Tx LED forblev blinkende.

Det skyldes, at Serial Monitor-vinduet ikke er rettet endnu.

Du skal klikke på boksen Seriel skærm i din IDE som vist ovenfor. Glem ikke at kontrollere baudhastigheden nederst til højre, som standard skal den være 9600 og vil matche koden. Hvis det ikke er tilfældet, skal du vælge 9600.

Følgende videoklip forklarer, hvordan det gøres.

Lad os nu gå videre og lære, hvordan ovenstående Serial Monitor-funktion kan hjælpe med at behandle måling af temperatur ved hjælp af Arduino

Vi bruger IC TMP36 som temperatursensor med et interval på -40 til 150 grader Celsius.

Opsætningen kan ses nedenfor:

Den følgende kode starter måling af temperatur ved at aflæse output fra TMP36-sensoren og ved at sende dem til den serielle skærm på ID'et.

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
}

Lad os forstå koden fra toppen.

float temperatureC = getTemperatureC()

Her kan du se, at vi har inkluderet variabeltypen flyde.

Dette er den eneste variabeltype, der indeholder lagring af alt undtagen heltal (tal uden decimal- eller brøkdele).

Nøjagtigheden fra en flydevariabel kan være op til 6 til 7 cifre.

Den tilstødende kode getTemperatureC() er vores egen funktion, der matematisk beregner og konverterer den registrerede spændingsforskel 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 det næste afsnit af koderne, siden udtrykket analogIn() er tildelt til at returnere et tal mellem 1 og 1023, bliver det muligt for os at vurdere spændingen fra sensoren ved at gange vores måling med 5 og derefter dividere den med 1024.

Sensoren TMP36 er specificeret til at generere en 0,5 V ved 0 grader Celsius og genererer derefter 10 mV for hver enkelt stigning i grad Celsius.

Her er den tilnærmelse, som vi er i stand til at generere gennem beregningerne:

Du kan overveje at være din første funktion, der returnerer en værdi (bemærk, at alle de resterende funktioner hidtil ikke returnerede nogen værdi, da de har været af typen ugyldig ).

Du kan forstå, at du bare skal tilføje for at få en værdi fra en funktion Vend tilbage efterfulgt af det ønskede nummer, du vil returnere.

Når vi siger Vend tilbage det betyder, at funktionen returnerer et svar eller et svar, når det kaldes, hvilket kan anvendes på en variabel.

Når dette sendes til Serial Monitor, konverteres læsningen til Fahrenheit igennem convertToF ().

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

Denne funktion opfanger Celsius-serien og konverterer den til Fahrenheit.

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

5.3 Interfacering af et LCD-display

Lad os nu studere, hvordan man grænseflade eller forbinder en LCD-skærm med Arduino til visuel visning af de krævede output.

I vores applikation skal vi anvende en 84x48 grafisk LCD med en 84 pixel eller prikker vandret og 48 pixels lodret opløsning. Da en dedikeret controller bliver bydende nødvendig for alle LCD-skærme, indeholder den nuværende enhed også en i form af PCD8544-controller.

I denne vejledning forbinder vi det ovennævnte LCD-modul med Arduino og anvender visse rutiner til at oprette tekstbeskeder på skærmen.

I den følgende figur kan du finde detaljer vedrørende grænsefladen mellem LCD og en lille 3,3 V spændingsregulator . Denne regulator er nødvendig, da LCD'en er specificeret til at arbejde med en 3,3 V forsyning.

Du kan også se 8 pinouts fra LCD-modulet, pinout-specifikationerne kan studeres fra følgende tabel:

Lad os nu se, hvordan vi kan forbinde LCD-skærmen og de relevante parametre med vores Arduino. Detaljerne kan visualiseres i nedenstående viste illustration:

5.4 Kommunikation til LCD'et

Selvom det er muligt at skrive detaljerede coeds til interaktion med LCD fra Arduino, lærer vi snarere, hvordan man gør det samme ved hjælp af biblioteker.

Biblioteker består af et udvalg af koder, der hurtigt kan anvendes til et valgt Arduino-program.

Dette gør det muligt for brugeren at ringe til en funktion uden besvær uden at skulle gennemgå komplekst kodningsarbejde.

5.4.1 Sådan installeres biblioteket

Til dette bliver du nødt til at oprette et bibliotek kaldet biblioteker på din computer Arduino IDE, som forklaret her

5.4.2 Implementering af LCD-funktionerne

Ligesom vores tidligere tilgang vil vi først tjekke hele koden og derefter prøve at forstå detaljerne i de enkelte linjer.

#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 pålægger pc'en at afhente den nævnte fil og erstatte #include-elementet med filindholdet i løbet af kompilering af programmet.

Elementet # inkluderer kan have vinkelparenteser, som angiver søgning i biblioteksbiblioteket, alternativt kan det også have anførselstegn, der angiver søgning i samme bibliotek, som programmet er placeret i.

De efterfølgende kodelinjer udtrykker LCD pinouts, og så skriver vi en ny form for variabel:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Her udtrykker vi en variabel med navnet lcd, der har typen PCD8544 og instruerer pc'en om at omgradere dens pinouts, der er forbundet med Arduino.

I denne proces beskriver vi variablen til pc'en ved at instruere, hvordan pin clk, din, dc og reset er grænseflader med Arduino.

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

Linjen lcd.init() initialiserer LCD-operationen. Når dette er udført, tvinger den næste linje en markør øverst til venstre på displayet. Og den næste efterfølgende linje bestræber sig på at udskrive meddelelsen 'Hej, Verden'.

Dette ser helt identisk ud med den teknik, hvor vi sendte meddelelser over den serielle skærm. Den eneste forskel er brugen af ​​koden lcd.print i stedet for serial.print.

Den næste blok kode kaldes faktisk gentagne gange.

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

Brug af denne linje lcd.setCursor(0,1) vi retter markøren til den 0. kolonne længst til venstre på 1. række over LCD-skærmen.

Den næste linje anvender en genvej: lcd.print(millis())

Hvis du husker, har vi arbejdet med millis() i vores tidligere koder kunne vi også have anvendt det samme her gennem koderne:

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

På grund af det faktum, at der ikke er nogen tidsperioder i millisekunder involveret, opnår vi det ved blot at sende millis() funktion direkte til lcd.print() .

5.5 Kombination af det hele

OK, lad os nu kombinere alle de koder, vi har lært ovenfor for at lave LCD-temperaturkredsløbet, og lad os se, hvordan det ser ud:

#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 ud i ovenstående program undtagen brugen af ​​funktionen setCursor () . Dette bruges til at justere teksten så langt som muligt omkring midten af ​​skærmen.

Store! Og tillykke, du har lige programmeret din egen lille LCD temperaturindikator ved hjælp af Arduino.

Praktiske Arduino-applikationer

Da vi på dette tidspunkt har detaljeret dækket de forskellige programmeringsteknikker i detaljer, er det tid til at gennemgå dem ved at anvende dem til et par nyttige praktiske implementeringer.

Vi begynder med sensorer og ser, hvordan sensorenheder kunne bruges med Arduino ved at udføre nogle få prøvekoder.

7.1 Introduktion til sensorer

I denne vejledning lærer vi os om det store udvalg af sensorer, der kan bruges med Arduino. Disse kan omfatte enheder som lyssensor LDR, magnetisk hall-effektsensor, vippesensorer, vibrationssensor, trykføler osv.

Vi begynder med grænsefladen mellem lyssensor LDR med Arduino, som vist i følgende diagram:

Som vi alle ved, er LDR en lysafhængig modstandsenhed, hvis modstand afhænger af intensiteten af ​​den omgivende hændelse på dens overflade.

Lysets intensitet er omvendt proportional med modstandslæsningen af ​​LDR.

Her lærer vi, hvordan denne egenskab kan integreres med Arduino til udførelse af en nyttig applikation:

Den komplette programkode kan visualiseres som angivet 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 parametre, der er brugt i koden, er allerede blevet diskuteret i vores kursus, som vi hidtil har lært. Du kan kontrollere linjerne ved at henvise til de relevante afsnit.

Værdierne blev valgt tilfældigt, du kan nemt ændre efter dine egne præferencer.

Vippesensor

En vippesensor er en enkel enhed, der kan bruges til at registrere en vippefunktion på ethvert objekt, hvor den er installeret. Enheden har dybest set en metalkugle indeni, som ved vipning ruller over et par kontakter, der forårsager en ledning på tværs af disse kontakter. Disse kontakter, der afsluttes som ledningerne til vippekontakten, bruges med et eksternt kredsløb til at detektere ledningen på grund af en vippende handling og aktivering af den ønskede outputapplikation.

Lad os nu se, hvordan en vippesensor enheden kunne være tilsluttet. Billedet nedenfor giver os en idé om den komplette konfiguration:

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 eksempel bruges standard pin nr. 13 LED som hældningsindikator.

Du kan tydeligt se medtagelsen af ​​pull-up-modstanden her, meget ens hvad vi gjorde i afsnit 3.1. Derfor angiver udtrykket LAV, at vippefunktionen ikke udløses.

7.4 Reed switch relæ (Miniature Magnet Activated Relay)

Lad os nu se, hvordan man tilslutter en relæafbryder eller en magnetfeltsensor med Arduino. Et reedrelæ er en slags kontakt, der aktiverer eller udfører, når et magnetfelt eller en magnet bringes i nærheden af ​​det. Dybest set har den et par ferromagnetiske kontakter inde i en miniatureglasafskærmning, der forbinder eller kommer i kontakt på grund af magnetisk træk, når en magnetisk er tæt på den. Når dette sker, viser kontakternes terminaler ledning på grund af kontakternes lukning.

Også her bruger vi pin nr. 13 LED til at indikere svaret. Du kan tilslutte en ekstern LED fra denne pin, hvis det kræves i henhold til vores 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)
}
}

Kodeudtrykkene skal være velkendte og selvforklarende.

7.5 Vibrationssensor ved hjælp af Piezo-transducer

I det næste prøveprogram ser vi, hvordan en piezo transducer kan bruges som en vibrationssensor til at belyse en LED gennem Arduino.

Et piezo-element er faktisk en enhed, der genererer vibrationer eller svingninger, når en frekvens påføres over dens terminaler. Imidlertid kunne den samme piezo bruges i den omvendte proces til generere elektriske impulser som reaktion på vibrationer på kroppen. Denne vibration kan være i form af et banke eller et slag på piezoens overflade.

Opsæt Arduino og et piezo-element som angivet i følgende figur

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
}
}

Tærsklen 100 introduceres bare for at sikre, at Arduino kun reagerer på de ægte vibrationer gennem slag, og ikke andre mindre vibrationer såsom fra høje lyde eller horn.

Valget af A5-pin er ikke obligatorisk, du kan vælge andre analoge indgange efter dine præferencer og ved at matche det i programkoden.

Brug af servomotor med Arduino

En servomotor er en type jævnstrømsmotor, som kan drejes til præcise vinkler i henhold til behovet for en bestemt applikation. Det kan gøres ved at anvende en beregnet kommando til de relevante indgange på motoren for at frembringe en nøjagtig rotations- eller drejevinkel inden for 180 graders rækkevidde på motoren.

Typisk har en servomotor 3 ledninger eller indgange. De positive ledninger har normalt rød farve, den negative ledning eller jordledningen er sort, hvor kommandotråden eller signaltråden normalt er hvid eller gul i farven.

Arduino letter servomotorkontrol gennem indbygget support sprog, hvilket gør styring meget praktisk og ideel til servomotorer.

Følgende eksempel viser os det grundlæggende installationsprogram til implementering af servomotorstyring gennem Arduino:

Koden er angivet 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 poster her. En, der fortæller den vedhæftede ledning på servoen til hvilken pin den tildeles. Den anden er koden, der giver stiften en værdi mellem 0 og 180 til bestemmelse af rotationsvinklen på servoen.

Konklusion

Arduino-emnet kan være uendeligt langt og derfor uden for denne artikels anvendelsesområde. Jeg håber dog, at ovenstående tutorial helt sikkert skulle have hjulpet dig med at lære det grundlæggende i Arduino og forstå vigtige parametre gennem de forskellige eksempler på applikationskoder.

Forhåbentlig kan flere oplysninger opdateres fra tid til anden her, når de er tilgængelige.

I mellemtiden kan du nyde dit programmeringskursus, Happy Arduinoing til dig !!