Arduino põhiprogrammeerimise õppimine - õpetus uustulnukatele

Selles õpetuses õpime, kuidas teha näite koodide ja näidisprogrammide kaudu Arduino põhiprogrammeerimist. See õpetus võib olla ülimalt väärtuslik kursus kõigile uustulnukatele, kes soovivad hõlpsa ja arusaadava keele abil põhitõdesid mõista.

Sissejuhatus

Vastavalt vikipeedia mikrokontroller on samaväärne ühe IC-kiibi sisse ehitatud mini-arvutiga, millel on oma põhiprotsessor, programmeeritavad sisendid, mälu ja väljundseadmed.

Mikrokontroller muutub kasutaja jaoks nii kasulikuks, kuna see pakub sisseehitatud protsessorit, mälu ning sisend- ja väljundporte (neid nimetatakse ka GPIO või üldotstarbelisteks sisend- ja väljundnõelteks), mida kasutaja saab kontrollida vastavalt soovitud spetsifikatsioonidele.

Selles õpetuses teeme programmide õppimiseks ja testimiseks koostööd Arduino Uno tahvliga. Riistvarakomplekti testimiseks ja integreerimiseks kasutame leiblauda.

Nüüd liigume kiiresti ja õpime, kuidas Arduino programmeerimisega alustada.

1.2 Tarkvara installimine (Windows)

Selleks vajate juurdepääsu Internetile, mis teil ilmselt on arvutis. Minge järgmisele lingile ja laadige alla IDE tarkvara:

Windowsi ZIP-fail mitte-administraatori installimiseks

Pärast allalaadimist leiate allalaadimiskataloogist Arduino seadistuse ikooni, mis näeks välja selline:

Kui olete selle kätte saanud, võite sellel lihtsalt topeltklõpsata ja Arduino integreeritud arenduskeskkonna (IDE) arvutisse installida. Kogu protsessi saab visualiseerida järgmises videos:

1.4 Alustades meie esimesest ringrajast

Enne kui hakkame õppima tegelikke programmeerimistehnikaid, oleks iga algaja jaoks kasulik alustada mõne põhikomponendiga, nagu näiteks LED, ja mõista, kuidas seda Arduinoga ühendada.

Nagu me teame, on LED valgusdiood, millel on polaarsus ja mis ei sütti, kui see pole ühendatud õigete toitepostidega.

LEDide teine ​​aspekt on see, et need seadmed töötavad väikese vooluga ja võivad koheselt kahjustuda, kui nõuetekohaselt arvutatud takistit ei ole seerias ühe selle tihvtiga.

Rusikareeglina on 330 oomi 1/4 vatt ideaalne toiteallika iga 5 V tõusu jaoks, et piirata voolu vajalikule ohutule tasemele. Seetõttu võib see 5 V jaoks olla 330 oomi, 10 V puhul 680 oomi ja nii edasi.

Leiblaua kasutamine kokkupanekuks

Palun veenduge, et oskate kasutada a leivalaud enne selles peatükis selgitatud õpetuse proovimist, kuna me kasutaksime siin kõigi katsete jaoks leiba.

LED-ühenduse põhilist seadistamist saab näha allpool:

Eespool näete kolme põhikomponenti:

1. 5mm, 20mA LED
2. 330 oomi 1/4 vatine takisti
3. An Arduino juhatus

Lihtsalt koguge süsteem vastavalt skeemile.

Järgmisena ühendage 5 V arvuti USB-lt Arduinoga. Niipea kui te seda teete, näete, kuidas LED süttib.

Ma tean, et see on üsna elementaarne, kuid alati on hea alustada nullist. Ole kindel, et asjad lähevad edasi liikudes üha huvitavamaks.

1.5 LED-i juhtimine Arduinoga

Nüüd õpime, kuidas juhtida LED-i Arduino programmiga.

Programmi kirjutamiseks peab igas programmis olema vähemalt 2 funktsiooni.

Funktsiooni võib mõista kui programmeerimislausete rida, millele võidakse määrata nimi, nagu allpool esitatud:

1. seadistamine () seda kutsutakse või täidetakse programmi käivitamise ajal.
2. silmus () seda nimetatakse või täidetakse korduvalt kogu Arduino tööperioodi vältel.

Seega, kuigi sellel ei pruugi olla praktilist funktsionaalsust, võib tehniliselt lühima legitiimse Arduino programmi kirjutada järgmiselt:

Lihtsaim programm

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

Võib-olla olete märganud, et paljudes programmeerimiskeeltes näitab süsteem lihtsalt lihtsat printimist 'Tere, maailm' ekraanil

Selle lause elektrooniline vaste mikrokontrolleri tõlgendamisel on vilkuma LED sisse ja välja.

See on kõige elementaarsem programm, mida saab süsteemi õigeks toimimiseks osutada ja rakendada.

Püüame protseduuri rakendada ja sellest aru saada järgmise koodijupi kaudu:

Loend 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, nüüd mõistame, mida iga koodi rida tähendab ja kuidas see funktsiooni täidab:

const int kPinLed = 13

See töötab nagu konstant, mis võimaldab meil seda kasutada kogu programmeerimiskursuse ajal, ilma et oleks vaja kasutada sellele vastavat tegelikku väärtust.

Vastavalt standardreeglitele on sellised konstandid tunnustatud algustähega kuni . Kuigi see ei ole kohustuslik, muudab see asjad selgemaks ja hõlpsasti mõistetavaks alati, kui soovite koodi üksikasjad läbi vaadata.

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

See kood konfigureerib konkreetse tihvti, mille külge meie LED on kinnitatud. Teisisõnu, kood käsib Arduinol selle 'lugemise' asemel juhtida selle tihvti 'kirjutamise' aspekti.

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

Ülaltoodud read näitavad rakenduse tegelikku täitmist. Kood algab vastava LED-ühenduse HIGH-i kirjutamise ja renderdamisega, lülitades LED-i sisse.

Siin tähendab termin HIGH lihtsalt + 5V saamist Arduino asjaomasele tihvtile. Täiendav mõiste LOW tähistab määratud nööpnõelal lihtsalt nulli või 0 V-d.

Järgmisena helistame delay() mille ülesanne on luua viivitus millisekundite (1/1000 sekundi) kaudu. Kuna sisestatakse joonis 500, on rakendatav viivitus 1/2 sekundit.

Niipea kui see 1/2 sekund on möödunud, käivitatakse järgmine rida, mis lülitab LEDi välja LOW-terminiga samal tihvtil.

Järgnev rida genereerib taas 1/2 sekundi viivituse, et LED jääks 1/2 sekundiks välja.

Ja protsess jätkub lõpmatult koodiridade täitmisega, kui Arduino on toiteallikana.

Enne järgmisele tasemele liikumist soovitan teil programmeerida ülaltoodud kood ja kontrollida, kas saate LED ON / OF järjestust õigesti rakendada või mitte.

