Učenje osnovnega programiranja za Arduino - Vadnica za novince

V tej vadnici se bomo naučili, kako narediti osnovno programiranje Arduino s pomočjo kod in vzorčnih programov. Ta vadnica je lahko izjemno dragocen tečaj za vse novince, ki želijo razumeti osnove s preprostim in razumljivim jezikom.

Uvod

Po navedbah wikipedia mikrokrmilnik je enakovreden mini računalniku, ki je vgrajen v enem samem čipu z lastnim procesorjem, programibilnimi vhodi, pomnilnikom in izhodno zunanjo opremo.

Mikrokrmilnik postane tako uporaben za uporabnika, saj ima vgrajen procesor, pomnilnik in vhodno / izhodna vrata (imenovana tudi GPIO ali splošni vhodni / izhodni zatiči), ki jih lahko uporabnik nadzoruje v skladu s poljubnimi specifikacijami.

V tej vadnici bomo sodelovali z Arduino Uno ploščo za učenje in preizkušanje programov. Za testiranje in integracijo sklopa strojne opreme bomo uporabili ploščo.

Zdaj pa pojdimo hitro in se naučimo, kako začeti s programiranjem Arduino.

1.2 Namestitev programske opreme (Windows)

Za to boste potrebovali dostop do interneta, ki bi ga očitno imeli v računalniku. Pojdite na naslednjo povezavo in prenesite programsko opremo IDE:

Datoteka Windows ZIP za ne skrbniško namestitev

Po prenosu boste v mapi za prenos našli ikono za namestitev Arduino, ki bi izgledala takole:

Ko to dobite, lahko preprosto dvokliknete nanj in v svoj računalnik namestite integrirano razvojno okolje (IDE) Arduino. Celoten postopek si lahko ogledate v naslednjem videu:

1.4 Začenši z našim prvim krogom

Preden se začnemo učiti dejanskih tehnik programiranja, bi bilo za vsakega novinca koristno začeti z osnovno komponento, kot je LED, in razumeti, kako jo povezati z Arduinom.

Kot vemo, je LED dioda, ki oddaja svetlobo in ima polariteto in ne bo svetila, če ni povezana z desnimi napajalnimi poli.

Drug vidik LED-jev je, da te naprave delujejo z nizkim tokom in se lahko takoj poškodujejo, če ustrezno izračunani upor ni zaporedoma priložen enemu od njegovih zatičev.

Praviloma je 330 ohmov 1/4 vata povsem idealno za vsakih 5 V dviga vhodnega vhoda, da se tok omeji na zahtevano varno raven. Zato je lahko za 5V 330 ohmov, za 10V pa 680 ohmov itd.

Uporaba Breadboard za skupščino

Prepričajte se, da veste, kako uporabljati plošča preden poskusite z vadnico, razloženo v tem poglavju, saj bi za vse eksperimente tukaj uporabili ploščo.

Osnovna nastavitev LED povezave je prikazana spodaj:

Zgoraj lahko vidite 3 osnovne komponente:

1. 5 mm, 20 mA LED
2. upor 330 ohmov 1/4 vatov
3. An Plošča Arduino

Samo sestavite sistem po diagramu.

Nato priključite 5 V iz računalniškega USB v Arduino. Takoj, ko to storite, boste videli, da se zasveti LED.

Vem, da je to precej osnovno, vendar je vedno dobro začeti od začetka. Bodite prepričani, da bodo stvari postajale vedno bolj zanimive, ko bomo napredovali.

1.5 Krmiljenje LED z Arduino

Zdaj se bomo naučili, kako upravljati LED s programom Arduino.

Za pisanje programa moramo imeti vsaj 2 funkciji v vsakem programu.

Funkcijo lahko razumemo kot vrsto programskih stavkov, ki jim je mogoče dodeliti ime, kot je navedeno spodaj:

1. nastaviti() ta se pokliče ali izvede med zagonom programa.
2. zanka () to se kliče ali izvaja ponavljajoče se v celotnem operativnem obdobju Arduina.

Torej, čeprav morda nima praktične funkcionalnosti, lahko tehnično najkrajši zakoniti program Arduino zapišemo kot:

Najenostavnejši program

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

Morda ste opazili, da se v mnogih programskih jezikih sistem začne s preprostim tiskom 'Hello, World' na zaslonu

Elektronski ekvivalent tega stavka pri interpretaciji mikrokrmilnika je utripanje LED in vklop.

To je najosnovnejši program, ki ga lahko napišemo in izvedemo za pravilno delovanje sistema.

Postopek bomo poskusili implementirati in razumeti z naslednjo kodo:

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

V redu, zdaj poglejmo, kaj pomeni vsaka vrstica kode in kako deluje za izvajanje funkcije:

const int kPinLed = 13

To deluje kot konstanta, ki nam omogoča, da jo uporabljamo med celotnim tečajem programiranja, ne da bi morali uporabiti dejansko vrednost, ki je nastavljena nanjo.

V skladu s standardnimi pravili so takšne konstante prepoznane z začetno črko do . Čeprav to ni obvezno, naredi stvari jasnejše in lahko razumljive, kadar koli želite prebrati podrobnosti kode.

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

Ta koda konfigurira poseben zatič, na katerega je priključena naša LED. Z drugimi besedami, koda Arduinu nalaga, naj nadzira 'zapis' na tem zatiču, namesto da bi ga 'prebral'.

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

Zgornje vrstice označujejo dejansko izvedbo aplikacije. Koda se začne s pisanjem in upodabljanjem HIGH na ustrezni LED povezavi, pri čemer se LED vklopi.

Tu izraz HIGH preprosto pomeni, da dobite + 5V na zadevni zatič Arduino. Izraz LOW preprosto označuje ničlo ali 0V na določenem zatiču.

Nato pokličemo delay() katerega funkcija je ustvariti zakasnitev v milisekundah (1/1000 sekunde). Ker je vnesena številka 500, bo izvedena zakasnitev trajala 1/2 sekunde.

Takoj, ko poteče ta 1/2 sekunde, se izvede naslednja vrstica, ki izklopi LED z LOW izrazom na istem zatiču.

Naslednja vrstica še enkrat ustvari 1/2 sekundo zakasnitve, da LED ostane vklopljen 1/2 sekunde.

In postopek se nadaljuje z izvajanjem vrstic kode, dokler Arduino ostane v pogonu.

Preden nadaljujete na naslednjo stopnjo, vam priporočam, da programirate zgornjo kodo in preverite, ali lahko pravilno izvedete zaporedje LED ON / OF.

Ker je privzeta LED v Arduinu povezana s pinom 13, se mora takoj odzvati na zgornji program in začeti utripati. Če pa ugotovite, da vaša zunanja LED ne utripa, lahko pride do napake v povezavi z vašo LED, poskusite obrniti polarnost LED in upamo, da bo tudi utripala.

