Učenje osnovnog Arduino programiranja - Vodič za pridošlice

U ovom uputstvu naučimo kako se izvodi osnovno programiranje Arduina kroz primjere kodova i primjera programa. Ovaj vodič može biti izuzetno vrijedan tečaj za sve novopridošlice koji žele shvatiti osnove jednostavnim, razumljivim jezikom.

Uvod

Prema wikipedija mikrokontroler je ekvivalentan mini računalu ugrađenom u jedan IC čip, koji ima vlastiti procesor jezgre, programibilne ulaze, memoriju i izlaznu perifernu opremu.

Mikrokontroler postaje toliko koristan za korisnika jer nudi ugrađeni procesor, memoriju i ulazno / izlazne priključke (koji se nazivaju i GPIO ili općenito ulazno / izlazni pinovi) kojima korisnik može upravljati prema bilo kojoj željenoj specifikaciji.

U ovom uputstvu radit ćemo s Arduino Uno pločom za učenje i testiranje programa. Za testiranje i integriranje sklopa hardvera koristit ćemo ploču.

Sada krenimo brzo i naučimo kako započeti s Arduino programiranjem.

1.2 Instaliranje softvera (Windows)

Za to će vam trebati pristup internetu koji biste očito imali na računalu. Idite na sljedeću vezu i preuzmite IDE softver:

Windows ZIP datoteka za instalaciju bez administratora

Nakon preuzimanja pronaći ćete ikonu za postavljanje Arduina u mapi za preuzimanje koja bi izgledala ovako:

Jednom kada to dobijete, možete ga jednostavno dvaput kliknuti i instalirati Arduino integrirano razvojno okruženje (IDE) na svoje računalo. Kompletni postupak može se vizualizirati u sljedećem videozapisu:

1.4 Počevši od našeg prvog kruga

Prije nego što započnemo s učenjem stvarnih tehnika programiranja, za bilo kojeg novaka bilo bi korisno započeti s osnovnom komponentom, poput LED-a, i razumjeti kako je povezati s Arduinom.

Kao što znamo, LED je dioda koja emitira svjetlost koja ima polaritet i neće svijetliti ako nije povezana s pravim polovima napajanja.

Sljedeći aspekt LED dioda je da ovi uređaji rade s malom strujom i mogu se trenutno oštetiti ako odgovarajuće izračunati otpornik nije uključen u seriju s jednim od svojih pinova.

U pravilu je 330 ohma 1/4 vata sasvim idealno za svakih 5 V porasta ulaza kako bi se struja ograničila na potrebnu sigurnu razinu. Stoga za 5V to može biti 330 ohma, za 10V može biti 680 ohma i tako dalje.

Korištenje ploče za skup za skupštinu

Molimo provjerite znate li kako se koristi kruha prije nego što isprobate tutorial objašnjen u ovom poglavlju, jer bismo ovdje koristili ploču za sve eksperimente.

Osnovno postavljanje LED veze može se vidjeti u nastavku:

Gore možete vidjeti 3 osnovne komponente:

1. LED od 5 mm i 20 mA
2. otpor od 330 ohma 1/4 vata
3. An Arduino ploča

Dovoljno je sastaviti sustav prema dijagramu.

Zatim priključite 5V s računala na Arduino. Čim to učinite, vidjet ćete kako LED svijetli.

Znam da je to prilično osnovno, ali uvijek je dobro početi ispočetka. Budite sigurni da će stvari početi postajati sve zanimljivije kako idemo dalje.

1.5 Upravljanje LED-om s Arduinom

Sada ćemo naučiti kako upravljati LED-om pomoću programa Arduino.

Da bismo napisali program, moramo imati najmanje 2 funkcije u svakom programu.

Funkcija se može shvatiti kao niz programskih izjava kojima se može dodijeliti ime, kako je dano u nastavku:

1. postaviti() to se naziva ili izvršava tijekom početka programa.
2. petlja() to se poziva ili izvodi ponavljajuće tijekom cijelog operativnog razdoblja Arduina.

Stoga, iako možda nema praktične funkcionalnosti, tehnički najkraći legitimni program Arduino može se napisati kao:

Najjednostavniji program

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

Možda ste primijetili da u mnogim programskim jezicima sustav započinje prikazivanjem jednostavnog ispisa 'Hello, World' na zaslonu zaslona

Elektronički ekvivalent ove fraze u interpretaciji mikrokontrolera je treptanje uključene i isključene LED diode.

Ovo je najosnovniji program koji se može napisati i implementirati kako bi ukazao na ispravno funkcioniranje sustava.

Pokušat ćemo implementirati i razumjeti postupak kroz sljedeći kôd:

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

U redu, hajde sada da shvatimo što znači svaki redak koda i kako to radi na izvršavanju funkcije:

const int kPinLed = 13

To djeluje poput konstante koja nam omogućuje da je koristimo tijekom cijelog tečaja programiranja, bez potrebe za korištenjem stvarne vrijednosti koja je postavljena u odnosu na nju.

Prema standardnim pravilima takve se konstante prepoznaju s početnim slovom do . Iako to nije obvezno, čini stvari jasnijima i lako razumljivima kad god poželite proći detalje koda.

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

Ovaj kod konfigurira određeni pin na koji je spojen naš LED. Drugim riječima, kôd govori Arduinu da kontrolira aspekt 'pisanja' na ovom pinu, umjesto da ga 'čita'.

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

Gornji redovi označavaju stvarno izvršenje zahtjeva. Kôd započinje pisanjem i prikazivanjem HIGH na odgovarajućem LED priključku, UKLJUČUJUĆI LED.

Ovdje izraz HIGH jednostavno znači dobivanje + 5V na dotični pin Arduina. Dopunski izraz LOW jednostavno označava nulu ili 0V na naznačenom pinu.

Dalje, pozivamo delay() čija je funkcija stvaranje kašnjenja kroz milisekunde (1/1000 dio sekunde). Budući da se unosi brojka 500, primijenjeno kašnjenje trajat će 1/2 sekunde.

Čim istekne ova 1/2 sekunde, izvršava se sljedeći redak koji isključuje LED s LOW termom na istom pinu.

Sljedeći redak opet generira kašnjenje od 1/2 sekunde, kako bi LED dioda ostala ISKLJUČENA 1/2 sekunde.

A postupak se nastavlja beskonačno izvršavanjem redaka koda, sve dok se Arduino održava napajanim.

Prije nego što prijeđete na sljedeću razinu, preporučio bih vam da programirate gornji kod i provjerite jeste li u stanju pravilno implementirati LED ON / OF sekvencu ili ne.

Budući da je zadana LED dioda u Arduinu spojena na pin # 13, trebala bi odmah reagirati na gornji program i početi treptati. Međutim, ako ustanovite da vanjska LED dioda ne trepće, onda bi mogla doći do greške u vezi s LED diodom, možete pokušati preokrenuti polaritet LED diode i nadamo se da će i ona treptati.

