Lärande grundläggande Arduino-programmering - Handledning för nykomlingarna

I denna handledning lär vi oss hur man gör grundläggande Arduino-programmering genom exempelkoder och exempelprogram. Denna handledning kan vara en extremt värdefull kurs för alla nykomlingar som vill förstå grunderna genom ett enkelt, förståeligt språk.

Introduktion

Enligt wikipedia en mikrokontroller motsvarar en minidator inbyggd i ett enda IC-chip med sin egen kärnprocessor, programmerbara ingångar, minne och kringutrustning.

En mikrokontroller blir så användbar för en användare eftersom den erbjuder en inbyggd processor, minne och ingångs- / utgångsportar (även kallade GPIO eller allmänna ändamål) som vi kan styras av användaren enligt önskade specifikationer.

I den här handledningen kommer vi att arbeta med ett Arduino Uno-kort för att lära sig och testa programmen. För att testa och integrera hårdvarumontering kommer vi att använda en bräda.

Låt oss nu gå snabbt och lära oss att komma igång med en Arduino-programmering.

1.2 Installera programvaran (Windows)

För detta behöver du tillgång till internet, vilket du uppenbarligen skulle ha på din dator. Gå till följande länk och ladda ner IDE-programvaran:

Windows ZIP-fil för installation utan administratör

Efter nedladdningen hittar du Arduino-installationsikonen i nedladdningsmappen, som skulle se ut så här:

När du väl har fått det här kan du helt enkelt dubbelklicka på det och installera Arduino the Integrated Development Environment (IDE) i din dator. Hela processen kan visualiseras i följande video:

1.4 Börjar med vår första krets

Innan vi börjar lära oss de faktiska programmeringsteknikerna, för någon nybörjare, skulle det vara bra att börja med en baskomponent som en LED och förstå hur man ansluter den till en Arduino.

Som vi vet är en LED en ljusdiod som har en polaritet och inte tänds om den inte är ansluten till rätt matningspoler.

En annan aspekt med lysdioder är att dessa enheter fungerar med låg ström och kan skadas omedelbart om ett lämpligt beräknat motstånd inte ingår i serie med en av dess stift.

Som en tumregel är en 330 ohm 1/4 watt ganska idealisk för varje 5V ökning av matningsingången för att begränsa strömmen till en nödvändig säker nivå. Därför för 5V kan det vara 330 ohm, för 10V kan det vara 680 ohm och så vidare.

Använda brödbräda för montering

Se till att du vet hur du använder en bakbord innan du försökte självstudien som förklaras i detta kapitel, eftersom vi skulle använda en brädbräda för alla experiment här.

Den grundläggande LED-anslutningsinställningen kan bevittnas nedan:

Du kan se 3 grundläggande komponenter ovan:

1. En 5mm, 20mA LED
2. ett motstånd på 330 ohm 1/4 watt
3. En Arduino styrelse

Montera bara systemet enligt diagrammet.

Därefter ansluter du 5V från datorns USB till Arduino. Så snart du gör detta ser du LED-lampan tändas.

Jag vet att det är ganska grundläggande, men det är alltid bra att börja från grunden. Var säker på att saker och ting börjar bli mer och mer intressanta när vi går vidare.

1.5 Kontrollerande LED med Arduino

Nu lär vi oss hur man styr en LED med ett Arduino-program.

För att kunna skriva ett program måste vi ha minst två funktioner i varje program.

En funktion kan förstås som en serie programmeringsuttalanden som kan tilldelas ett namn, enligt nedan:

1. uppstart() detta kallas eller körs under programstart.
2. slinga() detta kallas eller utförs upprepade gånger under hela Arduinos operativa period.

Därför, även om det kanske inte har någon praktisk funktion, kan ett kortast legitimt Arduino-program skrivas som:

Enklaste programmet

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

Du kanske har märkt att i många av programmeringsspråken börjar systemet med att visa ett enkelt tryck, 'Hello, World' på skärmen

Den elektroniska motsvarigheten för denna fras i tolkning av mikrokontroller är att blinka en lysdiod PÅ och AV.

Detta är det mest grundläggande programmet som man kan skriva och implementera för att indikera att systemet fungerar korrekt.

Vi försöker implementera och förstå proceduren genom följande kod:

Listning 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, låt oss nu förstå vad varje rad i koden betyder och hur det fungerar för att utföra funktionen:

const int kPinLed = 13

Detta fungerar som en konstant som gör att vi kan använda den under hela programmeringskursen utan att behöva använda det verkliga värdet som ställs in mot det.

Enligt standardreglerna erkänns sådana konstanter med startbokstaven till . Även om detta inte är obligatoriskt gör det saker tydligare och lättförståeliga när du känner för att gå igenom koddetaljerna.

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

Den här koden konfigurerar den specifika stift som vår LED är ansluten till. Med andra ord ber koden Arduino att styra 'skrivande' aspekt på denna stift, istället för att 'läsa' den.

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

Ovanstående rader anger det faktiska genomförandet av applikationen. Koden börjar med att skriva och återge en HÖG ut på relevant LED-anslutning och slå på lysdioden.

Här betyder termen HIGH helt enkelt att få + 5V på den berörda stiftet i Arduino. Den kompletterande termen LOW indikerar helt enkelt en noll eller 0V på den angivna stiftet.

Därefter ringer vi delay() vars funktion är att skapa en fördröjning genom millisekunder (1/1000 sekund). Eftersom siffran 500 är angiven kommer den implementerade fördröjningen att vara en 1/2 sekund.

Så snart denna 1/2 sekund har förflutit utförs nästa rad som stänger av LED-lampan med LOW-termen på samma stift.

Den efterföljande linjen genererar återigen 1/2 sekunders fördröjning för att lysdioden ska kunna vara AV i 1/2 sekunder.

Och processen fortsätter oändligt genom exekvering av kodraderna, så länge Arduino drivs.

Innan du fortsätter till nästa nivå rekommenderar jag att du programmerar ovanstående kod och kontrollerar om du kan implementera LED ON / OF-sekvensen korrekt eller inte.

Eftersom standard-lysdioden i Arduino är ansluten till stift nr 13 bör den omedelbart svara på ovanstående program och börja blinka. Men om du tycker att din externa LED inte blinkar kan det finnas ett anslutningsfel med din LED, du kan försöka vända polariteten på din LED och förhoppningsvis se att den blinkar också.