Z zakasnilnim časom se lahko igrate tako, da spremenite številko '500' na neko drugo vrednost in najdete LED, ki 'posluša' ukaze in povzroči, da utripa glede na določene vrednosti zakasnitve.

Ampak ne pozabite, če vidite, da LED ne utripa s konstantno hitrostjo 1 sekundo, ne glede na spremembo časa zakasnitve, to lahko pomeni, da koda zaradi neke napake ne deluje. Ker bo Arduino privzeto programiran s hitrostjo utripanja 1 sekundo. Zato morate to stopnjo spremeniti s svojo kodo, da potrdite njeno pravilno delovanje.

1.7 Komentarji

Vrstice kod, ki smo jih razumeli zgoraj, so bile posebej napisane za računalniško programsko opremo.

Da bi zagotovili, da se uporabnik lahko sklicuje na pomen vrstic in jih razume, je pogosto koristno in smiselno razlago zapisati poleg želenih vrstic kod.

Ti se imenujejo komentarji ki so napisani samo za sklicevanje na ljudi ali uporabnike in so kodirani tako, da jih računalniki lahko varno ignorirajo.

Jezik teh komentarjev je napisan v nekaj oblikah:

1. Slog bloka komentarja, pri čemer je opis komentarja zaprt pod začetnim simbolom / * in končnim simbolom * /
2. To ni treba omejiti v eni vrstici, temveč jo je mogoče razširiti na naslednje vrstice, odvisno od dolžine komentarja ali opisa, kot je prikazano v naslednjem primeru:

/ * To je komentar * /

/ * Tudi to je * /

/ * In
* to
* kot
* vodnjak * /

Za pisanje hitrega enovrstičnega opisa komentarja sta na začetku dovolj dve poševnici //. To pove računalniku, da ta vrstica nima nič skupnega z dejansko kodo in jo je treba prezreti. Na primer:

// To je komentar, ki ga računalniki ne bodo upoštevali.

Tu je primer za referenco:

/*
* 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 Odpravljanje težav

Če opazite, da vaš program med prevajanjem kaže »napako« ali kakšno drugo težavo, vam bodo naslednji nasveti verjetno pomagali znova preveriti kodo in se znebiti ovire.

1. Jezik vašega programa bo občutljiv na velike in male črke. Na primer izraz myVar ni mogoče zapisati kot MyVar.
2. Razmaki vseh vrst, ki jih lahko izvede tipkanje s tipkovnico, so navsezadnje upodobljeni kot en sam presledek in je viden ali razumljiv samo vam, računalnik tega ne bo upošteval. Preprosto povedano, kakršni koli prosti presledki ne bodo vplivali na rezultate kode.
3. Vsak blok kode mora biti zaprt z levim in desnim zavitim oklepajem, '{' in '}'
4. Številčne številke ne smejo biti ločene z vejicami. Na primer, 1000 morda ni zapisano kot 1000.
5. Vsaka vrstica kode, zaprta med zavitimi oklepaji, se mora zaključevati s podpičjem

Ustvarjanje zanimivega zaporedja LED luči z Arduinom

V prejšnjem poglavju smo se naučili, kako neprekinjeno utripati LED VKLOP / IZKLOP s konstantno hitrostjo zakasnitve.

Zdaj bomo izvedeli, kako je mogoče z nadgradnjo programske kode izvajati različne vzorce zakasnitve na isti LED.

Ne bomo uporabljali zunanje LED, raje uporabljali privzeto LED, vgrajeno v ploščo Arduino na pin # 13. Ta majhen SMD LED lahko najdete tik za priključkom USB.

2.2 Razumevanje izjav IF

V tem poglavju bomo izvedeli, kako nam nadzorne strukture omogočajo izvajanje posameznih kod in včasih celo ponavljajoče se, kot je potrebno.

Izjava če postane 1. nadzorna struktura. Naslednja izvedba prikazuje, kako se uporablja:

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

Poskusili bomo postopno razumeti zgornjo kodo in se naučili, kako jo lahko uporabimo za druge podobne izvedbe.

Kode med 1. in 7. vrstico so popolnoma podobne našemu začetnemu programu.

Prva sprememba se dejansko zgodi v 8. vrstici.

int delayTime = 1000

Ugotovite lahko, da je to podobno kodi v 1. vrstici, razen dejstva, da v njej manjka izraz const.

To je preprosto zato, ker ta koda ni stalnica. Namesto tega je to opredeljeno kot spremenljivka , ki ima med programiranjem lastnost spremenljive vrednosti.

V zgornjem primeru lahko vidite, da je tej spremenljivki pripisana vrednost 1000. Ne pozabite, da morajo biti takšne spremenljivke, ki so zaprte v zavite oklepaje, strogo zapisane samo v parih kodrastih oklepajev in se imenujejo 'lokalne' spremenljivke.

Druga možnost je, da so spremenljivke, ki naj bi bile zunaj zavitih oklepajev, na primer tista, o kateri razpravljamo zdaj, prepoznane kot 'globalne' in bi se lahko izvajale skoraj kjer koli znotraj programske kode.

Ko se premikate naprej, lahko vidite, da so tudi kode med vrsticami 9 in 11 podobne prvemu programu, vseeno pa stvari začnejo postajati zanimive po 11. vrstici. Poglejmo, kako!

delayTime = delayTime - 100

V tej kodi vidimo, da je privzeta vrednost delayTime se spreminja tako, da se od njega odšteje 100.

Pomen 100 se odšteje od začetne vrednosti 1000 in mu tako da novo vrednost 900.

Skozi naslednjo sliko bomo poskušali razumeti nekaj matematičnih operaterjev, ki se uporabljajo v jeziku Arduino.

Zdaj pa ocenimo kode med vrsticami 13 in 15.

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

Glavni cilj zgornje kode je zagotoviti, da LED še naprej utripa brez kakršnih koli prekinitev.

Ker se od prvotnega odšteje 100 delayTime , preprečuje, da bi utripanje LED doseglo ničlo in omogoča neprekinjeno utripanje.

Naslednja slika prikazuje nekaj primerjalnih operaterjev, ki bi jih uporabili v naših kodah:

V zgornji kodi bi lahko preizkusili kodo if(delayTime == 0).

Ker pa je negativna številka lahko enako slaba, se nismo strinjali in to je priporočljiva praksa.

Pomislite, kakšen bi lahko bil izid, če bi od delayTime poskušali odšteti 300 namesto 100?

Torej ste morda že ugotovili, da če delayTime je zapisano kot manj ali enako nič, potem bi bil čas zakasnitve nastavljen na prvotno številko 1000.

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

Zadnje 4 vrstice kode, kot je prikazano zgoraj, so odgovorne za neprekinjeno vklop / izklop LED.

Tu lahko jasno opazite, da smo namesto številke slike uporabili spremenljivko za določanje časa zakasnitve, tako da jo lahko prilagodimo, kot želimo, med operativnim obdobjem kode. To je v redu, kajne?

2.3 DRUGE izjave

Tukaj bomo izvedeli, zakaj in kako če izraz lahko vsebuje klavzulo drugače tako da odloči o situaciji v primeru če izjava je napačna.

Žal mi je, če se to sliši preveč zmedeno, ne skrbite, poskusili bomo to razumeti z naslednjim primerom:

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

V zgornjem lahko dobro vidite, da se v 10. vrstici koda izvede samo, ko delayTime je manjši ali enak 100, če se ne, potem se izvede koda v 13. vrstici, vendar se obe skupaj nikoli ne moreta zgoditi, bodisi 10. vrstica bodisi koda 13. vrstice bosta izvedeni, nikoli obe.

Morda ste opazili, da za razliko od tega, kar smo storili v prejšnjem oddelku 2.2, tukaj nismo primerjali z 0, temveč v primerjavi s 100. To je zato, ker smo v tem primeru v PRED, ko smo odšteli 100, nasprotno v oddelku 2.2, primerjali PO odšteti. Ali lahko ugotovite, kaj bi se lahko zgodilo, če bi primerjali 0 namesto 100?

2.4 Izjave WHILE

TO medtem izjava je precej podobna če izjava, razen resnice, da povzroča ponavljajoče se izvajanje bloka kode (ki je lahko med skodranimi oklepaji) toliko časa, ko veljajo pogoji, in to deluje brez drugače izjavo.

Naslednji primer vam bo pomagal bolje razumeti to

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

Ali lahko uganite, za kaj je programirana zgornja koda? No, zasnovan je tako, da hitreje in nato počasneje utripa LED.

2.5 Kaj je res in kaj ne?

V programskem jeziku, napačno se nanaša na nič (0). Dejansko se 'true' ne uporablja, temveč se domneva, da kadar nič ni napačno, je vse, kar je vključeno, res.

Zdi se malo nenavadno, vendar delo opravi precej lepo.

Situacijo bomo poskušali razumeti z naslednjim primerom.

Včasih lahko naletite na kodo, kot je navedena spodaj:

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

To je kodirano, izgleda, da bo izvedba LED ohranila kolesarjenje za vedno, dokler je na voljo moč.

Vendar pa lahko pride do slabe strani te vrste kode, če uporabnik po naključju uporabi = namesto ==.

Prepričan sem, da že veste, da = pomeni dodelitev, kar pomeni, da se uporablja za določitev izbrane vrednosti spremenljivki, medtem ko se == uporablja za uveljavitev testa, če je bila vrednost enaka.

Recimo, da ste na primer potrebovali LED, da utripa z zaporednim vzorcem hitrosti in večkrat, vendar nepravilno uporabljate = namesto ==.

Nato bi bila koda videti tako:

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
}

Napaka bo dodelila 0 delayTime in vodila do če izjava za preverjanje, ali je 0 res ali ne. Ker se 0 nanaša na false, bo mislil, da ni res, in bo ustavil uveljavljanje delayTime = 1000, ampak namesto funkcije delayTime med potekom zanke () ostane na 0.

To je videti zelo nezaželeno !!

Torej, vedno dvakrat preverite svoj program in se prepričajte, da niste storili takšnih neumnih napak.

2.6 Kombinacije

Včasih boste morda čutili potrebo po preizkušanju več stvari skupaj. Morda boste morda želeli preveriti, ali je bila spremenljivka med dvema številkama. Čeprav je to mogoče izvesti z uporabo stavka if večkrat, je morda boljše uporabiti logične kombinacije za boljše in lažje branje.

Izvajanje kombinacij v logičnih izrazih je mogoče izvesti s 3 metodami, kot je prikazano v naslednji tabeli:

Zanimivo bi bilo vedeti, da lahko operater NOT deluje kot preklopnik za spremenljivko, ki je lahko označena za eno prav ali napačno (ali NIZKO ali VISOKO).

Naslednji primer ponazarja stanje:

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

Tukaj je ledState bo NIZKO in bo takoj, ko ledState = !ledState, postane VISOKO. Naslednja zanka bo povzročila ledState biti VISOK, ko ledState = !ledState je LOW.

2.7 ZA izjave

Zdaj bomo poskušali razumeti še eno nadzorno strukturo, ki je za zanko. To je lahko zelo priročno, če želite nekajkrat več uporabiti.

Razumimo to z naslednjim primerom:

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
}

V vrstici lahko najdete nekaj unikatnega za.

To je koda i ++? . To je koristno za programerje, ki so precej leni in želijo izvajati kodiranje s priročnimi bližnjicami

Zgornji izraz je znan kot sestavljeni operaterji, saj opravljajo delo kombiniranja enega operaterja dodelitve z drugim operaterjem dodelitve. Najbolj priljubljene med njimi si lahko ogledate v naslednji tabeli:

Ugotovili boste, da so v izjavi for 3 podizjave. Strukturiran je, kot je prikazano spodaj:

for (statement1conditionstatement2){
// statements
}

Izjava št. 1 se pojavi takoj na začetku in samo enkrat. Stanje se preizkusi vsakič med potekom zanke. Kadarkoli je prav znotraj skodranih oklepajev se uveljavi naslednji stavek # 2. V primeru a napačno, sistem skoči na naslednji blok kode.

Priključitev več LED

V redu, zdaj bomo videli, kako lahko povežemo več LE-jev, da dobimo bolj zanimive učinke.

Priključite LED in Arduino, kot je prikazano spodaj. Rdeča žica pravzaprav ni potrebna, a ker je vedno dobro, da sta obe dovodni tirnici vključeni v ploščo, je postavitev smiselna.

Zdaj popravimo program, ki nam bo omogočil, da preverimo, ali je naša strojna oprema pravilno konfigurirana ali ne.

Vedno je priporočljivo kodirati in izvajati majhne koščke programov po korakih, da preverite, ali je ustrezna strojna oprema pravilno ožičena ali ne.

To pomaga hitro odpraviti morebitne napake.

Spodnji primer kode ponuja LED od 2 do 5 poseben vzorec tako, da jih ciklično obrača drug za drugim.

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

Kot lahko opazite, s kodo ni nič narobe, razen dejstva, da je videti dolga in zato nagnjena k napakam.

Seveda obstajajo boljši načini za pisanje zgornje kode, razkril jo bo naslednji razdelek.

2.9 Predstavljamo polja

Polja so lahko skupina spremenljivk, ki jih je mogoče indeksirati z indeksnimi številkami. Naslednji primer nam bo pomagal bolje razumeti.

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

V redu, poglejmo zdaj vsak odsek in razumemo, kako dejansko delujejo.

const int k_numLEDs = 4

Zgornja koda določa, koliko največ elementov naj bi imeli v matriki. Ta koda nam pomaga v naslednjih razdelkih zagotoviti, da je vse zapisano v matriki in nič, ko se matrika konča.

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

V tej naslednji vrstici smo nastavili matrično strukturo. Številke v oklepaju označujejo število elementov v matriki. Čeprav bi lahko napisali dejansko količino, pisanje kot konstante deluje bolje. Vrednosti je običajno mogoče videti v oklepaju z vejicami in jih določiti v matriki.

Ko najdete matriko, indeksirano s številko 0, to pomeni prvi element v matriki, kot je prikazano v code: k_LEDPins is k_LEDPins[0]

Podobno bo zadnji element prikazan kot k_LEDPins[3], saj je število od 0 do 3 4.

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

Zgornja koda prikazuje uporabo zanke za nadaljevanje vsakega elementa matrike in za njihovo nastavitev kot IZHODI. Izvajamo oglate oklepaje skupaj z indeksom, da dosežemo vsak element v matriki.

če se sprašujete, ali je mogoče uporabiti pin # 2 za pin # 5 brez nizov, je odgovor pritrdilen, je mogoče. Toda v tem primeru to ni storjeno, ker tega nismo storili na tak način. V naslednjih odsekih lahko odpravite pristop z matriko, če izbrani izhodni zatiči niso v vrstici.

Kar naprej, poglejmo, kaj počne naslednji blok kode:

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

Tu se koda nadaljuje skozi vsako LED, da jih zaporedno vklopi z razmikom ali zakasnitvijo 100 milisekund.

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

Uporaba zgornje kode prikazuje, kako se uporablja za zanko se lahko uporablja za premikanje skozi zanko tudi v obratnem vrstnem redu.

Začne se z k_numLEDs - 1, ker so nizi nič indeksirani. Ne začnemo od k_LEDPins[4] ker bi to povzročilo prečkanje cilja niza.

Koda uporablja> = 0 za preverjanje, da prvi element v indeksu 0 ne bo zgrešen ali prezrt.

3. poglavje

Kaj je vhod

Torej smo se naučili, kako upravljati stvari z uporabo Arduina. V tem poglavju bomo razpravljali o tem, kako zaznati resnični svet s povezovanjem vhodnih podatkov zunanjih parametrov.

3.1 Uporaba tipk

Vsi vemo, kaj je gumb in kako deluje. To je nekakšno stikalo ali gumb, ki za trenutek poveže signal z ene stopnje vezja na drugo, medtem ko je ta v depresivnem stanju, in prekine signal, ko se sprosti.

3.1.1 En gumb in LED

Arduino bomo s pritiskom na gumb povezali z Arduinom v skladu z zgornjimi podrobnostmi in se naučili osnovnega delovanja in izvedbe nastavitve.

Označeni gumb, ki se imenuje tudi mikro stikalo, ima skupaj 4 nožice (2 para na vsaki strani). Ko jih potisnete, se vsak par zatičev medsebojno poveže in omogoča povezavo ali prevod med njimi.

V tem primeru uporabljamo samo en par teh nožic ali kontaktov, drugi par je nepomemben in je zato prezrt.

Nadaljujmo, uporabljamo naslednjo kodo in preverimo, ali deluje!

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

Tu lahko najdete nekaj stvari, ki so videti nenavadne. Upoštevajmo jih korak po pamet.

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

Prva stvar, ki jo naredimo, je popraviti buttonPin kot VHOD. No, to je povsem osnovno, vem.

Nato dodelimo VISOKO do VHOD pin. Sprašujete se, kako je mogoče kaj napisati na vhod? Seveda, to je lahko zanimivo.

Pravzaprav dodelitev HIGH vhodu Arduino vklopi notranji 20k Ohm vlečni upor (LOW na tem zatiču ga izklopi).

Še eno vprašanje, ki ga lahko, je, kaj je pull-up upor. Obdelal sem obsežen prispevek o vlečnih uporih, ki ste ga nauči se tukaj .

V redu, gremo naprej, poglejmo zdaj kodo glavne zanke:

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

Ko pritisnete gumb, se žični zatič priključi na maso, kar naredi a NIZKO na tisti žebljiček. In medtem ko je v stisnjenem stanju isti pin drži VISOKO ali + 5V prek 20K notranjega vlečnega upora.

Tu želimo, da Arduino zasveti LED, ko pritisnete tipko (LOW), zato za vsak odziv LOW s tipke med pritiskom na HIGH pišemo HIGH.

3.1.2 Dva gumba in LED

No, morda se sprašujete, da bi lahko zgoraj prikazano dejanje izvedli tudi brez Arduina. Vendar razumem, da je to močan kamen, da se naučim, kako se lahko gumb uporablja z Ardunom.

Do tega trenutka smo preučevali pisanje kod za VKLOP (VISOKO) ali IZKLOP (LOW) LED.

Zdaj pa poglejmo, kako lahko svetlost LED nadziramo z Arduinom.

To lahko storite na dva načina:

1. Z omejitvijo količine toka na LED
2. Z uporabo PWM ali modulacija širine impulza, pri kateri se napajanje LED diode zelo hitro vklopi / izklopi z določeno želeno hitrostjo, kar povzroči povprečno osvetlitev, katere intenzivnost bi bila odvisna od PWM.

Na plošči Arduino je na voljo podpora za PWM na nožicah, označenih s tildo (~), ki so nožice 3, 4,5,9,10 in 11) pri 500Hz (500-krat na sekundo). Uporabnik lahko poda katero koli vrednost med 0 in 255, pri čemer se 0 nanaša na HIGH ali no + 5V, 255 pa Arduinu pove, naj ves čas dobi HIGH ali + 5V. Za zagon teh ukazov boste morali dostopati do analogWrite () z želeno vrednostjo.

Lahko domnevate, da je PWM x / 255, kjer je x želena vrednost, ki jo želite poslati prek analogWrite()

Nastavite Arduino in druge parametre, kot je prikazano zgoraj.

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

Tu lahko najdete 3 vrstice, ki potrebujejo razlago.

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

Vrstica: ledBrightness = constrain(ledBrightness, 0, 255) ponazarja edinstveno funkcijo znotraj Arduina, znano kot constrain ().

Ta notranja funkcija vsebuje kodo, podobno naslednjemu:

int constrain (int vrednost, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Vse kode, o katerih smo razpravljali pred tem, smo začeli z praznino , kar je pomenilo, da se nič ne vrne (neveljavno). Medtem ko se zgornja koda začne z int , kar pomeni, da vrne celo število. O tem bomo razpravljali v poznejših razdelkih, trenutno se samo spomnite, da celo število nima nobenih delnih delov.

Torej, to pomeni, da koda: ledBrightness = constrain(ledBrightness, 0, 255) dodeli ledBrightness to be within the range of 0 and 255.

V naslednji vrstici je analogWrite ukazom Arduino, da na izbrani zatič uporabi želeno vrednost PWM.

Naslednja vrstica ustvarja zakasnitev 20 milisekund, s čimer zagotovimo, da jedi ne prilagodimo hitreje kot 50 Hz ali 50-krat na sekundo. To je zato, ker so ljudje lahko veliko počasnejši od Arduina. Če torej do zamude ne pride, nas lahko program začuti, da je pritisk prvega gumba izklopil LED in pritisk drugega gumba vklopil (poskusite sami, da potrdite).

3.2 Potenciometri

Gremo naprej in se naučimo uporabljati potenciometri z Arduinom.

Če želite vedeti, kako deluje potenciometer ali lonec, lahko preberete to Članek .

Prikazane parametre povežite z vašim Arduinom, kot je prikazano zgoraj.

Pot bo imel 3 terminale. Srednji priključek se bo povezal z ANALOG IN 0 na Arduinu. Druga dva zunanja terminala sta lahko priključena na napajalni tirnici + 5V in 0V.

Programirajmo in preverimo rezultate:

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

Našli boste nekaj stvari, ki so lahko videti povsem nove in niso vključene v nobeno od naših prejšnjih kod.

1. Konstanta kPinPot je dodeljen kot A0, pri čemer je A bližnjica za opis enega od analognih zatičev. Vendar se A0 nanaša tudi na pin # 14, A1 na pin # 15 in tako naprej, in ti omogočajo uporabo kot digitalni vhodi / izpusti, če vam za eksperiment zmanjka nožic. Vendar ne pozabite, da digitalnih nožic ne morete uporabljati kot analogne nožice.
2. Vrstica: ledBrightness = map(sensorValue, 0, 1023, 0, 255) predstavlja novo notranjo funkcijo v Arduinu, znano kot zemljevid(). Ta funkcija ponovno kalibrira iz določenega obsega v drugega, ki se imenuje map (vrednost, odLow, fromHigh, toLow, toHigh). To lahko postane ključno, saj analogueRead poda vrednost v območju od 0 do 1023, vendar analogWrite lahko sprejme vrednost od 0 do 255.

Morda si mislite, da ker je možno svetlost LED nadzirati s spreminjajočim se uporom, bi preprosto lonec zadostoval za namen, zakaj uporaba Arduina. No, spet je samo temelj, da pokažemo, kako je mogoče lonec konfigurirati z Arduinom.

Brez težav, zdaj bomo storili nekaj, česar brez Arduina ni mogoče storiti.

V tem poskusu bomo videli, kako bi lahko različno odpornost lonca uporabili za nadzor utripajoče hitrosti ali hitrosti LED.

Tukaj je program:

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 Izogibanje zamudi ()

Zgornja koda izgleda dobro, vendar lučka LED ne more preveriti vrednosti lonca, dokler ne preide skozi celoten cikel. Za daljše zamude se ta postopek podaljša, zato mora uporabnik počakati, da vidi odziv pota, medtem ko ga premika. Tej zakasnitvi se je mogoče izogniti z nekaterimi inteligentnimi programi, tako da uporabniku omogoča, da preveri vrednost brez minimalnih zamud. Tu je koda.

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

Torej, kaj se v zgornji kodi razlikuje? Razlika je v naslednji vrstici.

long lastTime = 0

Do tega razdelka smo razpravljali o spremenljivki int. Vendar pa lahko obstaja še več spremenljivk vrst, do katerih lahko dostopate. Seznam lahko preberete spodaj:

Trenutno je morda ključnega pomena vedeti, da je za shranjevanje relativno velikega števila int spremenljivko, lahko uporabite izraz dolga ali a dolg int.

Tu lahko vidite še eno zanimivo funkcijo, imenovano milis ().

To ustvari časovni razpon v milisekundah, ko je Arduino deloval v svojem delovanju od začetka (ta se bo po 50 dneh ponastavil na 0). Tu se vrne dolgo, ker če bi se vrnil int , štetje za daljša obdobja morda ne bo mogoče. Bi lahko natančno odgovorili, kako dolgo? Odgovor je 32.767 sekund.

Zato namesto da uporabimo delay (), preverimo, ali je milis (), in takoj, ko poteče določeno število milisekund, zamenjamo LED. Posledično shranimo čas, v katerem smo ga nazadnje spremenili prejšnjič spremenljivko, tako da nam omogoča, da jo kadar koli ponovno preverimo.

3.3 RGB LED

Do zdaj smo se igrali z enobarvno LED. Čeprav bi lahko barvo LED spremenili tako, da bi jo zamenjali z drugo barvo, kako pa je z uporabo RGB LED za spreminjanje barv LED brez menjave LED?

RGB LED je v bistvu LED z rdečo, zeleno in modro LED, ki je vdelana in združena v eno samo LED. Ima en skupni kabel, ki gre na tla ali 0V napajalno tirnico, medtem ko se ostali 3 kabli napajajo z raznolikimi pozitivnimi signali PWM za izvajanje predvidenih mešanje barv .

Nastavitve lahko povežete, kot je prikazano spodaj:

Morda je videti nekoliko zapleteno, vendar je dejansko replika našega prejšnjega zaslona za upravljanje z LED s pomočjo PWM.

Tu je koda programa za prakso:

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

Po nalaganju te kode samo poglejte, kako prilagoditve loncev ustvarijo zanimiv svetlobni učinek na RGB, lahko je res zabavno.

Ugotovili boste, da ko se vsi 3 lončki premaknejo na največje položaje, boste namesto bele barve videli rdečo. To je zato, ker je rdeča barva med 3 barvami najbolj vidna in zato prevladuje v tej situaciji. Lahko pa eksperimentirate s funkcijo zemljevid() pred izvedbo na rdeči del LED, da bi ustvarili bolj smiselno ravnovesje.

Zvok z Arduinom

V tem razdelku se bomo naučili, kako dodati osnovni zvok in glasbo nastavitvam Arduino.

Videli bomo, kako signal preklopiti na priključeni zvočnik z želeno frekvenco.

Natančneje, preizkusila se bo srednja nota, to je frekvenca 440 Hz.

Če želite to narediti, bomo preprosto predvajali srednje note in optimizirali signal sinusnega vala s kvadratnim valom.

Izračunali bomo tudi, koliko časa lahko zvočnik ostane vklopljen, tako da tožimo po formuli:

timeDelay = 1 sekunda / 2 x tonFrekvenca.

timeDelay = 1 sekunda / 2 x 440

timeDelay = 1136 mikrosekund

4.1 Priključimo ploščo Arduino

4.2 Dodajanje preproste opombe

O funkciji smo že govorili zamuda () kjer je enota v milisekundah (sekunda / 1000), vendar boste našli še eno funkcijo delayMicroseconds() kjer je enota v mikrosekundah (milisekunda / 1000).

Za trenutno nastavitev programiramo kodo za vklop / izklop + 5 V na izbrani nožici, povezani z zvočnikom, s hitrostjo 440 impulzov na sekundo.

Spomnimo, v zadnji razpravi smo za predvideno zvočno noto določili vrednost 1136 mikrosekund.

Tukaj je torej program za to, ki vam bo omogočil, da slišite zvočno noto 440 Hz, takoj ko programirate arduino s priključenim zvočnikom.

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

Z zgornjo aplikacijo je mogoče ustvariti zvočno noto, kar pomeni tudi, da lahko ustvarimo glasbo po lastni izbiri.

Iz kode razumemo, da Arduino vključuje nekaj integriranih funkcij, ki dodatno prispevajo k ustvarjanju glasbe.

Prvi je ton () ki deluje z dvema elementoma skupaj s tretjim neobveznim elementom, označenim kot ton (pin, frekvenca, trajanje). ali ton (pin, frekvenca)

Oba sta določena za izvajanje časovnega obdobja, ki ste ga določili.

Če ni časovnega obdobja, se bo glasba predvajala do klica ton () se izvrši znova ali dokler ne izvedete notone ().

To bo treba storiti s funkcijo zakasnitve, če je predvajanje glasbe edina temeljna stvar, ki jo izvajate.

Čas je lahko ključnega pomena, saj omogoča določitev časa, kako dolgo se predvaja glasba, tako da lahko svobodno počnete druge stvari. Takoj, ko poteče trajanje, se glasba ustavi.

Naslednja funkcija noTone () obravnava en parameter in ustavi izbrani ton na določenem dodeljenem zatiču.

Nenavadno opozorilo: kadar koli ton () funkcija je implementirana, funkcija PWM na nogah 3 in 11 preneha delovati.

Zato kadar koli v programu uporabljate pritrditev zvočnika, ne uporabljajte omenjenega zatiča za zvočnike, temveč poskusite z drugimi nožicami za pritrditev zvočnika.

V redu, zato je tu program za izvajanje glasbe na zvočniku, čeprav ni prava glasba, temveč osnovna lestvica C.

#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 zgornji kodi ste morda opazili nekaj novega in to je #define .

Ta izraz deluje kot ukaz za iskanje in zamenjavo računalnika med prevajanjem.

Kadarkoli najde prvo pred presledkom, jo ​​nadomesti s preostalim delom vrstice (imenovanim makri).

Torej v tem primeru, ko računalnik vidi OPOMBA_E4 hitro ga nadomesti s količino 330.

Za več opomb in prilagajanja se lahko obrnete na datoteko na USB ključku z imenom parcele.h , kjer je po vaših željah mogoče najti večino frekvenc.

4.4 Glasba s funkcijami

Zgornja koda je videti dobra, vendar se zdi, da ima veliko ponovitev, obstajati mora kakšen način za skrajšanje teh ponovitev, kajne?

Do zdaj smo delali z dvema bistvenima funkcijama, vključenima v Arduino. Zdaj je morda čas, da ustvarimo svoje funkcije.

Vsaka funkcija se mora začeti s tipom spremenljivke, s katero je lahko povezana. Na primer funkcija praznino se nanaša na vrsto, ki ne vrne nič, zato ime void. Upoštevajte, da smo že razpravljali o seznamu spremenljivk v naših prejšnjih razdelkih, morda jih boste želeli napotiti.

Posledično določeno ime funkcije dobi odprto oklepaj '(' čemur sledi seznam parametrov, ločenih z vejico.

Vsak od parametrov dobi svoj tip skupaj z imenom in nazadnje zaključek ')' oklepaj.

Te parametre je mogoče uporabiti znotraj funkcije v obliki spremenljivk.

Oglejmo si spodnji primer, kjer razvijemo funkcijo z imenom ourTone () zasnovan za združitev ton () s zamuda () vrstice, tako da se funkcija preneha vračati, dokler nota ne konča predvajanja tona.

Te funkcije izvajamo v prejšnji kodi in dobimo spodnji program, glej zadnje vrstice:

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

Funkcije so lahko zelo priročne za lažje razumevanje programa.

Sledi primer, kjer lahko z dvema nizoma določimo izbiro tona, ki ga želimo predvajati. Ena matrika za zadrževanje not, druga pa za zadrževanje utripov.

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

V prvi vrstici lahko jasno vidite uvod #include izjavo. Naloga te izjave je, da pobere celotno datoteko med narekovaji in jo postavi v položaj #include izjavo. V skladu s standardnimi pravili so ta natančno določena na začetku programa.

5. poglavje

Merjenje temperature

Če se spomnimo, ne pozabite, namesto da bi v celoti pisali velike programe, je vedno pametno pisati in analizirati majhne dele kod, kar pomaga pri hitrem iskanju napak.

5.1 Serijski monitor

Do zdaj kode, o katerih smo razpravljali, niso tako enostavne za hitro odpravljanje težav. Tu bomo poskušali olajšati spremljanje in lažje reševanje morebitnih težav.

Arduino ima funkcijo, ki mu omogoča 'odziv' z računalnikom. Opazili boste, da sta pin0 in pin1 označena kot RX in TX drug ob drugem. Tem zatičem dejansko sledi ločen IC v Arduinu, ki jih nadgradi tako, da berejo prek kabla USB, medtem ko je priključen na računalnik.

Spodnji odsek prikazuje polnopravni program. Pojdite, vendar bomo o novih vnosih v kodo izvedeli v nadaljevanju. Ta koda je enaka izraženemu oddelku 2.2, le da vključuje nekaj dodatnih podatkov, ki nam omogočajo, da ugotovimo, za kaj je kodirana.

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

Tu lahko prepoznate dve novi stvari, novo vrstico v nastaviti() funkcijo.

Serial.begin(9600)

Ta vrstica preprosto izraža potrebo po uporabi Serijski1 kodo za uveljavitev s 9600 baud. (tukaj se serijska oznaka nanaša na bitov poslana ena za drugo in baud pomeni hitrost, s katero je poslana). Ta vrednost prenosa in vrednost v serijskem monitorju (to bomo izvedeli kasneje) morata biti enaki, sicer bodo podatki v serijskem monitorju pokazali smeti. 9600 kot standard postane bolj priročen za uporabo.

Drugi novi vnos je naslednji

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

Tu druga vrstica kaže, da se bo naslednja stvar, ki prihaja iz serijskih vrat, začela v naslednji vrstici. Tako se druga vrstica razlikuje od prve črte.

Še nekaj, kar lahko vidite, so narekovaji ('). To je znano kot niz, ki se bo tukaj uporabljal le kot konstante, ker je nadaljnja razprava o tej temi lahko preveč dodelana in presega obseg.

V redu, zdaj lahko naložimo zgornjo kodo v Arduino in vidimo, kaj se bo zgodilo.

Kaj, up, zdi se, da se ni nič zgodilo, LED diode Arduino # 13 je utripal in se ustavil, medtem ko je LED Tx še naprej utripal.

No, to je zato, ker okno serijskega monitorja še ni popravljeno.

V IDE morate klikniti polje Serial Monitor, kot je prikazano zgoraj. Ne pozabite preveriti hitrosti prenosa v spodnjem desnem kotu, privzeto mora biti 9600 in se bo ujemala s kodo. Če ne izberete 9600.

Naslednji video posnetek razloži, kako se to naredi.

Zdaj pa pojdimo naprej in se naučimo, kako lahko zgornja funkcija serijskega monitorja pomaga pri obdelavi merjenje temperature z uporabo Arduina

Kot temperaturni senzor bomo uporabili IC TMP36 z razponom od -40 do 150 stopinj Celzija.

Nastavitev si lahko ogledate spodaj:

Naslednja koda bo sprožila merjenje temperature tako, da bo prebrala izhod s senzorja TMP36 in jih poslala serijskemu monitorju ID-ja.

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
}

Razumejmo kodo z vrha.

float temperatureC = getTemperatureC()

Tu lahko vidite, da smo vključili vrsto spremenljivke float.

To je edina spremenljivka, ki vsebuje vse, razen celih števil (števil brez decimalnih ali delnih delov).

Natančnost spremenljivke s plovcem je lahko do 6 do 7 števk.

Sosednja koda getTemperatureC() je naša lastna funkcija, ki matematično izračuna in pretvori zaznano napetostno razliko s senzorja TMP36 v stopinje Celzija.

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
}

V naslednjem oddelku kod, od izraza analogIn() dodeli vrnitev številke med 1 in 1023, lahko ocenimo napetost senzorja tako, da pomnožimo odčitek s 5 in ga nato delimo z 1024.

Senzor TMP36 je določen za generiranje 0,5 V pri 0 stopinjah Celzija in nato generira 10 mV za vsak posamezen dvig stopinje Celzija.

Tu je približek, ki ga lahko ustvarimo z izračuni:

Lahko se štejete za svojo prvo funkcijo, ki vrne neko vrednost (upoštevajte, da vse preostale funkcije doslej niso vrnile nobene vrednosti, ker so bile tipa praznino ).

Razumete lahko, da za pridobitev vrednosti iz funkcije preprosto morate dodati vrnitev čemur sledi želena številka, ki jo želite vrniti.

Ko rečemo vrnitev to pomeni, da funkcija vrne odgovor ali odgovor, kadar koli je poklican, kar bi lahko uporabili za spremenljivko.

Ko je to poslano serijskemu monitorju, se branje skozi pretvori v Fahrenheit convertToF ().

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

Ta funkcija zajema območje Celzija in ga pretvori v Fahrenheit.

Za pretvorbo Fahrenheita v Celzija uporabimo formulo Fahrenheit = 9 / 5 (Celzija) + 32.

5.3 Povezava LCD-ja

Zdaj pa preučimo, kako vmesnik ali povezavo LCD zaslon z Arduinom za vizualni prikaz zahtevanih izhodov.

V naši aplikaciji bomo uporabili grafični LCD velikosti 84 x 48, ki ima vodoravno 84 pik ali pik in vertikalno ločljivost 48 slikovnih pik. Ker namenski krmilnik postane nujen za vse LCD-je, sedanja naprava vključuje tudi takšnega v obliki krmilnika PCD8544.

V tej vadnici bomo zgoraj navedeni modul LCD povezali z Arduinom in uporabili določene rutine za ustvarjanje besedilnih sporočil na zaslonu.

Na naslednji sliki najdete podrobnosti o povezavi LCD-ja, skupaj z majhno 3.3V napetostni regulator . Ta regulator je potreben, ker je LCD zasnovan za delovanje z napajanjem 3,3 V.

Na LCD-modulu si lahko ogledate tudi 8 izrezov, njihove lastnosti pa lahko preučite iz naslednje tabele:

Zdaj pa poglejmo, kako lahko povežemo LCD in ustrezne parametre z našim Arduinom. Podrobnosti si lahko ogledate na spodnji sliki:

5.4 Komuniciranje z LCD

Čeprav je mogoče za interakcijo z LCD-jem iz Arduina napisati zapletene zapise, se bomo raje naučili, kako to storiti z uporabo knjižnic.

Knjižnice obsegajo vrsto kod, ki jih je mogoče hitro uporabiti za izbrani program Arduino.

To omogoča uporabniku, da brez težav pokliče funkcijo, ne da bi mu bilo treba iti skozi zapleteno kodiranje.

5.4.1 Kako namestite knjižnico

Za to boste morali v računalniku Arduino IDE ustvariti imenik, imenovan knjižnice, kot je razloženo tukaj

5.4.2 Izvajanje operacij LCD

Tako kot naš prejšnji pristop bomo najprej preverili celotno kodo in nato poskusili razumeti podrobnosti posameznih vrstic.

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

Vrstica vključuje kodo #include

Koda #include naroči osebnemu računalniku, da med sestavljanjem programa prevzame omenjeno datoteko in nadomesti element #include z vsebino datoteke.

Element #include ima lahko kotne oklepaje, kar označuje iskanje v imeniku knjižnice, lahko pa ima tudi narekovaje, ki označujejo iskanje v istem imeniku, v katerem je program.

V naslednjih vrsticah kode so prikazani izrezki LCD, nato pa napišemo novo obliko spremenljivke:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Tu izražamo spremenljivko z imenom lcd tipa PCD8544 in naročimo računalniku, da nadgradi svoje pinout-e, povezane z Arduinom.

V tem postopku spremenljivko opišemo na osebni računalnik z navodili, kako so pin clk, din, dc in reset ponastavljeni z Arduinom.

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

Vrstica lcd.init() inicializira delovanje LCD. Ko je to izvedeno, naslednja vrstica sproži kazalko v zgornjem levem kotu zaslona. Naslednja vrstica si prizadeva natisniti sporočilo 'Zdravo, svet'.

To je videti povsem enako kot tehnika, pri kateri smo pošiljali sporočila prek serijskega monitorja. Edina razlika je uporaba kode lcd.print namesto serial.print.

Naslednji blok kode se dejansko ponavlja.

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

Uporaba te vrstice lcd.setCursor(0,1) kazalko pritrdimo na 0. stolpec skrajno levo od 1. vrstice nad LCD zaslonom.

Naslednja vrstica uporablja bližnjico: lcd.print(millis())

Če se spomnite, smo sodelovali z millis() v naših prejšnjih kodah bi lahko tudi tu uporabili isto prek kod:

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

Ker pa tu ne gre za časovna obdobja v milisekundah, to dosežemo s preprostim pošiljanjem millis() funkcija neposredno na lcd.print() .

5.5 Kombiniranje celotne stvari

V redu, zdaj združimo vse zgoraj navedene kode za izdelavo temperaturnega vezja LCD in poglejmo, kako izgleda:

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

V zgornjem programu je vse videti standardno, razen uporabe funkcije setCursor () . S tem se besedilo čim bolj poravna okoli sredine zaslona.

Super! Čestitamo! Pravkar ste programirali svoj mali LCD-indikator temperature z uporabo Arduina.

Praktične aplikacije Arduino

Ker smo na tej točki podrobno obravnavali različne tehnike programiranja, je čas, da jih preizkusimo, tako da jih uporabimo za nekaj uporabnih praktičnih izvedb.

Začeli bomo s senzorji in videli nekaj načinov uporabe senzorskih naprav z Arduinom z izvedbo nekaj vzorčnih kod.

7.1 Uvod v senzorje

V tej vadnici bomo izvedeli o najrazličnejših senzorjih, ki bi jih lahko uporabljali z Arduinom. To lahko vključuje naprave, kot so svetlobni senzor LDR, magnetni senzor učinka Hall, senzorji nagiba, senzor vibracij, senzor tlaka itd.

Začeli bomo s povezovanjem svetlobni senzor LDR z Arduinom, kot je prikazano na naslednjem diagramu:

Kot vsi vemo, je LDR svetlobno odvisna uporna naprava, katere upor je odvisen od intenzivnosti vdora okolice na njeno površino.

Intenziteta svetlobe je obratno sorazmerna z odčitkom odpornosti LDR.

Tu bomo izvedeli, kako lahko to lastnost integriramo z Arduino za izvajanje uporabne aplikacije:

Popolno programsko kodo si lahko ogledate, kot je navedeno spodaj:

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

Vsi parametri, uporabljeni v kodi, so že obravnavani v našem tečaju, ki smo se ga doslej naučili. Vrstice lahko preverite tako, da se sklicujete na ustrezne odseke.

Vrednosti so bile izbrane naključno, lahko jih enostavno spremenite glede na vaše želje.

Senzor nagiba

Senzor nagiba je preprosta naprava, ki jo lahko uporabimo za zaznavanje nagiba na katerem koli predmetu, kjer je nameščen. Naprava ima v bistvu kovinsko kroglo znotraj, ki se pri nagibanju prevrne čez par kontaktov in povzroči prevodnost čez te kontakte. Ti kontakti, ki so zaključeni kot vodniki nagibnega stikala, se uporabljajo z zunanjim vezjem za zaznavanje prevodnosti zaradi nagibanja in aktiviranje želene izhodne aplikacije.

Zdaj pa poglejmo, kako a senzor nagiba napravo lahko ožičite. Spodnja slika nam daje predstavo o celotni konfiguraciji:

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

V tem primeru je kot indikator nagiba uporabljen privzeti LED št. 13.

Tu lahko jasno vidite vključitev vlečnega upora, podobno kot v oddelku 3.1. Izraz LOW torej pomeni, da funkcija nagiba ni sprožena.

7.4 Rele trstnega stikala (rele z miniaturnim magnetom)

Zdaj pa poglejmo, kako priključiti relejsko stikalo ali senzor magnetnega polja z Arduinom. Trstni rele je nekakšno stikalo, ki se aktivira ali prevede, ko je blizu njega magnetno polje ali magnet. V bistvu ima par feromagnetnih kontaktov v miniaturnem steklenem ohišju, ki se zaradi magnetnega vleka povežejo ali vzpostavijo stik, kadar koli je magnet blizu njega. Ko se to zgodi, terminali kontaktov kažejo prevodnost zaradi zapiranja kontaktov.

Tudi tu za prikaz odziva uporabljamo lučko LED št. 13. Po potrebi lahko v skladu s prejšnjimi razlagami s tega zatiča priključite zunanjo LED.

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

Izrazi kode morajo biti znani in samoumevni.

7.5 Vibracijski senzor s Piezo pretvornikom

V naslednjem vzorčnem programu bomo videli, kako a piezo pretvornik se lahko uporablja kot senzor vibracij za osvetlitev LED skozi Arduino.

Piezo element je pravzaprav naprava, ki ustvarja vibracije ali nihanje, kadar frekvenca deluje na njegovih terminalih. Vendar bi lahko isti piezo uporabili v obratnem postopku za generiranje električnih impulzov kot odziv na vibracije, ki delujejo na njegovo telo. Ta vibracija je lahko v obliki trka ali udarca po površini pieza.

Nastavite Arduino in piezo element, kot je prikazano na naslednji sliki

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

Prag 100 je uveden samo zato, da se zagotovi, da se Arduino odziva samo na pristne vibracije z udarci, ne pa tudi na druge manjše vibracije, kot so glasni zvoki ali hupe.

Izbira nožice A5 ni obvezna, po želji lahko izberete kateri koli drugi analogni vhod in ga ujemate v programski kodi.

Uporaba servo motorja z Arduinom

Servo motor je vrsta enosmernega motorja, ki ga je mogoče zasukati pod natančnimi koti glede na potrebe določene aplikacije. To lahko storite z uporabo izračunanega ukaza na ustreznih vhodih motorja, da dobite natančen kot vrtenja ali obračanja v območju 180 stopinj na motorju.

Običajno ima servo motor 3 žice ali vhode. Pozitivne žice so običajno rdeče barve, negativna ali ozemljitvena žica je črna, kabel za vodenje ali signalna žica pa je običajno bele ali rumene barve.

Arduino olajša upravljanje servo motorjev z vgrajenim podpornim jezikom, zaradi česar je nadzor zelo priročen in idealen za servo motorje.

Naslednji primer nam bo pokazal osnovni nastavitveni program za izvajanje nadzora servo motorja prek Arduina:

Koda je navedena spodaj:

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

Tu lahko vidimo nekaj novih vnosov. Tisti, ki poveženi žici servo servo pove, kateremu pin je dodeljen. Druga je koda, ki daje zatiču vrednost med 0 in 180, za določanje kota vrtenja na servo.

Zaključek

Predmet Arduino je lahko neskončno dolg in zato presega obseg tega članka. Upam pa, da bi vam zgornja vadnica zagotovo pomagala, da se naučite osnov Arduina in razumete pomembne parametre z različnimi primeri aplikacijskih kod.

Upajmo, da se bodo tukaj občasno posodobile več informacij, kadar koli bodo na voljo.

Medtem uživajte v svojem tečaju programiranja, Happy Arduinoing vam !!