Možete se igrati s vremenom kašnjenja tako što ćete lik '500' promijeniti na neku drugu vrijednost i pronaći LED 'preslušavajući' naredbe i uzrokujući da treperi prema navedenim vrijednostima kašnjenja.

Ali imajte na umu, ako vidite da LED ne trepće s konstantnom brzinom od 1 sekunde, bez obzira na promjenu vremena kašnjenja, to može značiti da kôd ne radi zbog neke pogreške. Budući da će se Arduino prema zadanim postavkama programirati s brzinom treptanja od 1 sekunde. Stoga ovaj kôd mora varirati prema vašem kodu radi potvrđivanja ispravnog rada.

1.7 Komentari

Redovi kodova koje smo gore razumjeli posebno su napisani za računalni softver.

Međutim, kako bi se osiguralo da korisnik može uputiti značenje linija i razumjeti ih, često može biti korisno i razumno napisati objašnjenje pored željenih redaka kodova.

To su tzv komentari koji su napisani samo za referencu ljudi ili korisnika i kodirani su da omoguće računalima da ih sigurno ignoriraju.

Jezik ovih komentara napisan je u nekoliko formata:

1. Stil bloka komentara, pri čemu je opis komentara zatvoren ispod početnog simbola / * i završnog simbola * /
2. To ne mora ograničiti u jednom retku, već se može proširiti na sljedeće naredne retke, ovisno o duljini komentara ili opisa, kao što je prikazano u sljedećem primjeru:

/ * Ovo je komentar * /

/ * I ovo je * /

/ * And
* ovo
* kao
* dobro */

Za pisanje brzog opisa u jednom retku za komentar dovoljne su dvije crte // na početku. To računalu govori da ovaj redak nema nikakve veze sa stvarnim kodom i mora se zanemariti. Na primjer:

// Ovo je komentar koji će računala ignorirati.

Evo primjera za referencu:

/*
* 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 Rješavanje problema

Ako ustanovite da vaš program prikazuje 'pogrešku' tijekom sastavljanja ili neki drugi problem, sljedeći savjeti vjerojatno će vam pomoći da ponovo provjerite kôd i riješite se prepreka.

1. Jezik vašeg programa razlikovat će velika i mala slova. Na primjer izraz myVar ne može se zapisati kao MyVar.
2. Razmaci svih vrsta koje se mogu izvršiti tipkanjem na kraju, na kraju se prikazuju kao jedan razmak i vidljivi ste ili razumljivi samo vama, računalo to neće uzeti u obzir. Jednostavno rečeno, slobodni prostori bilo koje vrste neće imati nikakvog utjecaja na rezultate koda.
3. Svaki blok koda mora biti priložen lijevim i desnim zavojnim zagradama, '{' i '}'
4. Brojčane znamenke ne smiju se odvajati zarezima. Na primjer, 1000 možda neće biti zapisano kao 1000.
5. Svaka linija koda zatvorena između kovrčavih zagrada mora završiti točkom i zarezom

Stvaranje zanimljive sekvence LED svjetla s Arduinom

U našem prethodnom poglavlju naučili smo kako neprestano treptati ON / OFF LED uz konstantnu brzinu kašnjenja.

Sada ćemo naučiti kako se različiti oblici kašnjenja mogu izvoditi na istoj LED nadogradnjom programskog koda.

Nećemo koristiti vanjsku LED, radije ćemo koristiti zadanu LED ugrađenu u ploču Arduino na pinu # 13. Ovaj maleni SMD LED možete pronaći odmah iza USB konektora.

2.2 Razumijevanje IF izjava

U ovom ćemo odjeljku naučiti kako nam upravljačke strukture omogućuju pokretanje pojedinačnih kodova, a ponekad i ponavljajući, prema potrebi.

Izjava ako postaje 1. kontrolna struktura. Sljedeća implementacija pokazuje kako se koristi:

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

Pokušat ćemo korak po korak razumjeti gornji kod i naučiti kako se to može koristiti za druga slična izvršavanja.

Kodovi između 1. i 7. retka potpuno su slični našem početnom programu.

Prva se preinaka zapravo događa na 8. retku.

int delayTime = 1000

Možete pronaći da je sličan kodu u 1. retku, izuzev činjenice da mu nedostaje izraz konst.

To je jednostavno zato što ovaj kod nije konstanta. Umjesto toga ovo se definira kao varijabilna , koji ima svojstvo promjenjive vrijednosti tijekom programiranja.

U gornjem primjeru možete vidjeti da se ovoj varijabli pripisuje vrijednost 1000. Zapamtite, takve varijable koje su zatvorene u kovrčavim zagradama moraju biti strogo zapisane samo u parovima kovrčavih zagrada i nazivaju se 'lokalnim' varijablama.

Alternativno, varijable koje bi trebale biti izvan kovrčavih zagrada, poput one o kojoj sada raspravljamo, prepoznate su kao 'globalne' i mogle bi se izvršiti gotovo bilo gdje unutar programskog koda.

Krećući se prema naprijed, možete vidjeti da su kodovi između redaka 9 i 11 također slični prvom programu, ali stvari nakon 11 postaju zanimljivije. Da vidimo kako!

delayTime = delayTime - 100

U ovom kodu vidimo da je zadana vrijednost vrijeme odgode se modificira oduzimanjem 100 od njega.

Značenje 100 oduzima se od početne vrijednosti 1000, pružajući mu novu vrijednost 900.

Kroz sljedeću sliku pokušat ćemo shvatiti nekoliko matematičkih operatora koji se koriste u jeziku Arduino.

Sada procijenimo kodove između redaka 13 i 15.

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

Glavni cilj gornjeg koda je osigurati da LED nastavi treptati bez ikakvih prekida.

Zbog činjenice da se 100 oduzima od originala vrijeme odgode , sprječava treptanje LED-a da dosegne nulu i omogućuje kontinuirano treptanje.

Sljedeća slika prikazuje nekoliko operatora usporedbe koje bismo koristili u našim kodovima:

U našem gore navedenom kodu mogli smo testirati da je if(delayTime == 0).

Međutim, budući da negativna brojka može biti jednako loša, nismo pristali na to, a ovo je preporučena praksa.

Razmislite kakav bi mogao biti ishod da smo pokušali oduzeti 300 umjesto 100 od delayTime?

Dakle, sada ste možda shvatili da ako delayTime zapisuje se kao manje ili jednako nuli, tada bi se vrijeme odgode vratilo na početnu brojku 1000.

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

Posljednja 4 retka koda, kao što je prikazano gore, postaju odgovorna za neprekidno UKLJUČIVANJE / ISKLJUČIVANJE LED-a.

Ovdje možete jasno primijetiti da smo umjesto broja slika koristili varijablu za dodjeljivanje vremena odgode kako bismo ga mogli prilagoditi kako želimo tijekom operativnog razdoblja koda. To je u redu, zar ne?

2.3 OSTALE izjave

Ovdje ćemo naučiti zašto i kako ako Pojam može sadržavati klauzulu drugo tako da odluči o situaciji u slučaju ako izjava je lažna.

Žao mi je ako to zvuči previše zbunjujuće, ne brinite, pokušat ćemo to razumjeti na sljedećem primjeru:

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

U gore navedenom dobro možete vidjeti da se u 10. retku kôd izvršava samo kada je delayTime je manje ili jednako 100, ako nije, tada se izvršava kôd u 13. retku, ali oboje se nikada ne može dogoditi, implementirat će se 10. redak ili kôd 13. retka, nikada oboje.

Možda ste primijetili da za razliku od onoga što smo radili u našem prethodnom odjeljku 2.2, ovdje se nismo uspoređivali s 0, nego sa 100. To je zato što smo u ovom primjeru u usporedbi PRIJE nego što smo oduzeli 100, suprotno u odjeljku 2.2, uspoređivali NAKON oduzeti. Možete li reći što se moglo dogoditi da smo usporedili 0 umjesto 100?

2.4 WHILE izjave

DO dok Izjava je prilično slična ako izjava, osim istine da uzrokuje opetovano izvršavanje bloka koda (koji se može nalaziti između kovrčavih zagrada) tako dugo dok su primjenjivi uvjeti, a to djeluje bez drugo izjava.

Sljedeći primjer pomoći će vam da ovo bolje razumijete

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

Možete li pogoditi za što je programiran gornji kod? Pa, dizajniran je da trepće LED brže, a zatim sporije.

2.5 Što je istina i neistina?

U programskom jeziku, lažno odnosi se na nulu (0). Zapravo se 'true' ne koristi, već se pretpostavlja da kada ništa nije lažno, tada je sve što je uključeno istina.

Izgleda malo čudno, no posao obavlja prilično lijepo.

Pokušat ćemo shvatiti situaciju kroz sljedeći primjer.

Ponekad možete naići na kod kako je naveden u nastavku:

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

Ovo je kodirano, čini se da će LED izvedba zadržati ciklus zauvijek, sve dok je dostupna snaga.

Međutim, jedan nedostatak ove vrste koda mogao bi nastati kada slučajno korisnik primijeni = umjesto = =.

Siguran sam da već znate da = označava dodjelu, što znači da se koristi za označavanje odabrane vrijednosti varijablom, dok se == koristi za provođenje testa ako je vrijednost bila ista.

Na primjer, pretpostavimo da ste trebali LED da trepće s uzastopnim uzorkom brzine i ponavljajući se, ali pogrešno ste koristili = umjesto ==.

Kôd bi se tada pojavio ovako:

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
}

Pogreška će dodijeliti 0 delayTime i dovesti do ako izjava za provjeru je li 0 točno ili nije. Budući da se 0 odnosi na false, mislit će da nije istina i zaustavit će provođenje delayTime = 1000, ali umjesto toga funkcija delayTime se održava na 0 tijekom petlje ().

Ovo izgleda vrlo nepoželjno !!

Stoga, uvijek dvaput provjerite svoj program kako biste bili sigurni da niste napravili takve glupe pogreške.

2.6 Kombinacije

Ponekad ćete možda osjetiti potrebu da zajedno testirate više stvari. Kao, možda ćete htjeti ispitati je li varijabla bila između dva broja. Iako se to može implementirati pomoću naredbe if više puta, možda je prikladnije koristiti logičke kombinacije za bolje i lakše čitanje.

Implementacija kombinacija u logičke pojmove može se izvršiti s 3 metode, kao što je prikazano u sljedećoj tablici:

Bilo bi zanimljivo znati da operator NOT može raditi kao prekidač za varijablu koja može biti označena kao bilo koja pravi ili lažno (ili NISKO ili VISOKO).

Sljedeći primjer ilustrira stanje:

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

Ovdje je ledState bit će NISKO, a nakon toga ledState = !ledState, postat će VISOKO. Sljedeća petlja će uzrokovati ledState biti VISOK kada ledState = !ledState je nisko.

2.7 ZA izjave

Sada ćemo pokušati razumjeti još jednu upravljačku strukturu koja je za petlja. To može biti vrlo korisno kada želite nekoliko puta primijeniti nešto.

Shvatimo to na sljedećem primjeru:

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
}

U liniji s možete pronaći nešto jedinstveno za.

To je kod i ++? . Ovo je korisno za programere koji su prilično lijeni i žele implementirati kodiranje pomoću prikladnih prečaca

Gornji pojam poznat je kao složeni operateri, jer oni rade posao kombiniranja jednog operatora dodjele s drugim operatorom dodjele. Najpopularnije od njih mogu se vizualizirati u sljedećoj tablici:

Otkrit ćete da se u izjavi for nalaze 3 pod-izjave. Strukturiran je kako je prikazano u nastavku:

for (statement1conditionstatement2){
// statements
}

Izjava br. 1 javlja se odmah na početku i samo jednom. Stanje se ispituje svaki put tijekom petlje. Kad god je pravi unutar kovrčavih zagrada, izvršava se sljedeća izjava # 2. U slučaju a lažno, sustav preskače na sljedeći blok koda.

Spajanje više LED dioda

U redu, sada ćemo vidjeti kako možemo povezati veći broj LE-ova radi dobivanja zanimljivijih efekata.

Molimo spojite LED i Arduino kao što je prikazano dolje. Crvena žica zapravo nije potrebna, ali budući da je uvijek dobro postaviti obje vodilice napajanja u ploču za postavljanje, to ima smisla.

Sada popravimo program koji će nam omogućiti da provjerimo je li naš hardver ispravno konfiguriran ili nije.

Uvijek se preporučuje kodiranje i izvršavanje malih bitova programa korak po korak kako bi se provjerilo jesu li odgovarajući hardveri ispravno ožičeni ili ne.

To pomaže u brzom rješavanju mogućih pogrešaka.

Primjer koda u nastavku daje LED 2 do 5 određeni uzorak okrećući ih jedan za drugim na ciklički način.

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

Kao što ste mogli primijetiti, s kodom nema ništa loše, osim činjenice da izgleda dugo i zato sklon pogreškama.

Naravno da postoje bolji načini za pisanje gornjeg koda, sljedeći odjeljak će ga otkriti.

2.9 Uvođenje nizova

Nizovi mogu biti skupina varijabli koje se mogu indeksirati brojevima indeksa. Sljedeći primjer pomoći će nam da ga bolje razumijemo.

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, prođimo sada svaki odjeljak i shvatimo kako oni zapravo rade.

const int k_numLEDs = 4

Gornji kod definira koliko bismo maksimalno elemenata trebali imati u polju. Ovaj nam kôd pomaže u sljedećim odjeljcima kako bismo osigurali da je sve zapisano unutar polja i ništa nakon što niz završi.

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

U ovom sljedećem retku postavljamo strukturu niza. Brojevi unutar zagrade označavaju broj elemenata u polju. Iako je stvarna količina mogla biti napisana, pisanje kao konstante djeluje bolje. Vrijednosti se mogu normalno vidjeti unutar zagrade sa zarezima i označavaju vrijednosti u nizu.

Kada pronađete niz indeksiran brojem 0, to ukazuje na prvi element u nizu, kao što je prikazano u code: k_LEDPins is k_LEDPins[0].

Slično tome, zadnji element bit će prikazan kao k_LEDPins[3], jer je broj od 0 do 3 4.

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

Gornji kod prikazuje upotrebu petlje za prolazak kroz svaki element niza i za postavljanje kao IZLAZA. Implementiramo uglate zagrade zajedno s indeksom kako bismo dosegli svaki od elemenata u polju.

ako se pitate je li moguće koristiti pin # 2 za pin # 5 bez nizova, odgovor je da, moguće je. Ali u ovom primjeru to nije učinjeno jer to nismo učinili na taj način. U sljedećim odjeljcima možete ukloniti pristup nizu ako odabrani izlazni pinovi nisu u liniji.

Krenimo dalje, pogledajmo što radi sljedeći blok koda:

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

Ovdje se kôd nastavlja kroz svaku LED diodu kako bi ih se redno UKLJUČAO s razmakom ili kašnjenjem od 100 milisekundi.

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

Korištenje gornjeg koda pokazuje kako primjena za petlju mogao se koristiti za kretanje kroz petlju čak i obrnutim redoslijedom.

Počinje od k_numLEDs - 1 jer su nizovi indeksirani nula. Ne počinjemo od k_LEDPins[4] jer bi to rezultiralo prelaskom završetka niza.

Kôd koristi> = 0 za provjeru tako da prvi element u indeksu 0 ne bude propušten ili zanemaren.

3. poglavlje

Što je ulaz

Tako smo naučili kako upravljati stvarima koristeći Arduino. U ovom ćemo poglavlju razgovarati o tome kako osjetiti stvarni svijet povezivanjem unosa iz vanjskih parametara.

3.1 Korištenje tipki

Svi znamo što je tipkalo i kako to radi. To je vrsta prekidača ili gumba koji trenutno povezuje signal s jednog stupnja kruga na drugi dok je u depresivnom stanju i prekida signal kad se pusti.

3.1.1 Jedan gumb i LED

Arduino ćemo povezati tipkom s Arduinom prema gore prikazanim detaljima i naučiti osnovni rad i provedbu postavljanja.

Označena tipka koja se naziva i tipka s mikro prekidačem, ima ukupno 4 igle (po 2 para na svakoj strani). Kada se gurnu, svaki par pinova spojen je iznutra i omogućuje povezivanje ili provođenje preko njih.

U ovom primjeru koristimo samo jedan par ovih pinova ili kontakata, drugi par je nebitan i stoga se zanemaruje.

Nastavimo, primjenjujemo sljedeći kod i provjerimo da li radi!

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

Možda ćete ovdje pronaći nekoliko stvari koje izgledaju neobično. Pomislimo ih korak po korak.

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

Prvo što napravimo je popraviti buttonPin kao ULAZNI. Pa to je sasvim osnovno, znam.

Dalje, dodjeljujemo VISOKO prema ULAZNI pribadača Pitate se, kako je moguće bilo što napisati na ulazu? Svakako, ovo može biti zanimljivo.

Zapravo, dodjeljivanje HIGH za Arduino ulaz uključuje / isključuje unutarnji povlačni otpor od 20 k Ohma (LOW na ovom pinu ga isključuje).

Još jedno pitanje koje biste mogli postaviti jest koji je otpor na izvlačenje. Objavio sam sveobuhvatan članak o pull-up otpornicima koji vi naučite to ovdje .

OK, idemo dalje, pogledajmo sada glavni kôd petlje:

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

Kad pritisnete tipku, ožičeni se pin spaja na masu, što daje a NISKO na tu pribadaču. I dok je u pritisnutom stanju, drži se isti klin VISOKO ili + 5V putem 20K unutarnjeg otpornika na izvlačenje.

Ovdje želimo da Arduino svijetli LED kad se pritisne tipka (LOW), stoga pišemo HIGH za izlaz za svaki odgovor LOW-a s tipke, dok je pritisnuta.

3.1.2 Dvije tipke i LED

Pa, možda se pitate da je gore prikazana akcija mogla biti izvedena i bez Arduina. Razumijem, međutim, ovo je moćan kamen da naučim kako se gumb može koristiti s Ardunom.

Do ovog trenutka proučavali smo pisanje kodova za UKLJUČENO (VISOKO) ili ISKLJUČENO (LOW) LED.

Sada da vidimo kako se svjetlina LED-a može kontrolirati pomoću Arduina.

To se može učiniti pomoću dvije metode:

1. Ograničavanjem količine struje na LED
2. Pomoću PWM ili modulacija širine impulsa, u kojoj se napajanje LED diode vrlo brzo UKLJUČUJE / ISKLJUČUJE pri određenoj željenoj brzini, stvarajući prosječno osvjetljenje čiji bi intenzitet ovisio o PWM-u.

Na Arduino ploči PWM podrška dostupna je na pinovima označenim tildom (~), koji su pinovi 3, 4,5,9,10 i 11) na 500Hz (500 puta u sekundi). Korisnik može pružiti bilo koju vrijednost između 0 i 255, pri čemu se 0 odnosi na VISOKO ili nikakvo + 5V, a 255 govori Arduinu da cijelo vrijeme dobije VISOKO ili + 5V. Za pokretanje ovih naredbi morat ćete pristupiti analogWrite () sa željenom vrijednošću.

Možete pretpostaviti da je PWM x / 255 gdje je x željena vrijednost koju želite poslati putem analogWrite().

Postavite Arduino i ostale parametre kako je gore prikazano.

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

Ovdje možete pronaći 3 retka koja trebaju neko objašnjenje.

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

Redak: ledBrightness = constrain(ledBrightness, 0, 255) ilustrira jedinstvenu funkciju unutar Arduina poznatu kao constrain ().

Ova unutarnja funkcija sadrži kod srodan sljedećem:

int ograničenje (int vrijednost, int min, int max)
{
if(value > max){
value = max
}
if(value value = min
}
return value
}

Svi kodovi o kojima se raspravljalo prije ovoga započeli su s poništiti , što je značilo da se ništa ne vraća (ništa). Dok gornji kod započinje s int , što znači da vraća cijeli broj. O tome ćemo raspravljati u kasnijim odjeljcima, trenutno se samo sjetite da cijeli broj nema razlomljene dijelove.

Točno, pa to podrazumijeva, kod: ledBrightness = constrain(ledBrightness, 0, 255) dodjeljuje ledBrightness to be within the range of 0 and 255.

Sljedeći redak koristi analogWrite za naredbe Arduinu da primijeni PWM na odabrani pin sa željenom vrijednošću.

Sljedeći redak stvara kašnjenje od 20 milisekundi, čime se osigurava da ne prilagodimo jelo brže od 50 Hz ili 50 puta u sekundi. To je zato što ljudi mogu biti puno sporiji od Arduina. Stoga, ako ne dođe do kašnjenja, program bi mogao osjetiti da je pritiskom na prvi gumb isključena LED dioda, a pritiskom na drugi gumb UKLJUČEN (pokušajte sami potvrditi).

3.2 Potenciometri

Krenimo dalje i naučimo koristiti potenciometri s Arduinom.

Da biste znali kako funkcioniraju potenciometar ili lonac, možete pročitati ovo članak .

Povežite prikazane parametre sa svojim Arduinom kao što je prikazano gore.

Pot će imati 3 terminala. Srednji terminal priključit će se na ANALOG IN 0 na Arduinu. Druga dva vanjska terminala mogu biti spojena na opskrbne tračnice + 5V i 0V.

Programirajmo i provjerimo 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)
}

Pronaći ćete nekoliko stvari koje mogu izgledati potpuno novo i nisu uključene u bilo koji od naših ranijih kodova.

1. Konstanta kPinPot dodijeljen je kao A0, pri čemu je A prečac za opis jednog od analognih pinova. Međutim, A0 se također odnosi na pin # 14, A1 na pin # 15 i tako dalje, a oni vam omogućuju upotrebu kao digitalne ulaze / izlaze u slučaju da vam za eksperiment ponestane iglica. Ali imajte na umu da digitalne igle ne možete koristiti kao analogne.
2. Redak: ledBrightness = map(sensorValue, 0, 1023, 0, 255) predstavlja novu unutrašnju funkciju u Arduinu poznatu kao karta(). Ova se značajka ponovno kalibrira iz određenog raspona u drugi, nazvan kao karta (vrijednost, odLow, fromHigh, toLow, toHigh). Ovo može postati presudno jer analogueRead daje vrijednost u rasponu od 0-1023, ali analogWrite može prihvatiti vrijednost od 0-255.

Možda mislite da, budući da je moguće kontrolirati svjetlinu LED-a pomoću promjenjivog otpora, jednostavno je lonac mogao biti dovoljan u svrhu, zašto uporaba Arduina. Pa, opet, samo je temelj pokazati kako se lonac može konfigurirati s Arduinom.

Nema problema, sada ćemo napraviti nešto što se ne može bez Arduina.

U ovom ćemo eksperimentu vidjeti kako se različiti otpor lonca može koristiti za kontrolu brzine treperenja ili brzine LED-a.

Evo programa:

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 Izbjegavanje kašnjenja ()

Gornji kod izgleda dobro, ali LED ne može provjeriti vrijednost pota dok ne prođe kroz svaki puni ciklus. Za dulja kašnjenja ovaj postupak postaje sve duži, korisnik mora pričekati da vidi odgovor na lonac dok ga premješta. To se kašnjenje može izbjeći nekim inteligentnim programiranjem, tako da omogućuje korisniku da provjeri vrijednost bez minimalnih kašnjenja. Evo 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)
}
}

Pa što se to razlikuje u gornjem kodu? Sljedeći redak čini razliku.

long lastTime = 0

Do ovog odjeljka raspravljali smo o varijabli int. Međutim, možda postoji još mnogo varijabli tipova kojima možete pristupiti. Popis možete pročitati u nastavku:

Trenutno je možda samo presudno znati da za pohranu relativno velikog broja za int varijabla, mogli biste upotrijebiti izraz dugo ili a dugo int.

Ovdje možete vidjeti još jednu zanimljivu funkciju tzv milis ().

To stvara vremenski raspon u milisekundama koje je Arduino radio u svom radu od početka (to će se vratiti na 0 nakon svakih 50 dana). Ovdje se vraća dugo jer ako se vratilo int , brojanje duljeg razdoblja možda neće biti moguće. Možete li odgovoriti točno koliko dugo? Odgovor je 32.767 sekundi.

Stoga, umjesto da koristimo delay (), provjeravamo ima li milisa (), a čim prođe određeni broj milisekundi, mijenjamo LED. Stoga pohranjujemo vrijeme u kojem smo ga zadnji put promijenili posljednji put varijabla, tako da nam omogućuje ponovnu provjeru kad god to poželimo.

3.3 RGB LED diode

Do sada smo se igrali s jednobojnom LED diodom. Iako bi se LED boja mogla promijeniti zamjenom LED-a drugom bojom, ali kako bi bilo da se koriste RGB LED diode za promjenu LED boja bez promjene LED-a?

RGB LED je u osnovi LED koji ima crvenu, zelenu i plavu LED ugrađenu i spojenu u jednu LED. Ima jedan zajednički kabel koji ide na tlo ili 0V opskrbnu tračnicu, dok su ostala 3 kabela napajana raznolikim PWM pozitivnim signalima za provođenje namjeravanog miješanje boja .

Postavke možete ožičiti kao što je prikazano dolje:

Možda izgleda malo složeno, ali zapravo je replika našeg ranijeg dizajna LED upravljanja pomoću PWM-a.

Evo programskog koda za praksu:

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

Nakon što prenesete ovaj kod, samo pogledajte kako prilagodbe lonaca stvaraju zanimljiv svjetlosni efekt na RGB-u, to može biti prava zabava.

Otkrit ćete da kada se sva 3 lonca pomaknu u maksimalne položaje, umjesto bijele boje vidjet ćete crvenu. To je zato što je crvena boja najistaknutija među 3 boje i stoga dominira u ovoj situaciji. Međutim, možete eksperimentirati s funkcijom karta() , prije izvođenja na crveni dio LED-a, kako bi se stvorila osjetnija ravnoteža.

Audio s Arduinom

U ovom ćemo odjeljku naučiti kako dodati osnovni zvuk i glazbu u postavku Arduina.

Vidjet ćemo kako prebaciti signal na povezani zvučnik sa željenom frekvencijom.

Točnije, pokušat će se srednja nota, a to je nota frekvencije 440 Hz.

Da bismo to učinili, jednostavno ćemo pustiti notu srednje A i optimizirati signal sinusnog vala kvadratnim valom.

Također ćemo izračunati koliko vremena zvučnik može ostati UKLJUČEN tužbom formule:

timeDelay = 1 sekunda / 2 x tonFrekvencija.

timeDelay = 1 sekunda / 2 x 440

timeDelay = 1136 mikrosekundi

4.1 Priključimo Arduino ploču

4.2 Dodavanje jednostavne bilješke

O funkciji smo već razgovarali odgoditi() gdje je jedinica u milisekundama (sekunda / 1000), međutim naći ćete još jednu funkciju delayMicroseconds() gdje je jedinica u mikrosekundama, (milisekunda / 1000).

Za sadašnju postavku programiramo kod za uključivanje / isključivanje + 5 V na odabranom pinu povezanom sa zvučnikom, brzinom od 440 impulsa u sekundi.

Podsjetimo, u posljednjoj raspravi odredili smo vrijednost 1136 mikrosekundi za predviđenu zvučnu notu.

Dakle, evo programa za ovo, koji će vam omogućiti da čujete zvučnu notu od 440 Hz čim programirate arduino s povezanim zvuč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)
}

Pomoću gornje aplikacije moguće je napraviti zvučnu notu, što također znači da možemo stvoriti glazbu prema vlastitom izboru.

Iz koda shvaćamo da Arduino uključuje nekoliko integriranih funkcija što dodatno pridonosi stvaranju glazbe.

Prvi je ton() koji radi s 2 elementa zajedno s trećim opcijskim elementom, označenim kao ton (pin, frekvencija, trajanje). ili ton (pin, frekvencija)

Oboje su određeni za izvršavanje odgovarajućeg vremenskog razdoblja koje ste odredili.

Ako nema vremenskog razdoblja, glazba će se reproducirati do poziva ton() se izvršava ponovno ili dok ne izvršite notone ().

To će trebati učiniti pomoću funkcije odgode u slučaju da je sviranje glazbe jedina temeljna stvar koju provodite.

Vremensko trajanje može biti presudno, jer omogućuje određivanje vremena koliko dugo se glazba svira, tako da možete slobodno raditi i druge stvari. Čim protekne trajanje, glazba prestaje.

Sljedeća funkcija noTone () obrađuje jedan parametar i zaustavlja odabrani ton na određenom dodijeljenom pinu.

Osobito upozorenje: bilo kad ton() funkcija je implementirana, PWM funkcija na pinovima 3 i 11 prestat će raditi.

Stoga, kad god se u programu koristi privitak zvučnika, pripazite da ne koristite spomenuti pin za zvučnike, već pokušajte s nekim drugim pribadačama za pričvršćivanje zvučnika.

U redu, pa evo programa za implementaciju glazbe na zvučniku, iako to nije prava glazba, već osnovna nota na ljestvici 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)
}

U gornjem kodu ste možda primijetili nešto novo i to je #definirati .

Ovaj pojam djeluje poput naredbe za pretraživanje i zamjenu za računalo dok se vrši sastavljanje.

Kad god pronađe prvu stvar ispred razmaka, zamijeni je preostalim dijelom retka (zvanim makronaredbe).

Dakle, u ovom primjeru kada računalo vidi NAPOMENA_E4 brzo ga zamjenjuje s količinom 330.

Za više napomena i prilagodbe možete uputiti datoteku s USB ključa pod nazivom tereni.h , gdje se može naći većina frekvencija prema vašim željama.

4.4 Glazba s funkcijama

Gornji kod izgleda dobro, ali čini se da ima puno ponavljanja, trebala bi postojati neka metoda za skraćivanje tih ponavljanja, zar ne?

Do sada smo radili s dvije ključne funkcije uključene u Arduino. Sad je možda vrijeme da stvorimo vlastite funkcije.

Svaka funkcija mora započeti s vrstom varijable s kojom može biti povezana. Na primjer funkcija poništiti odnosi se na tip koji ne vraća ništa pa otuda naziv void. Napomena, već smo raspravljali o popisu varijabli u našim ranijim odjeljcima, možda biste ih trebali uputiti.

Slijedom toga, određeno ime funkcije dobiva otvorenu zagradu '(' nakon čega slijedi popis parametara odvojenih zarezom.

Svaki od parametara dobiva svoj tip zajedno s imenom, a na kraju i close ')' zagrada.

Ti se parametri mogu primijeniti unutar funkcije u obliku varijabli.

Pogledajmo donji primjer u kojem razvijamo funkciju tzv ourTone () dizajniran za spajanje ton() s odgoditi() redaka, na način da se funkcija prestaje vraćati dok nota ne završi s reprodukcijom tona.

Ove funkcije implementiramo u naš prethodni kod i dobivamo donji program, pogledajte posljednje retke:

#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 mogu biti izuzetno korisne za olakšavanje razumijevanja programa.

Slijedi primjer gdje možemo odrediti izbor tona koji želimo reproducirati pomoću dva niza. Jedan niz za zadržavanje nota, drugi za zadržavanje otkucaja.

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

Na prvom retku možete jasno vidjeti uvod #include izjava. Posao ove izjave je podići cijelu datoteku između navodnika i postaviti je na položaj #include izjava. Prema standardnim pravilima, ona su strogo postavljena na početku programa.

5. poglavlje

Mjerenje temperature

Samo da se prisjetimo, sjetite se, umjesto da uopće pišete velike programe, uvijek je pametno pisati i analizirati male dijelove kodova, što pomaže u brzom pronalaženju pogrešaka.

5.1 Serijski monitor

Do sada se čini da kodovi o kojima smo razgovarali nisu toliko jednostavni da omoguće brzo rješavanje problema. Ovdje ćemo pokušati olakšati nadzor i lakše rješavanje mogućeg problema.

Arduino ima značajku koja mu omogućuje 'odgovor' s računalom. Mogli biste primijetiti da su pin0 i pin1 označeni kao RX i TX jedan pored drugog. Te se igle zapravo prate zasebnim IC-om unutar Arduina koji ih nadograđuje tako da čitaju preko USB kabela dok je priključen na računalo.

Sljedeći odjeljak prikazuje punopravni program, molim vas, nastavite, naučit ćemo o novim unosima u kodu nakon toga. Ovaj je kod isti kao i izraženi odjeljak 2.2, osim činjenice da uključuje neke dodatne podatke koji nam omogućuju prepoznavanje za što je kodiran.

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

Ovdje možete prepoznati dvije nove stvari, novi redak u postaviti() funkcija.

Serial.begin(9600)

Ovaj redak jednostavno izražava potrebu korištenja Serijski1 kod za njegovo provođenje s 9600 baud-ova. (ovdje se serijski odnosi na komadići šalje se jedno za drugim, a baud znači brzina kojom se šalje). Ova vrijednost prijenosa podataka i vrijednost unutar serijskog monitora (to ćemo naučiti kasnije) moraju biti jednake, inače će podaci u serijskom monitoru pokazivati ​​smeće. 9600 kao standard postaje praktičniji za upotrebu.

Drugi novi unos su sljedeći

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

Ovdje drugi redak sugerira da će sljedeća stvar koja izlazi iz serijskog porta započeti u sljedećem retku. Po tome se druga linija razlikuje od prve linije.

Još nešto što možete vidjeti su citati ('). Ovo je poznato kao niz koji će se ovdje koristiti samo poput konstanti, jer daljnja rasprava o ovoj temi može biti previše razrađena i izvan opsega.

U redu, sada možemo prenijeti gornji kod u Arduino i vidjeti što će se dogoditi.

Što se, ups, čini se da se ništa nije dogodilo, LED dioda Arduino # 13 trepnula je i zaustavila se, dok je Tx LED i dalje treptao.

Pa, to je zato što prozor Serial Monitor još nije popravljen.

Morate kliknuti na okvir Serial Monitor u svom IDE-u kao što je gore prikazano. Ne zaboravite provjeriti brzinu prijenosa koja se nalazi dolje desno, prema zadanim postavkama trebala bi biti 9600 i odgovarat će kodu. Ako nije obavezno odaberite 9600.

Sljedeći video isječak objašnjava kako se to radi.

Ajmo sada naprijed i naučimo kako gornja značajka serijskog monitora može pomoći u obradi mjerenje temperature pomoću Arduina

Upotrijebit ćemo IC TMP36 kao temperaturni senzor u rasponu od -40 do 150 Celzijevih stupnjeva.

Postavljanje se može vidjeti u nastavku:

Sljedeći će kôd pokrenuti mjerenje temperature očitavanjem izlaza s TMP36 senzora i njihovim slanjem na serijski monitor ID-a.

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
}

Razumijemo kod s vrha.

float temperatureC = getTemperatureC()

Ovdje možete vidjeti da smo uključili tip varijable plutati.

Ovo je jedina vrsta varijable koja sadrži mogućnost pohrane svega osim cjelobrojnih brojeva (brojeva bez decimalnih ili razlomljenih dijelova).

Točnost varijable float može biti do 6 do 7 znamenki.

Pridruženi kod getTemperatureC() je naša vlastita funkcija koja matematički izračunava i pretvara osjetnu razliku napona sa TMP36 osjetnika u stupnjeve 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
}

U sljedećem odjeljku kodova, budući da pojam analogIn() dodijeljen je za vraćanje broja između 1 i 1023, postaje nam moguće procijeniti napon sa senzora množenjem očitanja s 5 i dijeljenjem s 1024.

Senzor TMP36 određen je za generiranje 0,5 V na 0 Celzijevih stupnjeva, a zatim generira 10 mV za svaki pojedinačni porast Celzijevog stupnja.

Evo aproksimacije koju možemo generirati proračunima:

Možete smatrati svojom prvom funkcijom koja vraća neku vrijednost (imajte na umu da sve preostale funkcije do sada nisu vratile nikakvu vrijednost jer su tipa poništiti ).

Možete razumjeti da biste dobili vrijednost iz funkcije, jednostavno morate dodati povratak nakon čega slijedi željeni broj koji želite vratiti.

Kad kažemo povratak to znači da funkcija vraća odgovor ili odgovor kad god se pozove, a koji bi se mogao primijeniti na varijablu.

Kada se ovo pošalje serijskom monitoru, očitanje se pretvara u Fahrenheit convertToF ().

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

Ova funkcija uzima raspon Celzija i pretvara ga u Fahrenheit.

Za pretvaranje Fahrenheita u Celzijus provodimo formulu Fahrenheit = 9 / 5 (Celzija) + 32.

5.3 Povezivanje LCD zaslona

Sada proučimo kako povezati ili spojiti LCD zaslon s Arduinom za dobivanje vizualnog prikaza potrebnih rezultata.

U našoj ćemo aplikaciji upotrijebiti grafički LCD 84x48, vodoravno 84 piksela ili točkice i vertikalnu razlučivost 48 piksela. Budući da namjenski kontroler postaje imperativ za sve LCD zaslone, sadašnji uređaj također uključuje jedan u obliku PCD8544 kontrolera.

U ovom uputstvu spojit ćemo gore navedeni LCD modul s Arduinom i primijeniti određene rutine za stvaranje tekstualnih poruka na zaslonu.

Na sljedećoj slici možete pronaći detalje u vezi s povezivanjem LCD-a, zajedno s malim 3.3V regulator napona . Ovaj regulator je neophodan jer je LCD predviđen za rad s napajanjem od 3,3 V.

Također možete vidjeti 8 izvoda iz LCD modula, a specifikacije izvoda mogu se proučiti iz sljedeće tablice:

Sada da vidimo kako možemo povezati LCD i relevantne parametre s našim Arduinom. Pojedinosti se mogu prikazati na dolje prikazanoj ilustraciji:

5.4 Komunikacija s LCD-om

Iako je iz Arduina moguće napisati složene korake za interakciju s LCD-om, radije ćemo naučiti kako to učiniti pomoću biblioteka.

Knjižnice sadrže niz kodova koji se mogu brzo primijeniti za odabrani Arduino program.

To omogućava korisniku da bez napora pozove funkciju bez potrebe za složenim kodiranjem.

5.4.1 Kako instalirati knjižnicu

Za to ćete morati stvoriti direktorij zvan knjižnice na vašem računalu Arduino IDE, kako je objašnjeno ovdje

5.4.2 Provođenje LCD operacija

Baš kao i naš prethodni pristup, prvo ćemo provjeriti cijeli kôd, a zatim pokušati razumjeti detalje pojedinih redaka.

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

Redak uključuje šifru #include

Kôd #include upućuje računalo da preuzme spomenutu datoteku i zamijeni element #include sadržajem datoteke tijekom sastavljanja programa.

Element #include može imati kutne zagrade što ukazuje na pretraživanje u direktoriju biblioteke, a može imati i navodnike koji ukazuju na traženje unutar istog direktorija u kojem se nalazi program.

Sljedeći retci koda izražavaju LCD pinoute, a zatim napišemo novi oblik varijable:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Ovdje izražavamo varijablu s imenom lcd tipa PCD8544 i upućujemo računalo da nadograđuje svoje pinoute povezane s Arduinom.

U ovom procesu opisujemo varijablu na računalu upućujući kako su pin clk, din, dc i reset povezani s Arduinom.

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

Redak lcd.init() inicijalizira rad LCD-a. Nakon što se ovo izvrši, sljedeći redak postavlja kursor u gornjem lijevom dijelu zaslona. I sljedeći se sljedeći redak trudi ispisati poruku 'Zdravo, svijet'.

Ovo izgleda posve identično tehnici kojom smo slali poruke preko serijskog monitora. Jedina razlika je u upotrebi koda lcd.print umjesto serijskog.tisak.

Sljedeći blok koda se zapravo ponavlja.

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

Koristeći ovu liniju lcd.setCursor(0,1) fiksiramo kursor na 0. stupac krajnje lijevo od 1. retka, preko LCD zaslona.

Sljedeći redak koristi prečac: lcd.print(millis())

Ako se sjećate, surađivali smo s millis() u našim ranijim kodovima, mogli smo isto primijeniti i ovdje putem kodova:

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

Međutim, zbog činjenice da ovdje nije riječ o vremenskim razdobljima u milisekundama, to postižemo jednostavnim slanjem millis() funkcija izravno na lcd.print() .

5.5 Kombiniranje cijele stvari

U redu, kombinirajmo sve kodove koje smo gore naučili za izradu LCD temperaturnog kruga i pogledajmo kako to 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
}

U gornjem programu sve izgleda standardno, osim upotrebe funkcije setCursor () . To se koristi za poravnavanje teksta što je više moguće oko sredine zaslona.

Sjajno! Čestitamo, upravo ste programirali svoj vlastiti mali LCD indikator temperature pomoću Arduina.

Praktične Arduino aplikacije

Budući da smo u ovom trenutku detaljno pokrili razne tehnike programiranja, vrijeme je da ih provjerimo primjenjujući ih za nekoliko korisnih praktičnih implementacija.

Započet ćemo sa senzorima i vidjet ćemo kako se senzorski uređaji mogu koristiti s Arduinom izvođenjem nekoliko uzoraka kodova.

7.1 Uvod u senzore

U ovom uputstvu naučit ćemo o širokoj paleti senzora koji se mogu koristiti s Arduinom. To mogu uključivati ​​uređaje poput LDR senzora svjetlosti, magnetskog senzora efekta Hall-a, senzora nagiba, senzora vibracija, senzora tlaka itd.

Počet ćemo s povezivanjem svjetlosni senzor LDR s Arduinom, kao što je prikazano na sljedećem dijagramu:

Kao što svi znamo, LDR je otporni uređaj ovisno o svjetlu čiji otpor ovisi o intenzitetu okolnog pada na njegovu površinu.

Intenzitet svjetlosti obrnuto je proporcionalan očitanju otpora LDR-a.

Ovdje ćemo naučiti kako se ovo svojstvo može integrirati s Arduinom za izvršavanje korisne aplikacije:

Kompletni programski kôd može se vizualizirati na sljedeći način:

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

Svi parametri korišteni u kodu već su raspravljeni u našem tečaju koji smo do sada naučili. Redove možete provjeriti pozivanjem na odgovarajuće odjeljke.

Vrijednosti su odabrane slučajnim odabirom, a lako ih možete mijenjati prema vlastitim željama.

Senzor nagiba

Senzor nagiba je jednostavan uređaj koji se može koristiti za otkrivanje djelovanja nagiba na bilo kojem objektu na kojem je instaliran. Uređaj u osnovi ima metalnu kuglu koja se pri naginjanju kotrlja preko para kontakata uzrokujući provođenje preko tih kontakata. Ti se kontakti završavaju kao vodovi preklopne sklopke, a koriste se s vanjskim krugom za otkrivanje vodljivosti uslijed djelovanja naginjanja i aktiviranje željene izlazne aplikacije.

Sada da vidimo kako a senzor nagiba uređaj bi se mogao ožičiti. Slika ispod daje nam ideju u vezi s kompletnom konfiguracijom:

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

U ovom se primjeru zadani LED broj # 13 koristi kao indikator nagiba.

Ovdje možete jasno vidjeti uključivanje pull-up otpora, prilično slično onome što smo učinili u odjeljku 3.1. Stoga izraz LOW označava da funkcija nagiba nije aktivirana.

7.4 Relej prekidača s trstikom (relej aktiviran minijaturnim magnetom)

Sad da vidimo kako spojiti relejni prekidač ili senzor magnetskog polja s Arduinom. Reed relej je vrsta prekidača koji se aktivira ili provodi kad mu se približi magnetsko polje ili magnet. U osnovi ima par feromagnetskih kontakata unutar minijaturnog staklenog kućišta koji se spajaju ili ostvaruju kontakt zbog magnetskog povlačenja kad god je magnet u njegovoj neposrednoj blizini. Kada se to dogodi, terminali kontakata pokazuju provodljivost zbog zatvaranja kontakata.

I ovdje koristimo LED # 13 za označavanje odgovora. Možete povezati vanjsku LED diodu s ovog pina ako je potrebno prema našim ranijim objašnjenjima.

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

Pojmovi koda trebaju biti poznati i razumljivi.

7.5 Senzor vibracije pomoću Piezo pretvarača

U sljedećem primjeru programa vidjet ćemo kako a piezo pretvarač može se koristiti kao senzor vibracija za osvjetljavanje LED diode kroz Arduino.

Piezo element zapravo je uređaj koji generira vibracije ili oscilacije kada se frekvencija primijeni na njegove stezaljke. Međutim, isti bi se piezo mogao koristiti u obrnutom postupku za generiranje električnih impulsa kao odgovor na vibracije koje se primjenjuju na njegovo tijelo. Ova vibracija može biti u obliku kucanja ili udara o površinu pieza.

Postavite Arduino i piezo element kao što je dato na sljedećoj slici

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 uveden je samo kako bi se osiguralo da Arduino reagira samo na istinske vibracije udarcima, a ne i na druge manje vibracije poput glasnih zvukova ili sirene.

Odabir A5 pina nije obvezan, možete odabrati bilo koji drugi analogni ulaz prema vašoj želji i podudaranjem s njim u programskom kodu.

Korištenje servo motora s Arduinom

Servo motor je vrsta istosmjernog motora koji se može rotirati pod preciznim kutovima prema zahtjevu određene primjene. To se može učiniti primjenom izračunate naredbe na odgovarajuće ulaze motora kako bi se na motoru postigao točan kut rotacije ili okretanja unutar raspona od 180 stupnjeva.

Servo motor obično ima 3 žice ili ulaza. Pozitivne žice obično su crvene boje, negativne ili uzemljene žice su crne, a naredbena žica ili signalna žica su obično bijele ili žute boje.

Arduino olakšava upravljanje servo motorom zahvaljujući ugrađenom jeziku podrške što upravljanje čini vrlo praktičnim i idealnim za servo motore.

Sljedeći primjer pokazat će nam osnovni program za postavljanje implementacije upravljanja servo motorom kroz Arduino:

Kôd je dan u nastavku:

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

Ovdje možemo vidjeti nekoliko novih unosa. Onaj koji pripojenoj žici servoa govori kojem je pinu dodijeljen. Drugi je kod koji osigurava vrijednost pina između 0 i 180, za određivanje kuta rotacije na servo-u.

Zaključak

Predmet Arduino može biti beskrajno dugačak i prema tome izvan dosega ovog članka. Međutim, nadam se da vam je gornji vodič sigurno trebao pomoći da naučite same osnove Arduina i razumijete važne parametre kroz razne primjere kodova aplikacija.

Nadamo se da će se ovdje povremeno ažurirati više informacija, kad god budu dostupne.

U međuvremenu uživajte u svom tečaju programiranja, sretan vam Arduinoing !!