Kuna Arduino vaikevalgusdiood on ühendatud tihvtiga nr 13, peaks see viivitamatult reageerima ülaltoodud programmile ja hakkama vilkuma. Kuid kui leiate, et teie väline LED ei vilgu, võib teie LED-is olla ühenduse viga, võite proovida oma LED-i polaarsust ümber pöörata ja loodetavasti näete ka seda vilkuvat.

Viivitusajaga saate mängida, muutes „500“ näitaja mõneks muuks väärtuseks ja leides käske kuulava LED-i ning pannes selle vilkuma vastavalt määratud viivitusväärtustele.

Kuid pidage meeles, et kui näete, et LED ei vilgu püsiva 1-sekundilise kiirusega, olenemata viivitusaja muutmisest, võib see tähendada, et kood ei tööta mõne vea tõttu. Sest vaikimisi programmeeritakse Arduino 1-sekundise vilkumissagedusega. Seetõttu peab see kiirus muutuma teie koodi abil, et kinnitada selle korrektset tööd.

1.7 Kommentaarid

Eespool mõistetud koodiread olid spetsiaalselt kirjutatud arvutitarkvara jaoks.

Kuid selleks, et tagada kasutajale võimalus viidata ridade tähendusele ja neist aru saada, võib sageli olla kasulik ja mõistlik kirjutada selgitus soovitud koodiridade kõrvale.

Neid nimetatakse kommentaare mis on kirjutatud ainult inimeste või kasutajate jaoks ja on kodeeritud, et võimaldada arvutitel seda ohutult eirata.

Nende kommentaaride keel on kirjutatud mitmes vormingus:

1. Kommentaari ploki stiil, kus kommentaari kirjeldus on lisatud algussümboli / * ja lõppsümboli * / alla
2. See ei pea ühes reas piirama, pigem võib seda laiendada järgmistele järgmistele ridadele, sõltuvalt kommentaari või kirjelduse pikkusest, nagu on näidatud järgmises näites:

/ * See on kommentaar * /

/ * Nii on ka see * /

/ * Ja
* see
* as
* hästi * /

Kommentaari jaoks ühe reaga kiire kirjelduse kirjutamiseks piisab alguses kahest kaldkriipsust // sümbolist. See ütleb arvutile, et sellel real pole tegeliku koodiga midagi pistmist ja seda tuleb ignoreerida. Näiteks:

// See on kommentaar, mida arvutid eiravad.

Siin on näide näitena:

/*
* 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 Tõrkeotsing

Kui leiate, et teie programmis on kompileerimisel „viga” või mõni muu probleem, aitavad järgmised näpunäited tõenäoliselt koodi uuesti üle vaadata, et tõkkest vabaneda.

1. Teie programmi keel on tõstutundlik. Näiteks väljend myVar ei saa kirjutada MyVar.
2. Igasugused tühikud, mille teie klaviatuur võib sisestada, renderdatakse lõpuks ühe tühikuna ja see on nähtav või arusaadav ainult teile, arvuti ei võta seda arvesse. Lihtsustatult öeldes - igasugused vabad ruumid ei mõjuta kooditulemusi.
3. Iga koodiplokk peab olema ümbritsetud vasak- ja parempoolsete lokkisulgudega, '{' ja '}'
4. Numbrikohti ei tohiks komadega eraldada. Näiteks 1000 ei pruugi olla kirjutatud kui 1000.
5. Iga lokkisulgude vahele suletud koodirida peab lõppema semikooloniga

Arduinoga huvitava LED-valgusjada loomine

Meie eelmises peatükis õppisime, kuidas pidevalt sisse ja välja lülitada LED-d pideva viivitusega.

Nüüd õpime, kuidas erinevaid viivitusmustreid saaks sama koodiga käivitada, uuendades programmi koodi.

Me ei kasuta välist LED-i, pigem kasutage Arduino tahvlisse sisseehitatud vaikevalgusdioodi tihvti nr 13 juures. Selle väikese SMD LED-i leiate USB-pistiku tagant.

2.2 IF-avalduste mõistmine

Selles jaotises õpime, kuidas juhtimisstruktuurid võimaldavad meil käitada individuaalseid koode ja mõnikord isegi korduvalt, kui vaja.

Avaldus kui saab 1. kontrollistruktuuriks. Järgmine juurutamine näitab, kuidas seda kasutatakse:

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

Püüame ülaltoodud koodi järk-järgult mõista ja õppida, kuidas seda saab kasutada teiste sarnaste hukkamiste jaoks.

1. ja 7. rea vahelised koodid on täpselt sarnased meie esialgse programmiga.

Esimene modifikatsioon toimub tegelikult 8. real.

int delayTime = 1000

Leiate, et see sarnaneb 1. rea koodiga, välistades selle, et sellel puudub termin konst.

Selle põhjuseks on lihtsalt see, et see kood ei ole konstant. Selle asemel on see määratletud kui muutuv , millel on programmeerimise käigus muutuva väärtusega omadus.

Ülaltoodud näites näete, et selle muutuja omistatakse väärtusega 1000. Pidage meeles, et sellised lokkisulgudesse suletud muutujad tuleb kirjutada rangelt ainult lokkisulgude paaridesse ja neile viidatakse kui 'kohalikele' muutujatele.

Teise võimalusena tunnustatakse muutujaid, mis ei kuulu lokkisulgudesse, nagu praegu arutlusel olevad, globaalseteks ja neid saab käivitada peaaegu kõikjal programmi koodis.

Edasi liikudes näete, et ka rea ​​9 ja 11 vahel olevad koodid sarnanevad esimese programmiga, sellegipoolest hakkavad asjad pärast 11. rida huvitama. Vaatame, kuidas!

delayTime = delayTime - 100

Selles koodis näeme, et hilinemisaeg muudetakse, lahutades sellest 100.

Tähendus 100 lahutatakse selle algväärtusest 1000, andes sellele uue väärtuse 900.

Järgmise pildi abil püüame mõista mõnda matduoperaatorit, mida kasutatakse arduino keeles.

Nüüd hindame koode rea 13 ja 15 vahel.

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

Ülaltoodud koodilõigu peamine eesmärk on tagada, et valgusdiood jätkab katkematut vilkumist.

Tulenevalt asjaolust, et originaalist lahutatakse 100 hilinemisaeg , see hoiab ära LED-i vilkumise nulli jõudmise ja võimaldab vilkumist pidevalt jätkata.

Järgmisel pildil on mõned võrdlusoperaatorid, mida me oma koodides kasutaksime:

Meie ülaltoodud koodis oleksime võinud testida, et kood on if(delayTime == 0).

Kuid kuna negatiivne näitaja võib olla sama halb, ei läinud me selle poole ja see on soovitatav tava.

Mõelge, mis oleks võinud olla tulemus, kui prooviksime delayTime -ist lahutada 100 asemel 300?

Nii et nüüd võite olla aru saanud, et kui delayTime on kirjutatud väiksemaks või võrdseks nulliga, siis viivitusaeg seatakse tagasi algsele joonisele 1000.

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

Koodi viimased 4 rida, nagu eespool näidatud, vastutavad LED-i pideva sisselülitamise / väljalülitamise, sisse / välja lülitamise eest.

Siin saate selgelt märgata, et arvude arvu asemel oleme viivitusaja määramiseks kasutanud muutujat, et saaksime seda koodi tööperioodi vältel vastavalt soovile kohandada. See on lahe, eks?

2.3 MUUD Avaldused

Siit saame teada, miks ja kuidas kui tähtajal võib olla klausel muud nii et see otsustab olukorra juhul kui väide on vale.

Mul on kahju, kui see tundub liiga segane, ärge muretsege, proovime sellest aru saada järgmise näite abil:

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

Ülaltoodust näete hästi, et 10. rea kood käivitatakse ainult siis, kui delayTime on väiksem või võrdne 100-ga, kui mitte, siis käivitatakse 13. reas olev kood, kuid mõlemat koos ei saa kunagi juhtuda, rakendatakse kas 10. või 13. rea koodi, mitte kunagi mõlemat.

Võib-olla olete märganud, et erinevalt sellest, mida tegime eelmises jaotises 2.2, ei võrrelnud me siin 0-ga, pigem 100-ga. Selle põhjuseks on see, et selles näites võrreldi ENNE kui lahutasime 100, vastupidi jaotises 2.2, võrdlesime PÄRAST me lahutatakse. Kas oskate öelda, mis oleks võinud juhtuda, kui võrdleksime 0 asemel 100?

2.4 WHOLE avaldused

TO samas avaldus on üsna sarnane kui avaldus, välja arvatud tõde, et see põhjustab koodiploki (mis võib olla lokkis sulgudes) korduvat käivitamist nii kaua, kuni tingimused on rakendatud, ja see töötab ilma muud avaldus.

Järgmine näide aitab teil sellest paremini aru saada

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

Kas oskate arvata, milleks ülaltoodud kood on programmeeritud? Noh, see on mõeldud LED-i vilkumiseks kiiremini ja seejärel aeglasemalt.

2.5 Mis on õige ja vale?

Programmeerimiskeeles vale tähistab nulli (0). Tegelikult ei kasutata 'tõelist', selle asemel eeldatakse, et kui miski pole vale, siis kõik, mis on lisatud, on tõsi.

See tundub vähe kummaline, kuid täidab seda tööd kenasti.

Püüame olukorrast aru saada järgmise näite abil.

Mõnikord võite kohata allpool toodud koodi:

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

See on kodeeritud nii, et LED-i rakendus jätkab jalgrattasõitu igavesti, kuna on saadaval palju toite.

Üks seda tüüpi koodide negatiivne külg võib tekkida siis, kui kasutaja kogemata == asemel rakendab a =.

Olen kindel, et juba teate, et = tähistab määrangut, see tähendab, et seda kasutatakse valitud väärtuse muutujaks tähistamiseks, a == kasutatakse testi täitmiseks, kui väärtus oli sama.

Oletame näiteks, et teil on vaja LED-i vilkumist järjestikuse kiiruse mustriga ja korduvalt, kuid valesti kasutasite == asemel vale =.

Seejärel kuvatakse kood järgmiselt:

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
}

Viga määrab delayTime -le 0 ja viib kui avaldus, et kontrollida, kas 0 oli tõene või mitte. Kuna 0 viitab valele, arvab ta, et see pole tõsi, ja peatab delayTime = 1000 jõustamise, kuid selle asemel funktsioon delayTime hoitakse tsükli () ajal 0-ga.

See tundub väga ebasoovitav !!

Seega kontrollige oma programmi alati üle, veendumaks, et te pole nii rumalaid vigu teinud.

2.6 Kombinatsioonid

Mõnikord võib tekkida vajadus katsetada mitut asja koos. Sarnaselt võiksite uurida, kas muutuja oli kahe numbri vahel. Kuigi seda saab rakendada if-lause mitu korda, võib parema ja lihtsama lugemise jaoks olla mugavam kasutada loogilisi kombinatsioone.

Kombinatsioonide rakendamine loogilistel tingimustel võiks toimuda kolme meetodiga, nagu on näidatud järgmises tabelis:

Oleks huvitav teada, et operaator NOT võib töötada lülitina muutuja jaoks, mille võib tähistada mõlemaks tõsi või vale (või LOW või HIGH).

Järgmist näidet illustreerib tingimus:

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

Siin kuvatakse ledState on Madal ja hiljem niipea, kui ledState = !ledState, muutub see KÕRGEKS. Järgmine silmus põhjustab ledState olla KÕRGE, kui ledState = !ledState on madal.

2.7 Lausete jaoks

Nüüd proovime mõista veel ühte juhtimisstruktuuri, mis on jaoks silmus. See võib olla väga mugav, kui soovite midagi mitu korda rakendada.

Mõistame seda järgmise näite abil:

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
}

Sarjast leiate midagi ainulaadset jaoks.

See on kood i ++? . See on kasulik programmeerijatele, kes on üsna laisad ja soovivad kodeerimist mugavate otseteede kaudu rakendada

Ülaltoodud terminit tuntakse liitoperaatoritena, kuna nad teevad tööd ühe omistamise operaatori ühendamiseks teise omistamise operaatoriga. Kõige populaarsemaid neist saab visualiseerida järgmises tabelis:

Leiate, et avaldises for 3 on 3 alamväidet. See on üles ehitatud järgmiselt:

for (statement1conditionstatement2){
// statements
}

Avaldus nr 1 esineb kohe alguses ja ainult üks kord. Seisundit kontrollitakse iga kord tsükli jooksul. Alati, kui see on tõsi lokkis sulgudes täidetakse järgnev avaldus nr 2. Juhul kui vale, süsteem hüppab järgmise koodiploki juurde.

Rohkemate valgusdioodide ühendamine

OK, nüüd näeme, kuidas saaksime ühendada rohkem LE-sid, et saada huvitavamaid efekte.

Ühendage LED-id ja Arduino, nagu allpool näidatud. Punane juhe ei ole tegelikult vajalik, kuid kuna alati on mõtet, et mõlemad toiteplatvormid oleksid leivaplaadil, on seadistamine mõttekas.

Parandame nüüd programmi, mis võimaldab meil kontrollida, kas meie riistvara on õigesti konfigureeritud või mitte.

Alati on soovitatav samm-sammult kodeerida ja käivitada programmide väikesed bitid, et kontrollida, kas vastavad riistvarad on õigesti ühendatud või mitte.

See aitab võimaliku tõrke kiiret otsimist.

Allpool olev koodinäide annab LED-idele 2 kuni 5 konkreetse mustri, pöörates neid üksteise järel tsükliliselt.

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

Nagu võite märgata, pole koodil midagi valesti, välja arvatud asjaolu, et see näeb välja pikk ja seetõttu altid vigadele.

Muidugi on ülaltoodud koodi kirjutamiseks paremaid viise, järgmine osa paljastab selle.

2.9 Massiivide tutvustamine

Massiivid võivad olla muutujate rühm, mida saab indekseerida indeksinumbritega. Järgmine näide aitab meil sellest paremini aru saada.

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, vaatame nüüd iga osa läbi ja mõistame, kuidas need tegelikult toimivad.

const int k_numLEDs = 4

Ülaltoodud kood määratleb, kui palju maksimaalseid elemente peaks meil massiivis olema. See kood aitab meil järgmistes jaotistes tagada, et kõik oleks massiivi sees kirjutatud ega midagi, kui massiiv lõpeb.

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

Selles järgmises reas seadistasime massiivi struktuuri. Sulgudes olevad numbrid tähistavad massiivi elementide arvu. Kuigi tegeliku koguse oleks võinud kirjutada, töötab konstantidena kirjutamine paremini. Väärtusi saab tavaliselt sulgudes komadega näha ja tähistada väärtused massiivile.

Kui leiate massiivi, mis on indekseeritud numbriga 0, näitab see massiivi esimest elementi, nagu on näidatud code: k_LEDPins is k_LEDPins[0]

Sarnaselt näidatakse viimast elementi kujul k_LEDPins[3], kuna arv 0 kuni 3 on 4.

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

Ülaltoodud kood näitab silmuse kasutamist iga massiivi elemendi läbimiseks ja nende väljunditeks seadmiseks. Massiivi kõigi elementideni jõudmiseks rakendame nurksulgudes koos indeksiga.

kui te ei tea, kas on võimalik kasutada tihvti nr 2, et kinnitada # 5 ilma massiivideta, on vastus jah, see on võimalik. Kuid selles näites seda ei tehta, sest me ei teinud seda niimoodi. Järgmistes jaotistes saate massiivilähenemise kõrvaldada, kui valitud väljundnõelad ei ole ühel joonel.

Edasi liikudes vaatame, mida järgmine koodiplokk teeb:

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

Siin liigub kood läbi iga valgusdioodi, et lülitada need järjestikku sisse 100 millisekundilise vahe või viivitusega.

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

Ülaltoodud koodi kasutamine näitab, kuidas silmuse jaoks saaks kasutada silmuse kaudu liikumiseks isegi vastupidises järjekorras.

See algab k_numLEDs - 1 -st, kuna massiivid on nullindekseeritud. Me ei alusta k_LEDPins[4] -st sest see tooks kaasa massiivi finiši ületamise.

Kood kasutab> = 0 kontrollimiseks, et indeksi 0 esimest elementi ei jäetaks kasutamata või ignoreeritaks.

3. peatükk

Mis on sisend

Nii et kas oleme õppinud, kuidas asju Arduino abil juhtida. Selles peatükis käsitleme, kuidas tajuda reaalset maailma, ühendades välistest parameetritest pärinevad sisendid.

3.1 Nuppude kasutamine

Me kõik teame, mis on nupp ja kuidas see töötab. See on omamoodi lüliti või nupp, mis ühendab signaali ühest vooluringi etapist teise hetkega, kui see on surutud, ja katkestab signaali vabastamisel.

3.1.1 Üks nupp ja LED

Ühendame Arduino nupuga Arduinoga vastavalt ülaltoodud üksikasjadele ja õpime seadistamise põhitööd ja rakendamist.

Näidatud nupul, mida nimetatakse ka mikrolüliti nupuks, on kokku 4 tihvti (2 paari mõlemal küljel). Lükates ühendatakse kõik tihvtipaarid sisemiselt ja võimaldavad nende vahel ühendust või juhtivust.

Selles näites kasutame ainult ühte paari nendest tihvtidest või kontaktidest, teine ​​paar on ebaoluline ja seetõttu ignoreeritakse.

Rakendame järgmist koodi ja kontrollime, kas see töötab!

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

Siit võite leida mõned asjad, mis tunduvad ebatavalised. Mõelgem neile samm-sammult välja.

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

Esimese asjana parandame buttonPin nagu SISEND. Noh, see on üsna elementaarne, ma tean.

Järgmisena määrame KÕRGE Euroopa SISEND tihvt. Sa ei tea, kuidas on võimalik sisendile midagi kirjutada? Muidugi, see võib olla huvitav.

Tegelikult lülitab Arduino sisendile HIGH määramine sisemise 20k Ohmi tõmbetakisti SEES (selle tihvti LOW lülitab selle VÄLJAS).

Teine küsimus, mis teile võib tekkida, on see, mis on tõmbetakisti. Olen kajastanud põhjalikku postitust tõmmetakistite kohta, mille te õppige seda siin .

OK, liikudes edasi, vaatame nüüd peamist silmuse koodi:

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

Kui vajutate surunuppu, ühendatakse juhtmega tihvt maapinnaga, mis muudab a MADAL selle tihvti külge. Ja survestamata olekus hoitakse sama tihvti KÕRGE või + 5V 20K sisemise tõmbetakisti kaudu.

Siinkohal soovime, et Arduino süttiks LED-nuppu, kui vajutatakse nuppu (LOW), seetõttu kirjutame väljundile HIGH iga LOW-i vastuse korral, kui seda vajutatakse.

3.1.2 Kaks nuppu ja LED

Noh, võite imestada, et ülaltoodud toimingut oleks saanud teha ka ilma Arduinota. Mõistan siiski, et see on järsk kivi, et õppida, kuidas Ardunoga nuppu saaks kasutada.

Siiani oleme uurinud koodide kirjutamist kas LED-i sisselülitamiseks (HIGH) või väljalülitamiseks (LOW).

Nüüd vaatame, kuidas LED-i heledust saaks Arduinoga juhtida.

Seda saab teha kahel viisil:

1. Piirates LED-i vooluhulka
2. Kasutades PWM või impulsi laiuse modulatsioon, mille korral LED-i toiteallikas lülitatakse soovitud kiirusega väga kiiresti sisse / välja, tekitades keskmise valgustuse, mille intensiivsus sõltub PWM-st.

Arduino plaadil on PWM-tugi saadaval tildega (~) tähistatud tihvtidel, milleks on tihvtid 3, 4,5,9,10 ja 11) 500 Hz juures (500 korda sekundis). Kasutaja suudab esitada mis tahes väärtuse vahemikus 0 kuni 255, kus 0 viitab väärtusele KÕRGE või ei + 5V ja 255 käsib Arduinol saada kogu aeg HIGH või + 5V. Nende käskude käivitamiseks peate pääsema soovitud väärtusega analogWrite () -sse.

Võite eeldada, et PWM on x / 255, kus x on soovitud väärtus, mille soovite analogWrite() kaudu saata.

Seadistage Arduino ja muud parameetrid, nagu eespool näidatud.

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

Siit leiate 3 rida, mis vajavad veidi selgitusi.

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

Rida: ledBrightness = constrain(ledBrightness, 0, 255) illustreerib unikaalset funktsiooni Arduinos, mida nimetatakse kitsenduseks ().

See sisemine funktsioon sisaldab koodi, mis sarnaneb järgmisega:

int piirang (int väärtus, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Kõik enne seda arutatud koodid algasid tühine , mis tähendas, et ei tagastatud midagi (tühine). Kusjuures ülaltoodud kood algab int , mis näitab, et see tagastab täisarvu. Selle kohta arutame lähemalt järgmistes jaotistes, pidage lihtsalt meeles, et täisarvul pole murdosa.

Nii, see tähendab, kood: ledBrightness = constrain(ledBrightness, 0, 255) määrab ledBrightness to be within the range of 0 and 255.

Järgmine rida kasutab analogWrite käsib Arduinol rakendada valitud tihvti PWM-i soovitud väärtusega.

Järgmine rida tekitab 20 millisekundi viivituse, see tagab, et me ei reguleeri söömist kiiremini kui 50 Hz või 50 korda sekundis. Seda seetõttu, et inimesed võivad olla palju aeglasemad kui Arduino. Seega, kui viivitust ei tehta, võib programm panna meid tundma, et esimese nupu vajutamine lülitas LED-i välja ja teise nupu vajutamine lülitas selle sisse (kinnitamiseks proovige ise).

3.2 Potentsiomeetrid

Liigume edasi ja õpime kasutama potentsiomeetrid Arduinoga.

Selleks, et teada saada, kuidas potentsiomeeter või pott töötab, saate seda lugeda artikkel .

Ühendage näidatud parameetrid oma Arduinoga, nagu eespool näidatud.

Potil on 3 terminali. Keskmine terminasl ühendub Arduinos ANALOG IN 0-ga. Kaks ülejäänud välisklemmi võivad olla ühendatud toiteplokkidega + 5V ja 0V.

Programmeerime ja kontrollime tulemusi:

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

Leiate paar asja, mis võivad tunduda täiesti uued ja mida pole meie üheski varasemas koodis.

1. Konstant kPinPot on tähistatud kui A0, kus A on otsetee ühe analoognõela kirjeldamiseks. Kuid A0 viitab ka tihvtile nr 14, A1 kuni tihvtile nr 15 ja nii edasi ning need võimaldavad teil kasutada digitaalset sisendit / väljundit juhuks, kui katse jaoks tihvtid otsa saavad. Kuid pidage meeles, et analoognõeltena ei saa kasutada digitaalseid tihvte.
2. Rida: ledBrightness = map(sensorValue, 0, 1023, 0, 255) esitleb Arduinos uut sisefunktsiooni, mida nimetatakse kaart (). See funktsioon kalibreeritakse uuesti antud vahemikust teise, mida nimetatakse kaart (väärtus, fromLow, fromHigh, toLow, toHigh). See võib muutuda ülioluliseks, kuna analogueRead annab väärtuse vahemikus 0-1023, kuid analoogkirjutus on võimeline aktsepteerima väärtust vahemikus 0-255.

Võite arvata, et kuna LED-i heledust on võimalik muuta muutuva takistuse kaudu, oleks selleks piisanud lihtsalt potist, miks Arduino kasutamine. Noh, jällegi on see lihtsalt vundament, et näidata, kuidas Arduinoga potti saaks konfigureerida.

Pole probleeme, nüüd teeme midagi, mida ei saa ilma Arduinota teha.

Selles katses näeme, kuidas poti erinevat takistust saaks kasutada LED-i vilkumise kiiruse või kiiruse reguleerimiseks.

Siin on programm:

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 Viivituse vältimine ()

Ülaltoodud kood näeb hea välja, kuid LED ei saa poti väärtust kontrollida enne, kui see läbib iga täistsükli. Pikemate viivituste korral läheb see protsess pikemaks, kui kasutaja peab ootama poti vastuse nägemist, kui ta seda liigutab. Seda viivitust saab vältida mõne intelligentse programmeerimisega, nii et see võimaldab kasutajal väärtust kontrollida minimaalsete viivitusteta. Siin on kood.

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

Mis siis ülaltoodud koodis erineb? Selle muudab järgmine joon.

long lastTime = 0

Kuni selle jaotiseni oleme arutanud muutujat int. Siiski võib teil olla palju muud tüüpi muutujaid, millele pääsete juurde. Loendit saab lugeda allpool:

Praegu võib olla ülitähtis teada, et suhteliselt suure hulga salvestamiseks int muutuja, võiksite seda terminit kasutada pikk või a pikk int.

Siin näete veel ühte huvitavat funktsiooni, mida nimetatakse millis ().

See annab ajavahemiku millisekundites, mida Arduino oma töö käigus algusest peale töötas (see lähtestatakse väärtusele 0 iga 50 päeva järel). Siin naaseb see pikk, sest kui see naaseb int , ei pruugi pikkade perioodide arvestamine olla võimalik. Kas saaksite täpselt vastata, kui kaua? Vastus on 32,767 sekundit.

Seetõttu viivituse () asemel kontrollime millis () ja kohe, kui konkreetne millisekundite arv saab otsa, muudame LED-i. Järelikult salvestame aja, kus seda viimati muutsime viimane kord muutuja, nii et see võimaldab meil seda soovi korral uuesti kontrollida.

3.3 RGB valgusdioodid

Siiani oleme mänginud ühevärvilise LED-iga. Kuigi LED-värvi saab muuta, asendades LED-i mõne muu värviga, aga kuidas oleks RGB-LED-idega LED-värvide muutmiseks ilma LED-sid vahetamata?

RGB LED on põhimõtteliselt LED, millel on punane, roheline ja sinine LED sisseehitatud ja ühendatud üheks LED-ks. Sellel on üks ühine juhe, mis läheb maapinnale või 0V toitetrassile, samal ajal kui ülejäänud 3 juhet toidetakse mitmekülgsete PWM-positiivsete signaalidega kavandatud rakendamiseks värvide segamine .

Võite seadistuse ühendada, nagu allpool näidatud:

See võib tunduda veidi keeruline, kuid tegelikult on see meie varasema LED-juhtimisdisaini koopia, kasutades PWM-i.

Siin on harjutusprogrammi kood:

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

Pärast selle koodi üleslaadimist vaadake lihtsalt, kuidas poti seadistused loovad RGB-le huvitava valgusefekti, see võib olla tõeline lõbu.

Leiate, et kui kõik 3 potti liigutatakse maksimaalsesse asendisse, näete valge värvi asemel punast. Seda seetõttu, et punane värv on kolme värvi seas kõige silmatorkavam ja seetõttu selles olukorras domineeriv. Funktsiooniga saate siiski katsetada kaart () , enne selle käivitamist LED-i punasesse ossa, et luua mõistlikum tasakaal.

Heli koos Arduinoga

Selles jaotises õpime, kuidas Arduino seadistusse põhilist heli ja muusikat lisada.

Näeme, kuidas lülitada signaal soovitud sagedusega ühendatud kõlarisse.

Täpsemalt öeldes proovitakse keskmist nooti, ​​mis on 440 Hz sagedusnoot.

Selleks mängime lihtsalt keskmist A-nooti ja optimeerime siinuslaine ruutlaine abil.

Samuti arvutame valemi kohtusse kaevamise aja, kui valjuhääldi võib SISSE jääda.

timeDelay = 1 sekund / 2 x toonisagedus.

timeDelay = 1 sekund / 2 x 440

timeDelay = 1136 mikrosekundit

4.1 Ühendame Arduino juhatuse

4.2 Lihtsa märkuse lisamine

Funktsiooni üle oleme juba arutanud viivitus () kus ühik on millisekundites (sekund / 1000), leiate siiski veel ühe funktsiooni delayMicroseconds() kus ühik on mikrosekundites, (millisekund / 1000).

Praeguse seadistuse jaoks programmeerime koodi, et lülitada valitud kõlariga ühendatud tihvt + 5 V sisse / välja, kiirusega 440 impulssi sekundis.

Tuletame meelde, et viimases arutelus määrasime kavandatud helimärkuse väärtuse 1136 mikrosekundit.

Nii et siin on selle jaoks programm, mis võimaldab teil kuulda 440 Hz helimärkust kohe, kui programmeerite ühendatud kõlariga arduino.

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

Ülaltoodud rakendusega on võimalik helimärkmeid teha, mis tähendab ka seda, et saame luua muusikat vastavalt meie enda valikule.

Koodi põhjal mõistame, et Arduino sisaldab paari integreeritud funktsiooni, mis lisaks aitab kaasa muusika loomisele.

Esimene neist on toon () mis töötab 2 elemendiga koos kolmanda valikulise elemendiga, mis on tähistatud kui toon (tihvt, sagedus, kestus). või toon (tihvt, sagedus)

Mõlemad on määratud vastama teie määratud ajaperioodile.

Ajavahemiku puudumisel jätkatakse muusika kõnet toon () täidetakse uuesti või kuni te täidate mitte üks ().

Seda tuleb teha viivitusfunktsiooni abil, juhul kui muusika mängimine on ainus oluline asi, mida rakendate.

Aja kestus võib olla ülioluline, kuna see võimaldab anda aega muusika esitamise pikkuseks, nii et kas saate vabalt teha muid asju. Niipea, kui kestus saab otsa, muusika peatub.

Järgmine funktsioon mitte üks () käsitleb ühte parameetrit ja peatab valitud tooni konkreetsel määratud pinil.

Omapärane hoiatus: millal iganes toon () funktsioon on rakendatud, PWM-funktsioon kontaktidel 3 ja 11 lakkab töötamast.

Seetõttu, kui programmis kasutatakse kõlari manust, veenduge, et te ei kasutaks mainitud tihvti kõlarite jaoks, proovige selle asemel mõnda muud kõlari kinnitamiseks mõeldud tihvti.

OK, nii et siin on programm muusika kõlaril rakendamiseks, ehkki see pole päris muusika, pigem alusskaala C noot.

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

Võib-olla olete ülaltoodud koodis märganud midagi uut ja nii #define .

See termin töötab kompileerimise ajal nagu arvuti otsimise ja asendamise käsk.

Alati, kui ta leiab tühiku ees esimese asja, asendab see rea ülejäänud osa (nn makrod).

Nii et selles näites, kui arvuti näeb MÄRKUS_E4 see asendab selle kiiresti kogusega 330.

Lisamärkuste ja kohandamise saamiseks võite viidata oma USB-mälupulgal olevale failile helikõrgused.h , kus enamus sagedusi võiks leida teie eelistuse järgi.

4.4 Funktsioonidega muusika

Ülaltoodud kood näeb hea välja, kuid tundub, et sellel on palju kordusi, nende korduste lühendamiseks peaks olema mingi meetod?

Siiani oleme töötanud kahe Arduinoga kaasneva olulise funktsiooniga. Nüüd võib olla aeg luua oma funktsioonid.

Iga funktsioon peab algama muutuja tüübist, millega see võib olla seotud. Näiteks funktsioon tühine viitab tüübile, mis ei tagasta midagi, mistõttu nimi on tühine. Pange tähele, et muutujate loendit oleme juba varasemates jaotistes arutanud, võiksite neile viidata.

Järelikult saab konkreetse funktsiooni nimi avatud sulgude '(' järgneb komadega eraldatud parameetrite loend.

Iga parameeter omandab oma tüübi koos nimega ja lõpuks sulgeb ')' sulgudes.

Neid parameetreid saab funktsiooni piires rakendada muutujate kujul.

Vaatame allpool näidet, kus töötame välja funktsiooni nimega meieToon () mõeldud ühendama toon () koos viivitus () rida, nii et funktsioon ei naase, kuni noot on tooni lõpetanud.

Rakendame need funktsioonid oma eelmises koodis ja saame järgmise programmi, vaadake viimaseid ridu:

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

Funktsioonid võivad olla programmile arusaadavamaks muutmiseks äärmiselt käepärased.

Järgnev on näide, kus me saame kahe massiivi abil täpsustada valiku tooni, mida me tahame mängida. Üks massiiv nootide säilitamiseks, teine ​​taktide säilitamiseks.

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

Esimesel real näete selgelt sissejuhatust # kaasata avaldus. Selle lause ülesandeks on kogu fail pakkumises jutumärkide vahele ja asetada see positsiooni # kaasata avaldus. Vastavalt standardreeglitele on need rangelt programmi alguses.

5. peatükk

Temperatuuri mõõtmine

Lihtsalt meenutades, pidage meeles, et suurte programmide kirjutamise asemel on alati mõistlik kirjutada ja analüüsida väikseid koodide osi, mis aitab vigade kiiret jälitamist.

5.1 Seeriamonitor

Siiani pole meie arutatud koodid kiire tõrkeotsingu lubamiseks nii lihtsad. Püüame siinkohal hõlbustada võimaliku probleemi jälgimist ja hõlpsamat lahendamist.

Arduinol on funktsioon, mis võimaldab arvutiga tagasi rääkida. Võib täheldada, et pin0 ja pin1 on üksteise kõrval tähistatud kui RX TX. Neid tihvte jälgib Arduinos asuv eraldi IC, mis uuendab neid USB-kaabli kaudu lugemiseks, kui see on arvutiga ühendatud.

Allpool olevas jaotises on näidatud täieõiguslik programm, minge sellest hoolimata, seejärel õpime koodis sisalduvate uute kirjete kohta. See kood on sama, mis väljendatud jaotises 2.2, välja arvatud see, et see sisaldab täiendavaid andmeid, mis võimaldavad meil tuvastada, milleks see on kodeeritud.

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

Siin saate tuvastada kaks uut asja, uus rida seadistamine () funktsioon.

Serial.begin(9600)

See rida lihtsalt väljendab vajadust kasutada Seeria1 kood selle jõustamiseks 9600 baudiga. (siin viitab seerianumber bitti saadetakse üksteise järel ja baud tähendab saatmise kiirust). See baudi väärtus ja seeriamonitori sees olev väärtus (me õpime seda hiljem) peavad olema võrdsed, vastasel juhul näitavad seeriamonitori andmed prügi. Standardiks 9600 on mugavam kasutada.

Teine uus kanne on järgmine

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

Siinkohal viitab teine ​​rida, et jadapordist väljuv järgmine asi algab järgmisel real. Nii erineb teine ​​rida rusikajoonest.

Veel üks asi, mida näete, on jutumärgid ('). Seda nimetatakse stringiks, mida kasutatakse siin ainult nagu konstandid, sest edasine arutelu sellel teemal võib olla liiga keerukas ja ulatusest väljas.

OK, saame nüüd ülaltoodud koodi Arduinosse üles laadida ja vaadata, mis juhtub.

Mis aga, näib, et midagi pole juhtunud, Arduino tihvti nr 13 LED vilgutas ja seiskus, samal ajal kui Tx LED jäi vilkuma.

Noh, sellepärast, et Serial Monitori aken pole veel fikseeritud.

Peate oma IDE-s klõpsama kastil Serial Monitor, nagu eespool näidatud. Ärge unustage kontrollida paremas alanurgas asuvat baudikiirust, vaikimisi peaks see olema 9600 ja vastab koodile. Kui see pole kindel, valige 9600.

Järgmises videoklipis selgitatakse, kuidas seda tehakse.

Nüüd liigume edasi ja õpime, kuidas ülaltoodud seeriamonitori funktsioon aitab seda töödelda temperatuuri mõõtmine Arduino abil

Temperatuuriandurina kasutame IC TMP36, mille vahemik on -40 kuni 150 kraadi Celsiuse järgi.

Seadistust saab näha allpool:

Järgmine kood käivitab temperatuuri mõõtmise, lugedes TMP36 anduri väljundit ja saates need ID seeriamonitorile.

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
}

Mõistame koodi ülevalt.

float temperatureC = getTemperatureC()

Siin näete, et oleme lisanud muutuja tüübi ujuk.

See on ainus muutuja tüüp, milles on salvestatud kõik, välja arvatud täisarvud (kümnend- või murdosadeta arvud).

Ujukmuutuja täpsus võib olla kuni 6–7 numbrit.

Külgnev kood getTemperatureC() on meie enda funktsioon, mis matemaatiliselt arvutab ja teisendab TMP36 andurilt tajutava pinge erinevuse Celsiuse kraadiks.

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
}

Koodide järgmises osas alates terminist analogIn() on määratud tagastama näitaja vahemikus 1 kuni 1023, on meil võimalik hinnata anduri pinget, korrutades meie näidu 5-ga ja jagades selle seejärel 1024-ga.

Andur TMP36 on ette nähtud 0,5 V tekitamiseks 0 ° C juures ja seejärel 10 mV iga Celsiuse kraadi tõusu jaoks.

Siin on ligikaudne arvutus, mille saame arvutustega luua:

Võite pidada oma esimeseks funktsiooniks, mis tagastab mingi väärtuse (pange tähele, et kõik siiani jäänud funktsioonid ei tagastanud väärtust, kuna need olid seda tüüpi tühine ).

Võite aru saada, et funktsioonist väärtuse saamiseks peate lihtsalt lisama tagasi järgneb soovitud number, mille soovite tagastada.

Kui me ütleme tagasi see tähendab, et funktsioon tagastab vastuse või vastuse alati, kui seda kutsutakse, mida saaks muutujale rakendada.

Kui see saadetakse seeriamonitorile, teisendatakse lugemine Fahrenheiti väärtuseks convertToF ().

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

See funktsioon võtab Celsiuse vahemiku ja teisendab selle Fahrenheiti väärtuseks.

Fahrenheiti teisendamiseks Celsiuseks rakendame valemi Fahrenheit = 9 / 5 (Celsiuse järgi) + 32.

5.3 LCD-liidestamine

Uurime nüüd, kuidas liidestada või ühendada LCD ekraan Arduinoga vajalike väljundite visuaalse kuvamise saamiseks.

Oma rakenduses kasutame 84x48 graafilist LCD-d, millel on horisontaalselt 84 pikslit või punkte ja vertikaalselt 48 pikslit. Kuna spetsiaalne kontroller muutub kõigi LCD-de jaoks hädavajalikuks, sisaldab käesolev seade ka seda PCD8544 kontrolleri kujul.

Selles õpetuses ühendame ülaltoodud LCD-mooduli Arduinoga ja rakendame ekraanil tekstsõnumite loomiseks teatud rutiini.

Järgmisel joonisel leiate üksikasjad LCD-liidese kohta koos väikese 3,3 V pinge regulaator . See regulaator on vajalik, kuna LCD on määratud töötama 3,3 V toiteallikaga.

LCD-moodulist näete ka 8 kinnitusdetaili. Pinouti spetsifikatsioone saab uurida järgmisest tabelist:

Vaatame nüüd, kuidas saame LCD ja asjakohased parameetrid oma Arduinoga ühendada. Üksikasju saab visualiseerida allpool toodud joonisel:

5.4 LCD-ga suhtlemine

Kuigi Arduinost on võimalik kirjutada keerukaid kootsioone LCD-ga suhtlemiseks, õpime pigem seda, kuidas sama teha ka teekide abil.

Raamatukogud sisaldavad valikut koode, mida saab kiiresti rakendada valitud Arduino programmi jaoks.

See võimaldab kasutajal funktsiooni hõlpsalt kutsuda, ilma et peaksite keerukat kodeerimistööd läbi tegema.

5.4.1 Kuidas teeki installida

Selleks peate oma arvutis Arduino IDE looma kataloogi nimega teegid, nagu selgitatud siin

5.4.2 LCD-toimingute rakendamine

Nii nagu meie eelmine lähenemine, kontrollime kõigepealt kogu koodi ja proovime seejärel mõista üksikute ridade üksikasju.

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

Rida sisaldab koodi #include

Kood #include käsib arvutil programmi koostamise käigus nimetatud faili kätte saada ja element #include faili sisuga asendada.

Elemendil #include võivad olla nurksulgud, mis näitavad otsimist raamatukogu kataloogis, alternatiivina võib see sisaldada ka jutumärke, mis näitavad otsimist samas kataloogis, kus programm asub.

Järgnevad koodiread väljendavad vedelkristallekraani ja seejärel kirjutame muutuja uue vormi:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Siinkohal väljendame muutujat nimega lcd, mille tüüp on PCD8544, ja juhendame arvutit oma Arduinoga seotud pinoutide ümber klassifitseerima.

Selles protsessis kirjeldame muutuja arvutile, juhendades, kuidas pin clk, din, dc ja reset on Arduinoga liidestatud.

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

Rida lcd.init() lähtestab LCD töö. Kui see on täidetud, sunnib järgmine rida kursori ekraani vasakus ülanurgas. Ja järgmine järgmine rida püüab printida sõnumi 'Tere, maailm'.

See näeb välja üsna identne tehnikaga, milles saatsime seeriamonitori kaudu sõnumeid. Ainus erinevus on koodi kasutamine lcd.print serial.print asemel.

Järgmist koodiplokki nimetatakse tegelikult korduvalt.

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

Selle rea kasutamine lcd.setCursor(0,1) fikseerime kursori 1. veeru vasakpoolsest veerust 0., LCD-ekraani kohal.

Järgmine rida kasutab otseteed: lcd.print(millis())

Kui meenutate, et oleme koostööd teinud millis() oma varasemates koodides oleksime võinud sama rakendada ka koodide kaudu:

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

Kuid kuna siin pole millisekundites mingeid ajavahemikke, siis saavutame selle lihtsalt saates millis() funktsioon otse lcd.print() .

5.5 Kogu asja ühendamine

OK, ühendame nüüd LCD-temperatuuri vooluringi tegemiseks kõik ülalpool õpitud koodid ja vaatame, kuidas see välja näeb:

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

Kõik tundub ülaltoodud programmis standardne, välja arvatud funktsiooni kasutamine setCursor () . Seda kasutatakse teksti joondamiseks võimalikult ekraani keskel.

Suurepärane! Ja palju õnne, olete just Arduino abil oma väikese LCD-temperatuuri indikaatori programmeerinud.

Praktilised Arduino rakendused

Kuna siinkohal oleme erinevaid programmeerimistehnikaid üksikasjalikult käsitlenud, on aeg need läbi vaadata, rakendades neid mõne kasuliku praktilise rakenduse jaoks.

Alustame anduritest ja vaatame, kuidas anduriseadmeid saaks Arduinoga kasutada, käivitades mõned näidiskoodid.

7.1 Sissejuhatus anduritesse

Selles õpetuses õpime mitmesuguseid andureid, mida saaks Arduinoga kasutada. Need võivad hõlmata selliseid seadmeid nagu valgusandur LDR, magnetiline halli efekti andur, kallutusandurid, vibratsiooniandur, rõhuandur jne.

Alustame liidesega valgusandur LDR Arduinoga, nagu on näidatud i järgmine skeem:

Nagu me kõik teame, on LDR valgust sõltuv takisti seade, mille takistus sõltub selle pinnale langeva ümbritseva keskkonna intensiivsusest.

Valguse intensiivsus on pöördvõrdeline LDR takistusnäiduga.

Siit saame teada, kuidas seda vara saab Arduinoga integreerida kasuliku rakenduse käivitamiseks:

Programmi täielikku koodi saab visualiseerida järgmiselt:

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

Kõiki koodis kasutatud parameetreid on meie kursusel juba arutatud, mille oleme siiani õppinud. Ridu saate kontrollida, viidates asjakohastele jaotistele.

Väärtused valiti juhuslikult, neid saab hõlpsasti muuta vastavalt oma eelistustele.

Kaldeandur

Kaldeandur on lihtne seade, mida saab kasutada kallutamise tuvastamiseks mis tahes objektil, kuhu see on paigaldatud. Põhimõtteliselt on seadme sees metallkuul, mis kallutades rullub üle paari kontakti, põhjustades juhtivust üle nende kontaktide. Neid kontakte, mis on lõpetatud kallutuslüliti juhtmetena, kasutatakse välise vooluahelaga juhtimise tuvastamiseks kallutamise tõttu ja soovitud väljundrakenduse aktiveerimiseks.

Nüüd vaatame, kuidas a kallutusandur seadme saab juhtmega ühendada. Allolev pilt annab meile idee kogu konfiguratsiooni kohta:

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

Selles näites kasutatakse kallutusindikaatorina vaikimisi tihvti nr 13 LED-i.

Siin on selgelt näha tõmbetakisti kaasamine, üsna sarnane sellele, mida me tegime jaotises 3.1. Seetõttu näitab mõiste LOW, et kallutusfunktsiooni ei käivitata.

7.4 Reed-lüliti relee (kääbusmagnetiga aktiveeritud relee)

Nüüd vaatame, kuidas Arduino abil relee lüliti või magnetvälja andur ühendada. Pilliroo relee on omamoodi lüliti, mis aktiveerub või juhib, kui selle lähedale viiakse magnetväli või magnet. Põhimõtteliselt on sellel miniatuurse klaasist korpuse sees paar ferromagnetilisi kontakte, mis magnetilise tõmbe tõttu ühenduvad või saavad kontakti alati, kui magnet on selle lähedal. Kui see juhtub, näitavad kontaktide klemmid kontaktide sulgemise tõttu juhtivust.

Ka siin kasutame vastuse näitamiseks tihvti nr 13 LED-i. Vajaduse korral võite ühendada selle tihvti välise LED-i vastavalt meie varasematele selgitustele.

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

Kooditerminid peaksid olema tuttavad ja ise seletatavad.

7.5 Vibratsiooniandur Piezo muunduri abil

Järgmises näidisprogrammis näeme, kuidas a piesoandur võib kasutada vibratsiooniandurina LED-i valgustamiseks Arduino kaudu.

Piesoelement on tegelikult seade, mis tekitab vibratsiooni või võnkumisi, kui selle klemmidele rakendatakse sagedust. Kuid sama piesot saab kasutada ka vastupidises protsessis elektriliste impulsside genereerimine vastusena tema kehale rakendatavale vibratsioonile. See vibratsioon võib olla pieso pinnale koputamise või löögi kujul.

Seadistage Arduino ja piesoelement vastavalt järgmisele joonisele

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

Lävi 100 võetakse kasutusele ainult selleks, et veenduda, et Arduino reageerib ainult ehtsatele vibratsioonidele koputuste kaudu, mitte teistele väiksematele vibratsioonidele, näiteks valjusti või sarvedest.

A5 tihvti valik pole kohustuslik, saate valida mis tahes muu analoogsisendi vastavalt oma eelistustele ja sobitades selle programmi koodiga.

Servomootori kasutamine koos Arduinoga

Servomootor on alalisvoolumootori tüüp, mida saab pöörata täpsete nurkade järgi vastavalt konkreetse rakenduse vajadustele. Seda saab teha, rakendades arvutatud käsku mootori asjakohastele sisenditele, et tekitada mootoril täpne pöördenurk või pöördenurk 180 kraadises vahemikus.

Tavaliselt on servomootoril 3 juhet või sisendit. Positiivsed juhtmed on tavaliselt punast värvi, negatiivne või maandusjuhe on must, mille käsujuhtme või signaaltraadi värv on tavaliselt valge või kollane.

Arduino hõlbustab servomootori juhtimist sisseehitatud tugikeeles, mis muudab juhtimise servomootorite jaoks väga mugavaks ja ideaalseks.

Järgmine näide näitab meile põhilist seadistusprogrammi servomootori juhtimise rakendamiseks Arduino kaudu:

Kood on toodud allpool:

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

Paari uut sissekannet näeme siin. Üks, mis ütleb servo kinnitatud juhtmele, millisele pinile see on määratud. Teine on kood, mis annab tihvtile servo pöördenurga määramiseks väärtuse vahemikus 0 kuni 180.

Järeldus

Arduino teema võib olla lõpmatu pikk ja seetõttu väljaspool seda artiklit. Loodan siiski, et ülaltoodud juhendaja oleks kindlasti pidanud aitama teil õppida Arduino põhitõdesid ja mõista olulisi parameetreid erinevate rakenduse näidiskoodide kaudu.

Loodetavasti võidakse siin lisateavet aeg-ajalt värskendada, kui see on saadaval.

Seniks aga nautige oma programmeerimiskursust, Head Arduinoing teile !!