Du kan spela med fördröjningstiden genom att ändra '500' -siffran till något annat värde och hitta lysdioden 'lyssna' på kommandona och få den att blinka enligt de angivna fördröjningsvärdena.

Men kom ihåg att om du ser att lysdioden inte blinkar med en konstant hastighet på 1 sekund, oavsett din tidsförändring, kan det indikera att koden inte fungerar på grund av något misstag. Eftersom Arduino som standard kommer att programmeras med en blinkande hastighet på 1 sekund. Därför måste denna kurs varieras efter din kod för att bekräfta att den fungerar korrekt.

1.7 Kommentarer

Raderna med koder som vi förstod ovan skrevs specifikt för datorprogramvaran.

Men för att säkerställa att användaren kan hänvisa innebörden av raderna och förstå dem kan det ofta vara användbart och förnuftigt att skriva förklaringen bredvid de önskade kodraderna.

Dessa kallas kommentarer som är skrivna endast för mänsklig eller användarreferens och är kodade för att göra det möjligt för datorerna att ignorera det säkert.

Språket för dessa kommentarer är skrivna i ett par format:

1. Blockstilen för kommentar, varvid kommentarbeskrivningen är innesluten under startsymbolen / * och avslutningssymbolen * /
2. Detta behöver inte begränsas i en rad, utan kan utvidgas till nästa efterföljande rader beroende på längden på kommentaren eller beskrivningen, som visas i följande exempel:

/ * Detta är en kommentar * /

/ * Så är det här * /

/ * Och
* detta
* som
* väl * /

För att skriva en enstaka radbeskrivning för en kommentar blir två snedstreck // symboler i början tillräckliga. Detta berättar för datorn att den här raden inte har något att göra med den faktiska koden och måste ignoreras. Till exempel:

// Detta är en kommentar som datorer kommer att ignorera.

Här är ett exempel som referens:

/*
* 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 Felsökning

Om du hittar ditt program som visar ett 'fel' när du kompilerar, eller någon annan fråga, kommer följande tips förmodligen att hjälpa dig att kontrollera din kod igen för att bli av med hindret.

1. Ditt programspråk är skiftlägeskänsligt. Till exempel uttrycket myVar kan inte skrivas som MyVar.
2. Alla typer av vita mellanslag som kan köras genom tangentbordstyp, återges i slutändan som ett enda mellanslag, och det är bara synligt eller förstått av dig, datorn tar inte hänsyn till detta. Enkelt uttryckt, lediga utrymmen av något slag kommer inte att påverka kodresultaten.
3. Varje kodblock måste vara inneslutet med vänster och höger lockigt parentes, '{' och '}'
4. Siffror ska inte separeras med kommatecken. Till exempel kanske 1000 inte skrivs som 1000.
5. Varje kodrad som är innesluten mellan de lockiga parenteserna måste avslutas med semikolon

Skapa intressant LED-ljussekvens med Arduino

I vårt föregående kapitel lärde vi oss hur man blinkar en lysdiod PÅ / AV kontinuerligt med en konstant fördröjningshastighet.

Nu lär vi oss hur olika fördröjningsmönster kan köras på samma lysdiod genom att uppgradera programkoden.

Vi använder inte en extern lysdiod, utan använder standardlampan inbyggd i Arduino-kortet vid stift nr 13. Du hittar den här lilla SMD-lampan precis bakom USB-kontakten.

2.2 Förstå IF-uttalanden

I det här avsnittet lär vi oss hur kontrollstrukturer gör det möjligt för oss att köra enskilda koder, och ibland upprepade gånger, efter behov.

Påståendet om blir den första kontrollstrukturen. Följande implementering visar hur den används:

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 kommer att försöka förstå ovanstående kod stegvis och lära oss hur detta kan användas för andra liknande körningar.

Koderna mellan 1: a och 7: e raden liknar exakt vårt ursprungliga program.

Den första modifieringen sker faktiskt på den 8: e raden.

int delayTime = 1000

Du kan tycka att det här liknar koden på första raden, vilket hindrar att termen saknas konst.

Detta beror helt enkelt på att den här koden inte är en konstant. Istället definieras detta som en variabel , som har egenskapen till ett variabelt värde under programmeringen.

I exemplet ovan kan du se att denna variabel tillskrivs värdet 1000. Kom ihåg att sådana variabler som är inneslutna inom lockiga parenteser måste skrivas strikt inom par av lockiga parenteser och kallas 'lokala' variabler.

Alternativt erkänns variabler som ska ligga utanför lockiga parenteser, som den vi diskuterar nu, som 'globala' och kan köras nästan var som helst inom en programkod.

Framåt ser du att koder mellan rad 9 och 11 också liknar det första programmet, ändå börjar saker och ting bli intressanta efter rad 11. Låt oss se hur!

delayTime = delayTime - 100

I den här koden ser vi att standardvärdet för försening modifieras genom att subtrahera 100 från den.

Betydelsen 100 dras av från sitt ursprungliga värde på 1000, vilket ger det ett nytt värde på 900.

Genom följande bild kommer vi att försöka förstå några av de matematikoperatörer som används på Arduino-språk.

Låt oss nu bedöma koderna mellan rad 13 och 15.

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

Huvudsyftet med ovanstående kod är att säkerställa att lysdioden fortsätter att blinka utan avbrott.

På grund av att 100 dras från originalet försening , det förhindrar att lysdioden blinkar från noll och låter blinka kontinuerligt.

Följande bild visar några jämförelseoperatörer som vi skulle använda i våra koder:

I vår ovanstående kod kunde vi ha testat koden för att vara if(delayTime == 0).

Men eftersom att vara negativ siffra kan vara lika dålig, gick vi inte för det, och detta är en rekommenderad praxis.

Tänk vad kunde ha varit resultatet om vi hade försökt dra 300 istället för 100 från delayTime?

Så nu kanske du har insett att om delayTime skrivs som mindre eller lika med noll, då skulle fördröjningstiden ställas tillbaka till originalfigur 1000.

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

De sista fyra raderna i koden som visas ovan blir ansvariga för att tända / släcka lysdioden kontinuerligt.

Här kan du tydligt märka att i stället för att använda ett antal siffror, har vi använt en variabel för att tilldela fördröjningstiden så att vi kan justera den som vi vill under den operativa perioden för koden. Det är coolt, eller hur?

2.3 ELSE-uttalanden

Här lär vi oss varför och hur en om term kan ha en klausul annan så att det avgör situationen i fallet om uttalande är falskt.

Jag är ledsen om det låter för förvirrande, oroa dig inte, vi försöker förstå det med följande exempel:

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 ovanstående kan du väl se att i den 10: e raden körs koden bara när delayTime är mindre eller lika med 100, om inte så körs koden i den 13: e raden, men båda tillsammans kan aldrig hända, antingen den 10: e raden eller den 13: e linjekoden kommer att implementeras, aldrig båda.

Du kanske har märkt att till skillnad från vad vi gjorde i vårt tidigare avsnitt 2.2, här jämförde vi inte med 0, snarare jämfört med 100. Detta beror på att i detta exempel jämfört FÖR vi subtraherade 100, i motsats till avsnitt 2.2, jämförde vi EFTER subtraheras. Kan du berätta vad som kunde ha hänt om vi hade jämfört 0 istället för 100?

2.4 MEDAN uttalanden

TILL medan uttalande är ganska lik om uttalande, förutom sanningen att det orsakar upprepad körning av ett kodblock (som kan vara mellan lockiga parenteser) så länge villkoren är tillämpliga, och detta fungerar utan en annan påstående.

Följande exempel hjälper dig att förstå detta bättre

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 gissa vad ovanstående kod är programmerad att göra? Tja, den är utformad för att blinka LED-lampan snabbare och sedan långsammare.

2.5 Vad är sant och falskt?

På programmeringsspråk, falsk hänvisar till noll (0). Egentligen används inte 'true', utan det antas att när inget är falskt är allt som ingår sant.

Det ser lite konstigt ut men det gör jobbet ganska snyggt.

Vi försöker förstå situationen genom följande exempel.

Ibland kan du stöta på en kod enligt nedan:

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

Det här är kodat ser ut som att LED-körningen kommer att fortsätta cykla för alltid, så länge ström är tillgänglig.

En nackdel med denna typ av kod kan dock uppstå när användaren av misstag tillämpar a = istället för ==.

Jag är säker på att du redan vet att = betyder en uppgift, vilket betyder att den används för att beteckna ett valt värde till en variabel, medan a == används för att genomföra ett test om värdet var detsamma.

Antag till exempel att du behövde en lysdiod för att blinka med ett sekventiellt snabbmönster och upprepade gånger, men felaktigt använde en = istället för ==.

Koden skulle då se ut så här:

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
}

Felet tilldelar 0 till delayTime och leder till om uttalande för att kontrollera om 0 var sant eller inte. Eftersom 0 hänvisar till falskt, kommer det att tro att det inte är sant, och kommer att stoppa verkställigheten av delayTime = 1000, utan istället funktionen delayTime hålls vid 0 under slingan ().

Detta ser väldigt oönskat ut !!

Så dubbelkolla alltid ditt program för att se till att du inte har gjort sådana fåniga misstag.

2.6 Kombinationer

Ibland kan du känna behovet av att testa flera saker tillsammans. Som du kanske vill undersöka om en variabel var mellan två siffror. Även om detta kan implementeras med if-uttalandet flera gånger, kan det vara bekvämare att använda logiska kombinationer för bättre och enklare läsning.

Implementering av kombinationer på logiska termer kan göras med tre metoder, som visas i följande tabell:

Det skulle vara intressant att veta att NOT-operatören kan fungera som en omkopplare för en variabel som kan betecknas som endera Sann eller falsk (eller LÅG eller HÖG).

Följande exempel illustrerar tillståndet:

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

Här är ledState kommer att vara LÅG och därefter så snart ledState = !ledState, kommer den att bli HÖG. Följande slinga kommer att orsaka ledState att vara HÖG när ledState = !ledState är låg.

2.7 FÖR uttalanden

Nu ska vi försöka förstå om en annan kontrollstruktur som är en för slinga. Detta kan vara väldigt praktiskt när du vill implementera något flera gånger.

Låt oss förstå detta med följande exempel:

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 hitta något unikt i linje med för.

Det är koden jag ++? . Detta är användbart för programmerare som är ganska lata och vill implementera kodning genom praktiska genvägar

Ovanstående term kallas sammansatta operatörer, eftersom de gör jobbet med att kombinera en uppdragsoperatör med en annan uppdragsoperatör. Den mest populära av dessa kan visualiseras i följande tabell:

Du kommer att upptäcka att det finns tre underuttalanden i ett för uttalande. Den är strukturerad enligt nedan:

for (statement1conditionstatement2){
// statements
}

Uttalandet nr 1 inträffar direkt i början och bara en gång. Villkoret testas varje gång under loopens gång. Närhelst det är Sann inuti de lockiga parenteserna verkställs det efterföljande uttalandet # 2. Vid en falsk, systemet hoppar till nästa kodblock.

Ansluter fler lysdioder

OK, nu får vi se hur vi kan ansluta fler antal LEds för att få mer intressanta effekter.

Anslut lysdioderna och Arduino enligt nedan. Den röda ledningen är faktiskt inte nödvändig, men eftersom det alltid är en bra idé att ha båda leveransskenorna inkluderade i brödbrädan är uppställningen meningsfull.

Låt oss nu fixa ett program som gör att vi kan kontrollera om vår hårdvara är korrekt konfigurerad eller inte.

Det rekommenderas alltid att koda och köra små bitar av program stegvis för att kontrollera om respektive hårdvara är ansluten korrekt eller inte.

Detta hjälper till att snabbt felsöka ett eventuellt fel.

Kodexemplet nedan ger LED 2 till 5 ett specifikt mönster genom att vrida dem efter varandra på ett cykliskt sätt.

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 kanske märker är det inget fel med koden, förutom det faktum att den ser lång ut och därför är benägen för misstag.

Naturligtvis finns det bättre sätt att skriva ovanstående kod, följande avsnitt kommer att avslöja den.

2.9 Introduktion av arrays

Arrayer kan vara en grupp variabler som kan indexeras med indexnummer. Följande exempel hjälper oss att förstå det bättre.

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, nu ska vi gå igenom varje avsnitt och förstå hur de faktiskt fungerar.

const int k_numLEDs = 4

Ovanstående kod definierar hur många maximala element vi ska ha i matrisen. Den här koden hjälper oss i de efterföljande avsnitten att se till att allt skrivs i en matris och ingenting när matrisen slutar.

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

I nästa rad ställer vi in ​​arraystrukturen. Siffrorna inom fästet anger antalet element i matrisen. Även om den faktiska kvantiteten kunde ha skrivits fungerar skrivandet som konstanter bättre. Värdena visas normalt inom parentes med kommatecken och anger värdena i matrisen.

När du hittar en matris indexerad med siffran 0, indikerar detta det allra första elementet i matrisen, som visas i code: k_LEDPins is k_LEDPins[0].

På samma sätt kommer det sista elementet att visas som k_LEDPins[3], eftersom antalet från 0 till 3 är 4.

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

Ovanstående kod visar användningen av loop för att gå igenom varje arrayelement och för att ställa in dem som OUTPUTS. Vi implementerar hakparenteser tillsammans med indexet för att nå vart och ett av elementen i matrisen.

om du undrar om det är möjligt att använda stift nr 2 till stift nr 5 utan matriser är svaret ja, det är möjligt. Men i det här exemplet görs det inte eftersom vi inte gjorde det på det sättet. I följande avsnitt kan du eliminera matrismetoden om de valda utgångsstiften inte är i linje.

Låt oss se vad nästa kodblock gör:

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

Här fortsätter koden genom var och en av lysdioderna för att slå på dem i följd med ett gap eller fördröjning på 100 millisekunder.

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

Använda ovanstående kod visar hur tillämpningen av för loop kan användas för att röra sig genom slingan även i omvänd ordning.

Det börjar från k_numLEDs - 1 eftersom matriser är nollindexerade. Vi börjar inte från k_LEDPins[4] eftersom det skulle resultera i att korsa mållinjen för matrisen.

Koden använder> = 0 för att kontrollera så att det första elementet vid index 0 inte missas eller ignoreras.

Kapitel 3

Vad är en ingång

Så har vi lärt oss hur man använder saker med Arduino. I det här kapitlet kommer vi att diskutera hur man känner av den verkliga världen genom att koppla in ingångar från externa parametrar.

3.1 Använda tryckknappar

Vi vet alla vad en tryckknapp är och hur den fungerar. Det är en slags brytare eller knapp som förbinder en signal från ett kretssteg till ett annat tillfälligt medan det är i deprimerat tillstånd och bryter signalen när den släpps.

3.1.1 En knapp och en LED

Vi ansluter Arduino med en tryckknapp med Arduino enligt ovanstående detaljer och lär oss grundläggande arbete och implementering av inställningen.

Den angivna tryckknappen, som även kallas en mikrobrytarknapp, har totalt 4 stift (2 par på varje sida). När de trycks samman, förenas varje par stift internt och möjliggör en anslutning eller ledning över dem.

I det här exemplet använder vi bara ett par av dessa stift eller kontakter, det andra paret är irrelevant och ignoreras därför.

Låt oss fortsätta med att använda följande kod och kolla att den fungerar!

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 hitta några saker som ser ovanliga ut här. Låt oss räkna ut dem stegvis.

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

Det första vi gör är att fixa buttonPin som den INMATNING. Det är väl grundläggande, jag vet.

Därefter tilldelar vi HÖG till INMATNING stift. Du undrar, hur det kan vara möjligt att skriva något vid ingången? Visst, det här kan vara intressant.

Att tilldela en HIGH till en Arduino-ingång växlar faktiskt ett internt 20k Ohm pull-up-motstånd PÅ (ett LOW på denna stift växlar det OFF).

En annan fråga som du kan är är vad som är ett uppdragningsmotstånd. Jag har täckt ett omfattande inlägg om pull-up motstånd som du lär dig det här .

OK, fortsätt, låt oss nu titta på huvudslingkoden:

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

När du trycker på tryckknappen ansluts den trådbundna stiftet till marken, vilket gör a LÅG till den nålen. Och i otryckt skick hålls samma stift vid HÖG eller + 5V via 20K internt uppdragsmotstånd.

Här vill vi att Arduino ska tända lysdioden när tryckknappen trycks in (LÅG), därför skriver vi HÖG för utgången för varje svar från ett LÅG från tryckknappen, medan den trycks in.

3.1.2 Två knappar och en LED

Tja, du kanske undrar att den ovan visade åtgärden kunde ha gjorts utan en Arduino också. Jag förstår, men detta är en brant sten för att lära mig hur tryckknappen kan användas med Arduno.

Fram till denna tid har vi studerat att skriva koder för att antingen sätta PÅ (HÖG) eller stänga AV (LÅG) en lysdiod.

Låt oss nu se hur ljusstyrkan hos LED kan styras med en Arduino.

Det kan göras med två metoder:

1. Genom att begränsa strömmen till lysdioden
2. Genom att använda PWM eller pulsbreddsmodulering, i vilken matning till lysdioden slås PÅ / AV med någon önskad hastighet mycket snabbt, vilket ger en genomsnittlig belysning vars intensitet skulle bero på PWM.

I ett Arduino-kort finns PWM-stöd på stift märkta med en tilde (~), som är stift 3, 4,5,9,10 och 11) vid 500Hz (500 gånger per sekund). Användaren kan tillhandahålla valfritt värde mellan 0 och 255, där 0 refererar till inget HÖGT eller inget + 5V, och 255 säger till Arduino att få en HÖG eller + 5V hela tiden. För att initiera dessa kommandon måste du komma åt analogWrite () med önskat värde.

Du kan anta att PWM är x / 255 där x är det önskade värdet du vill skicka via analogWrite().

Ställ in Arduino och andra parametrar som visas ovan.

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 hitta tre rader här som behöver en förklaring.

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

Raden: ledBrightness = constrain(ledBrightness, 0, 255) illustrerar en unik funktion inuti Arduino känd som constrain ().

Denna interna funktion innehåller kod som liknar följande:

int begränsa (int värde, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Alla koder som diskuterades innan detta började med tomhet , vilket innebar att inte returnera någonting (ogiltigt). Medan ovanstående kod börjar med int , vilket indikerar att det returnerar ett heltal. Vi kommer att diskutera mer om i de senare avsnitten, för tillfället kom bara ihåg att ett heltal inte har några bråkdelar.

Rätt, så detta antyder, koden: ledBrightness = constrain(ledBrightness, 0, 255) tilldelar ledBrightness to be within the range of 0 and 255.

Nästa rad använder analogWrite för att beordra Arduino att applicera PWM på den valda stiftet med önskat värde.

Nästa rad skapar en fördröjning på 20 millisekunder, detta är för att säkerställa att vi inte justerar åt snabbare än 50 Hz eller 50 gånger per sekund. Detta beror på att människor kan vara mycket långsammare än en Arduino. Därför, om fördröjningen inte görs, kan programmet få oss att känna att genom att trycka på den första knappen släcktes lysdioden och att trycka på den andra knappen slog PÅ den (försök själv att bekräfta).

3.2 Potentiometrar

Låt oss gå vidare och lära oss hur man använder potentiometrar med Arduino.

För att veta hur potentiometer eller en kruka fungerar kan du läsa detta artikel .

Anslut de visade parametrarna till din Arduino som visas ovan.

En pott kommer att ha tre terminaler. Den mellersta terminalen kommer att anslutas till ANALOG IN 0 på Arduino. De andra två yttre terminalerna kan anslutas till + 5V och 0V matningsskenor.

Låt oss programmera och kolla in resultaten:

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 hittar ett par saker som kan se helt nya ut och inte ingår i någon av våra tidigare koder.

1. Konstanten kPinPot tilldelas som A0, där A är genvägen för att beskriva en av de analoga stiften. Men A0 hänvisar också till stift nr 14, A1 till stift nr 15 och så vidare, och dessa låter dig användas som digitala ingångar / utgångar om du får slut på stift för ett experiment. Men kom ihåg att du inte kan använda digitala stift som analoga stift.
2. Raden: ledBrightness = map(sensorValue, 0, 1023, 0, 255) presenterar en ny insida funktion i Arduino känd som Karta(). Den här funktionen kalibrerar om från ett visst intervall till ett annat, benämnt karta (värde, fromLow, fromHigh, toLow, toHigh). Detta kan bli avgörande eftersom analogueRead ger ut ett värde inom intervallet 0-1023, men analogWrite kan acceptera ett värde från 0-255.

Du kanske tror att eftersom det är möjligt att kontrollera ljusstyrkan hos en LED genom ett förändrat motstånd, kan helt enkelt en kruka ha varit tillräcklig för ändamålet, varför användningen av Arduino. Återigen är det bara grunden för att visa hur en kruka kan konfigureras med en Arduino.

Inga problem, nu ska vi göra något som inte kan göras utan en Arduino.

I detta experiment kommer vi att se hur en grytas varierande motstånd kan användas för att styra blinkningshastigheten eller hastigheten för en LED.

Här är 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 Undvika fördröjning ()

Ovanstående kod ser bra ut, men lysdioden kan inte kontrollera pottvärdet förrän den går igenom varje hel cykel. För längre förseningar blir denna process längre, användaren måste vänta på att se pottsvaret medan han flyttar den. Denna fördröjning kan undvikas med viss intelligent programmering, så att den tillåter användaren att kontrollera värdet utan minimala förseningar. Här är 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å vad är det annorlunda i ovanstående kod? Det är följande rad som gör skillnaden.

long lastTime = 0

Fram till detta avsnitt har vi diskuterat om variabeln int. Det kan dock finnas många fler variabler som du kan komma åt. Listan kan läsas nedan:

För närvarande kan det bara vara viktigt att veta att för att lagra relativt stort antal för int variabel kan du använda termen lång eller a lång int.

Här kan du se en annan intressant funktion som heter millis ().

Detta producerar tidsperioden i millisekunder som Arduino arbetade under sin drift från början (detta återställs till 0 efter var 50: e dag). Här returnerar det länge för om det återvände int , räkning under långa perioder kanske inte är möjligt. Kan du svara exakt hur länge? Svaret är 32,767 sekunder.

Istället för att använda fördröjning () kontrollerar vi för millis (), och så snart det specifika antalet millisekunder försvinner ändrar vi lysdioden. Följaktligen lagrar vi tiden vi ändrade den senast lastTime variabel, så att vi kan kontrollera den igen när så önskas.

3.3 RGB-lysdioder

Hittills har vi spelat med en enda färg-LED. Även om LED-färg kan ändras genom att ersätta LED med en annan färg, men vad sägs om att använda RGB-lysdioder för att ändra LED-färger utan att byta lysdioder?

En RGB-LED är i grunden en LED med en röd, grön och blå LED inbäddad och sammanfogad till en enda LED. Den har en gemensam ledning som går till marken eller 0V-skenan medan de andra 3 ledningarna matas med diversifierade PWM-positiva signaler för att implementera den avsedda färgblandning .

Du kan koppla upp anläggningen enligt nedan:

Det kan se lite komplext ut, men faktiskt är det en kopia av vår tidigare LED-styrdesign med PWM.

Här är en övningsprogramkod:

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 att du laddat upp den här koden, se bara hur potten justeringar skapar intressant ljuseffekt på RGB, det kan vara riktigt roligt.

Du kommer att upptäcka att när alla 3 krukor flyttas maximala positioner, istället för en vit färg ser du rött. Detta beror på att röd färg är den mest framträdande bland de tre färgerna och därför dominerar i denna situation. Du kan dock experimentera med funktionen Karta() innan den körs till den röda delen av lysdioden för att skapa en mer förnuftig balans.

Ljud med Arduino

I det här avsnittet lär vi oss att lägga till grundläggande ljud och musik till en Arduino-installation.

Vi kommer att se hur man byter en signal till en ansluten högtalare med önskad frekvens.

För att vara mer exakt kommer en mitten A-anteckning att prövas, vilket är en 440 Hz-frekvensnot.

För att göra detta spelar vi helt enkelt en mitten av en anteckning och optimerar sinusvågssignalen med fyrkantvåg.

Vi beräknar också hur länge en högtalare kan stanna PÅ genom att stämma formeln:

timeDelay = 1 sekund / 2 x tonFrekvens.

timeDelay = 1 sekund / 2 x 440

timeDelay = 1136 mikrosekunder

4.1 Låt oss ansluta Arduino Board

4.2 Lägga till en enkel anteckning

Vi har redan diskuterat om funktionen dröjsmål() där enheten är i millisekunder (sekund / 1000), men du hittar ännu en funktion delayMicroseconds() där enheten är i mikrosekunder, (millisekunder / 1000).

För den nuvarande inställningen programmerar vi en kod för att slå på + 5V PÅ / AV på den valda stift som är kopplad till högtalaren, med en hastighet av 440 pulser per sekund.

Minns, i den senaste diskussionen bestämde vi värdet 1136 mikrosekunder för den avsedda ljudnoten.

Så här är programmet för detta, vilket gör att du kan höra en ljudnot på 440 Hz så snart du programmerar arduino med en högtalare ansluten.

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 ovanstående applikation är det möjligt att göra en ljudanteckning, vilket också innebär att vi kan skapa en musik enligt vårt eget val.

Från koden förstår vi att Arduino innehåller ett par integrerade funktioner som dessutom bidrar till skapandet av musik.

Den första är tona() som fungerar med två element tillsammans med ett tredje valfritt element, betecknat som ton (stift, frekvens, varaktighet). eller ton (stift, frekvens)

Båda är avsedda att utföra respektive den tidsperiod som du har tilldelat.

I avsaknad av en tidsperiod fortsätter musiken att spelas fram till samtalet tona() körs igen, eller tills du kör inte en enda ().

Detta måste göras med en fördröjningsfunktion om musikuppspelning är det enda grundläggande du implementerar.

Tidslängden kan vara avgörande eftersom det ger dig tid för hur länge musiken spelas, så kan du fritt göra andra saker. Så snart varaktigheten försvinner stannar musiken.

Nästa funktion inte en enda () hanterar en enda parameter och stoppar den valda tonen på en viss tilldelad stift.

En märklig varning: När som helst tona() funktionen är implementerad kommer PWM-funktionen på stift 3 och 11 att sluta fungera.

Var noga med att inte använda den nämnda stiftet för högtalarna när du använder ett högtalarfäste i programmet, istället prova några andra stift för högtalarfästet.

OK så här är programmet för att implementera musik på en högtalare, även om det inte är en riktig musik snarare en basskala C-anteckning.

#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 ovanstående kod kanske du har märkt något nytt och det är #definiera .

Denna term fungerar som ett sök-och-ersätt-kommando för datorn medan kompileringen görs.

Närhelst det hittar det första innan ett mellanslag ersätter det det med den återstående delen av raden (kallas makron).

Så inom detta exempel när datorn ser OBS_E4 den ersätter den snabbt med kvantiteten 330.

För fler anteckningar och anpassning kan du hänvisa till en fil på ditt USB-minne med namnet platser.h , där de flesta frekvenser hittades efter dina önskemål.

4.4 Musik med funktioner

Koden ovan ser bra ut, men verkar ha många repetitioner, det borde finnas någon metod för att förkorta dessa repetitioner, eller hur?

Hittills har vi arbetat med två viktiga funktioner som ingår i Arduino. Nu kan det vara dags att skapa våra egna funktioner.

Varje funktion måste börja med den typ av variabel den kan associeras med. Till exempel funktionen tomhet refererar till typ som returnerar ingenting därav namnet ogiltigt. Obs! Vi har redan diskuterat en lista med variabler i våra tidigare avsnitt, du kanske vill hänvisa dem.

Följaktligen får det specifika funktionsnamnet en öppen parentes '(' följt av en lista med kommaseparerade parametrar.

Var och en av parametrarna får sin typ tillsammans med ett namn och slutligen en avslutning ')' parentes.

Dessa parametrar kan användas inom funktionen i form av variabler.

Låt oss se ett exempel nedan där vi utvecklar en funktion som kallas ourTone () utformad för att slå samman tona() med dröjsmål() rader, på ett sätt som funktionen slutar återvända tills noten har spelat upp tonen.

Vi implementerar dessa funktioner i vår tidigare kod och får nedanstående program, se de sista raderna:

#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 vara extremt praktiska för att göra ett program lättare att förstå.

Följande är ett exempel där vi kan specificera valet av ton vi vill spela med två arrays. En matris för att behålla noterna, den andra för att behålla takten.

#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 ser tydligt på första raden introduktionen av #omfatta påstående. Arbetet med detta uttalande är att plocka upp hela filen mellan offerten och placera den i positionen för #omfatta påstående. Enligt standardreglerna är dessa strikt placerade i början av programmet.

Kapitel 5

Mäta temperatur

Bara för att komma ihåg, kom ihåg istället för att skriva stora program helt och hållet, det är alltid klokt att skriva och analysera små delar av koder, vilket hjälper till att spåra upp misstag snabbt.

5.1 Seriell bildskärm

Hittills verkar koder som vi diskuterade inte vara så lättare att möjliggöra snabb felsökning. Här försöker vi göra saker enklare för övervakning och enklare lösning av ett eventuellt problem.

Arduino har en funktion som gör att den kan 'prata tillbaka' med datorn. Du kan observeras att pin0 och pin1 är markerade som RX en TX bredvid varandra. Dessa stift spåras faktiskt av en separat IC i Arduino som uppgraderar dem för att läsa över USB-kabeln medan den är ansluten till datorn.

Nedanstående avsnitt visar ett fullfjädrat program, snälla gå igenom det, vi lär oss om de nya posterna i koden därefter. Den här koden är densamma som uttryckt i avsnitt 2.2 förutom att den innehåller extra data för att vi ska kunna identifiera vad den har kodats för.

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 identifiera två nya saker här, en ny rad i uppstart() fungera.

Serial.begin(9600)

Denna linje uttrycker helt enkelt nödvändigheten av att använda Seriell1 kod för att genomdriva den med 9600 baud. (här seriell hänvisar till bitar skickas efter varandra och baud betyder hastigheten med vilken den skickas). Detta baudvärde och det som finns inuti den seriella bildskärmen (vi får lära oss detta senare) måste vara lika, annars kommer data i seriell bildskärm att visa skräp. 9600 är standarden blir bekvämare att använda.

Den andra nya posten är som följer

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

Här föreslår den andra raden att den efterföljande saken som kommer ut från den seriella porten börjar på nästa rad. Det är så den andra raden skiljer sig från nävelinjen.

En sak till kan du se är citat ('). Detta är känt som en sträng, som bara används som konstanter här, eftersom ytterligare diskussion om detta ämne kan vara för detaljerad och utanför omfattningen.

OK, vi kan nu ladda upp ovanstående kod i Arduino och se vad som händer.

Vad, oops, ingenting verkar ha hänt, Arduino-stift nr 13 blinkade och stannade medan Tx-lysdioden förblev blinkande.

Det beror på att fönstret Serial Monitor inte är fixat än.

Du måste klicka på rutan Seriell bildskärm i din IDE som visas ovan. Glöm inte att kontrollera överföringshastigheten längst ner till höger, som standard ska den vara 9600, och den kommer att matcha koden. Om det inte är så se till att välja 9600.

Följande videoklipp förklarar hur det görs.

Låt oss gå vidare och lära oss hur ovanstående Serial Monitor-funktion kan hjälpa till att bearbeta mätning av temperatur med Arduino

Vi använder IC TMP36 som temperatursensor med ett intervall på -40 till 150 grader Celsius.

Installationen kan ses nedan:

Följande kod startar mätningen av temperaturen genom att avläsa utgången från TMP36-sensorn och genom att skicka dem till ID-seriens bildskärm.

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
}

Låt oss förstå koden uppifrån.

float temperatureC = getTemperatureC()

Här kan du se att vi har inkluderat variabeltypen flyta.

Detta är den enda variabeltypen som har lagring av allt utom heltal (tal utan decimaler eller bråkdelar).

Noggrannheten från en flytvariabel kan vara upp till 6 till 7 siffror.

Den angränsande koden getTemperatureC() är vår egen funktion som matematiskt beräknar och omvandlar den avkända spänningsskillnaden från TMP36-sensorn till 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 nästa avsnitt av koder, sedan termen analogIn() tilldelas att returnera en siffra mellan 1 och 1023 blir det möjligt för oss att bedöma spänningen från sensorn genom att multiplicera vår avläsning med 5 och sedan dela den med 1024.

Sensorn TMP36 är specificerad för att generera en 0,5 V vid 0 grader Celsius och genererar därefter 10 mV för varje enskild ökning av grad Celsius.

Här är den approximation som vi kan generera genom beräkningarna:

Du kan överväga att vara din första funktion som returnerar något värde (notera att alla återstående funktioner hittills inte returnerade något värde eftersom de har varit av typen tomhet ).

Du kan förstå att du bara behöver lägga till för att få ett värde från en funktion lämna tillbaka följt av önskat nummer du vill returnera.

När vi säger lämna tillbaka det betyder att funktionen returnerar ett svar eller ett svar närhelst det anropas, vilket kan tillämpas på en variabel.

När detta skickas till Serial Monitor konverteras läsningen till Fahrenheit genom convertToF ().

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

Denna funktion plockar upp Celsius-sortimentet och konverterar det till Fahrenheit.

För att konvertera Fahrenheit till Celsius implementerar vi formeln Fahrenheit = 9 / 5 (Celsius)+ 32.

5.3 Gränssnitt mellan en LCD

Låt oss nu studera hur man gränssnitt eller ansluta en LCD skärm med Arduino för att få visuell visning för erforderliga utgångar.

I vår ansökan kommer vi att använda en 84x48 grafisk LCD-skärm med en 84 pixel eller punkter horisontellt och 48 pixlar vertikal upplösning. Eftersom en dedikerad styrenhet blir absolut nödvändig för alla LCD-skärmar, innehåller den aktuella enheten också en i form av PCD8544-styrenhet.

I denna handledning ansluter vi den ovan angivna LCD-modulen med Arduino och tillämpar vissa rutiner för att skapa textmeddelanden på skärmen.

I följande bild hittar du information om gränssnittet mellan LCD-skärmen och en liten 3,3 V spänningsregulator . Denna regulator är nödvändig eftersom LCD-skärmen är specificerad för att fungera med en 3,3 V-matning.

Du kan också se 8 pinouts från LCD-modulen, pinout-specifikationerna kan studeras från följande tabell:

Låt oss nu se hur vi kan ansluta LCD-skärmen och relevanta parametrar till vår Arduino. Detaljerna kan visualiseras i nedanstående illustration:

5.4 Kommunicera till LCD-skärmen

Även om det är möjligt att skriva utarbetade coeds för interaktion med LCD från Arduino, lär vi oss snarare hur man gör samma sak med hjälp av bibliotek.

Bibliotek innehåller ett sortiment av koder som snabbt kan användas för ett valt Arduino-program.

Detta gör det möjligt för användaren att anropa en funktion utan att behöva genomgå komplicerat kodarbete.

5.4.1 Hur man installerar biblioteket

För detta måste du skapa en katalog som heter bibliotek på din dator Arduino IDE, som förklarat här

5.4.2 Implementering av LCD-funktionerna

Precis som vårt tidigare tillvägagångssätt kommer vi först att checka ut hela koden och sedan försöka förstå detaljerna i de enskilda raderna.

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

Raden innehåller koden #include

Koden #include instruerar PC: n att plocka upp den nämnda filen och ersätta #include-elementet med filinnehållet under sammanställningen av programmet.

Elementet #include kan ha vinkelparenteser som indikerar sökning i bibliotekskatalogen, alternativt kan det också ha citat som indikerar sökning i samma katalog som programmet ligger i.

De efterföljande kodraderna uttrycker LCD-pinouts, och sedan skriver vi en ny form av variabel:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Här uttrycker vi en variabel med namnet lcd som har typen PCD8544 och instruerar PC: n att omorganisera sina pinouts associerade med Arduino.

I den här processen beskriver vi variabeln till PC: n genom att instruera hur pin clk, din, dc och reset är gränssnitt med Arduino.

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

Linjen lcd.init() initialiserar LCD-funktionen. När detta har utförts, tvingar nästa rad en markör längst upp till vänster på displayen. Och nästa efterföljande rad anstränger sig för att skriva ut meddelandet 'Hej, Värld'.

Detta ser ganska identiskt ut med tekniken där vi skickade meddelanden över den seriella bildskärmen. Den enda skillnaden är användningen av koden lcd.print istället för serial.print.

Nästa kodblock kallas faktiskt repetitivt.

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

Med den här raden lcd.setCursor(0,1) vi fixar markören till den 0: e kolumnen längst till vänster om den första raden, över LCD-skärmen.

Nästa rad använder en genväg: lcd.print(millis())

Om du kommer ihåg har vi arbetat med millis() i våra tidigare koder kunde vi ha använt samma här också genom koderna:

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

Men på grund av det faktum att här inga tidsperioder i millisekunder är inblandade, gör vi det genom att helt enkelt skicka millis() fungerar direkt till lcd.print() .

5.5 Kombinera hela saken

OK, nu ska vi kombinera alla koder som vi lärde oss ovan för att skapa LCD-temperaturkretsen, och låt oss se hur 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
}

Allt ser standard ut i ovanstående program, förutom användning av funktionen setCursor () . Detta används för att rikta in texten så långt som möjligt runt skärmens mitt.

Bra! Och grattis, du har just programmerat din egen lilla LCD-temperaturindikator med Arduino.

Praktiska Arduino-applikationer

Eftersom vi vid denna tidpunkt har behandlat de olika programmeringsteknikerna i detalj, är det dags att testa dem genom att använda dem för några användbara praktiska implementeringar.

Vi börjar med sensorer och ser hur sensorenheter kan användas med Arduino genom att köra några exempelkoder.

7.1 Introduktion till sensorer

I denna handledning lär vi oss om det stora utbudet av sensorer som kan användas med Arduino. Dessa kan inkludera enheter som ljussensor LDR, magnetisk hallseffektsensor, lutningssensorer, vibrationssensor, trycksensor etc.

Vi börjar med gränssnittet mellan ljussensor LDR med Arduino, som visas i följande diagram:

Som vi alla vet är LDR en ljusberoende motståndsanordning vars motstånd beror på intensiteten hos omgivande infall på dess yta.

Ljusintensiteten är omvänt proportionell mot LDR: s motståndsavläsning.

Här lär vi oss hur den här egenskapen kan integreras med Arduino för att utföra en användbar applikation:

Den kompletta programkoden kan visualiseras enligt nedan:

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

Alla parametrar som används i koden har redan diskuterats i vår kurs som vi hittills har lärt oss. Du kan kontrollera raderna genom att hänvisa till relevanta avsnitt.

Värdena valdes slumpmässigt, du kan enkelt ändra enligt dina egna preferenser.

Lutningssensor

En lutningssensor är en enkel anordning som kan användas för att upptäcka en lutningsåtgärd på alla objekt där den är installerad. Enheten har i grunden en metallkula inuti, som vid lutning rullar över ett par kontakter som orsakar en ledning över dessa kontakter. Dessa kontakter som avslutas som ledningarna för lutningsomkopplaren används med en extern krets för att detektera ledningen på grund av en lutningsåtgärd och aktivera den önskade utmatningstillämpningen.

Låt oss nu se hur en lutningssensor enheten kan kopplas ihop. Bilden nedan ger oss en uppfattning om den fullständiga konfigurationen:

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 detta exempel används standardstift nr 13 som lutningsindikator.

Du kan tydligt se inkluderingen av uppdragningsmotståndet här, ganska lika vad vi gjorde i avsnitt 3.1. Därför indikerar termen LÅG att tiltfunktionen inte utlöses.

7.4 Reed Switch Relay (Miniature Magnet Activated Relay)

Låt oss nu se hur man kopplar upp en reläbrytare eller en magnetfältsensor med Arduino. Ett vassrelä är en typ av omkopplare som aktiverar eller leder när ett magnetfält eller en magnet förs nära det. I grund och botten har den ett par ferromagnetiska kontakter inuti ett miniatyrglashölje som går ihop eller kommer i kontakt på grund av magnetisk dragning när en magnet är i närheten av den. När detta händer visar kontakternas kontakter ledning på grund av att kontakterna stängs.

Även här använder vi stift nr 13 för att indikera svaret. Du kan ansluta en extern lysdiod från denna stift om så krävs enligt våra tidigare förklaringar.

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

Kodtermerna ska vara bekanta och självförklarande.

7.5 Vibrationssensor med Piezo-givare

I nästa exempelprogram ser vi hur en piezogivare kan användas som en vibrationssensor för att belysa en LED genom Arduino.

Ett piezo-element är faktiskt en anordning som genererar vibrationer eller svängningar när en frekvens appliceras över dess terminaler. Dock kan samma piezo användas i omvänd process för generera elektriska pulser som svar på vibrationer som appliceras på kroppen. Denna vibration kan vara i form av en knackning eller träff på piezos yta.

Ställ in Arduino och ett piezo-element enligt nedanstående bild

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

Tröskeln 100 introduceras bara för att se till att Arduino endast svarar på de äkta vibrationerna genom knackar, och inte andra mindre vibrationer som från höga ljud eller horn.

Valet av A5-stift är inte obligatoriskt, du kan välja andra analoga ingångar enligt dina önskemål och genom att matcha den i programkoden.

Använda Servomotor med Arduino

En servomotor är en typ av likströmsmotor som kan roteras till exakta vinklar enligt behovet av en viss applikation. Det kan göras genom att tillämpa ett beräknat kommando på relevanta ingångar för motorn för att producera en exakt rotations- eller vridningsvinkel inom motorn 180 grader.

Vanligtvis har en servomotor tre ledningar eller ingångar. De positiva ledningarna är vanligtvis röda, den negativa eller jordade ledningen är svart, vilken kommandotråd eller signaltråden normalt har vit eller gul färg.

Arduino underlättar servomotorstyrning genom inbyggt stödspråk vilket gör styrning mycket bekvämt och perfekt för servomotorer.

Följande exempel visar oss det grundläggande installationsprogrammet för implementering av servomotorstyrning via Arduino:

Koden ges nedan:

#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 ett par nya poster här. En som berättar den anslutna ledningen på servon till vilken stift den tilldelas. Den andra är koden som ger stiftet ett värde mellan 0 och 180 för att bestämma rotationsvinkeln på servon.

Slutsats

Arduino-ämnet kan vara oändligt långt och därför utanför ramen för denna artikel. Jag hoppas emellertid att ovanstående handledning verkligen borde ha hjälpt dig att lära dig Arduinos grunder och förstå viktiga parametrar genom olika exempel på applikationskoder.

Förhoppningsvis kan mer information uppdateras då och då här, närhelst den är tillgänglig.

Under tiden kan du njuta av din programmeringskurs, Happy Arduinoing till dig !!