Naučiť sa základné programovanie Arduina - návod pre nováčikov

V tomto tutoriáli sa naučíme, ako vykonávať základné programovanie Arduina prostredníctvom ukážkových kódov a ukážkových programov. Tento tutoriál môže byť nesmierne cenným kurzom pre všetkých nováčikov, ktorí chcú pochopiť základy jednoduchým a zrozumiteľným jazykom.

Úvod

Podľa wikipedia mikrokontrolér je ekvivalentom mini počítača zabudovaného do jediného čipu IC, ktorý má vlastný jadrový procesor, programovateľné vstupy, pamäť a výstupné periférie.

Mikrokontrolér sa stáva pre používateľa taký užitočný, pretože ponúka vstavaný procesor, pamäť a vstupné / výstupné porty (nazývané tiež GPIO alebo univerzálne vstupné / výstupné piny), ktoré môže používateľ ovládať podľa akýchkoľvek požadovaných špecifikácií.

V tomto výučbe budeme pracovať s doskou Arduino Uno na výučbu a testovanie programov. Na testovanie a integráciu hardvérovej montáže použijeme nepájivú dosku.

Poďme teraz rýchlo ďalej a naučme sa, ako začať s programovaním Arduina.

1.2 Inštalácia softvéru (Windows)

Potrebujete na to prístup na internet, ktorý by ste vo svojom počítači samozrejme mali. Prejdite na nasledujúci odkaz a stiahnite si softvér IDE:

Súbor Windows ZIP na inštaláciu iným používateľom než správcom

Po stiahnutí nájdete v priečinku na stiahnutie ikonu nastavenia Arduina, ktorá by vyzerala takto:

Keď to získate, môžete na ne jednoducho dvakrát kliknúť a nainštalovať do svojho počítača Arduino the Integrated Development Environment (IDE). Celý proces je možné vizualizovať v nasledujúcom videu:

1.4 Počnúc našim prvým okruhom

Než sa začneme učiť skutočné techniky programovania, pre každého nováčika by bolo užitočné začať so základnou súčasťou, ako je napríklad LED, a pochopiť, ako ju prepojiť s Arduinom.

Ako vieme, LED je svetelná dióda, ktorá má polaritu a nebude svietiť, ak nie je spojená so správnymi napájacími pólmi.

Ďalším aspektom LED diód je, že tieto zariadenia pracujú s nízkym prúdom a môžu sa okamžite poškodiť, ak do série s jedným z jeho pinov nie je zahrnutý správne vypočítaný odpor.

Pravidlom je, že 330 ohmový 1/4 watt je celkom ideálny pre každé zvýšenie napájacieho vstupu o 5 V, aby sa prúd obmedzil na požadovanú bezpečnú úroveň. Preto pre 5V to môže byť 330 ohmov, pre 10V to môže byť 680 ohmov a tak ďalej.

Používanie nepájivej dosky pre montáž

Uistite sa, že viete, ako používať a doska na pečenie predtým, ako vyskúšame tutoriál vysvetlený v tejto kapitole, pretože by sme tu použili experimentálnu dosku pre všetky experimenty.

Základné nastavenie pripojenia LED je možné vidieť nižšie:

Vyššie môžete vidieť 3 základné komponenty:

1. 5 mm, 20 mA LED
2. rezistor s veľkosťou 330 ohmov, 1/4 wattu
3. An Doska Arduino

Stačí zostaviť systém podľa schémy.

Ďalej zapojte 5V z USB počítača do Arduina. Len čo to urobíte, uvidíte rozsvietiť LED.

Viem, že je to dosť základné, ale vždy je dobré začať od nuly. Buďte si istí, že keď pôjdeme ďalej, začnú byť veci čoraz zaujímavejšie.

1.5 Ovládanie LED pomocou Arduina

Teraz sa naučíme, ako ovládať LED pomocou programu Arduino.

Na napísanie programu musíme mať v každom programe minimálne 2 funkcie.

Funkciu možno chápať ako sériu programovacích príkazov, ktorým je možné priradiť názov, ako je uvedené nižšie:

1. nastaviť() toto sa vyvolá alebo vykoná počas spustenia programu.
2. slučka () toto sa volá alebo vykonáva opakovane počas celého operačného obdobia Arduina.

Aj keď teda nemusí mať žiadnu praktickú funkčnosť, technicky najkratší legitímny program Arduino môže byť napísaný ako:

Najjednoduchší program

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

Možno ste si všimli, že v mnohých programovacích jazykoch systém začína zobrazením jednoduchej tlače „Hello, World“ na displeji

Elektronickým ekvivalentom tejto frázy v interpretácii mikrokontroléra je blikanie LED diódy ZAPNUTÉ a VYPNUTÉ.

Toto je najzákladnejší program, ktorý je možné napísať a implementovať na označenie správneho fungovania systému.

Pokúsime sa implementovať a porozumieť postupu prostredníctvom nasledujúcej časti kódu:

Výpis 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)
}

Dobre, poďme teraz pochopiť, čo každý riadok kódu znamená a ako to funguje pri spustení funkcie:

const int kPinLed = 13

Funguje to ako konštanta, ktorá nám umožňuje používať ju počas celého kurzu programovania bez potreby použitia skutočnej hodnoty nastavenej oproti nej.

Podľa štandardných pravidiel sú tieto konštanty rozpoznané začiatočným písmenom k . Aj keď to nie je povinné, robí veci jasnejšími a ľahšie pochopiteľnými, kedykoľvek máte chuť prejsť podrobnosťami kódu.

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

Tento kód konfiguruje konkrétny pin, na ktorý je pripojená naša LED. Inými slovami, kód hovorí Arduinu, aby namiesto „čítania“ ovládal aspekt „zápisu“ na tomto kolíku.

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

Vyššie uvedené riadky označujú skutočné vykonanie aplikácie. Kód začína napísaním a vykreslením hodnoty HIGH na príslušnom pripojení LED diód, pričom sa rozsvieti LED dióda.

Tu pojem HIGH jednoducho znamená dostať + 5V na príslušný kolík Arduina. Doplňujúci výraz LOW jednoducho označuje nulu alebo 0V na určenom kolíku.

Ďalej voláme delay() ktorého funkciou je vytvorenie oneskorenia v milisekundách (1/1 000 sekundy). Pretože je zadaný údaj 500, implementované oneskorenie bude 1/2 sekundy.

Len čo uplynie táto 1/2 s, vykoná sa ďalší riadok, ktorý LED zhasne s výrazom LOW na rovnakom kolíku.

Nasledujúci riadok opäť generuje 1/2 sekundové oneskorenie, aby LED mohla zostať vypnutá po dobu 1/2 sekundy.

A proces pokračuje nekonečne vykonávaním riadkov kódu, pokiaľ je Arduino napájané.

Pred prechodom na ďalšiu úroveň by som vám odporučil naprogramovať vyššie uvedený kód a skontrolovať, či ste schopní implementovať postupnosť LED ON / OF správne alebo nie.

Pretože predvolená LED v Arduine je spojená s pinom # 13, mala by okamžite reagovať na vyššie uvedený program a začať blikať. Ak však zistíte, že externá LED dióda nebliká, mohlo by dôjsť k poruche spojenia s vašou LED diódou. Môžete skúsiť obrátiť polaritu svojej LED diódy a dúfajme, že bliká tiež.

Môžete hrať s časom oneskorenia tak, že zmeníte číslicu „500“ na inú hodnotu a nájdete LED, ktorá „počúva“ príkazy a spôsobí jej blikanie podľa zadaných hodnôt oneskorenia.

Pamätajte však, že ak LED dióda nebliká konštantnou rýchlosťou 1 sekundy, bez ohľadu na zmenu času oneskorenia, môže to znamenať, že kód kvôli chybe nefunguje. Pretože v predvolenom nastavení bude Arduino programované s frekvenciou blikania 1 sekunda. Preto sa táto rýchlosť musí meniť podľa vášho kódu, aby sa potvrdila jeho správna funkčnosť.

1.7 Komentáre

Riadky kódov, ktoré sme pochopili vyššie, boli špeciálne napísané pre počítačový softvér.

Avšak aby sa zabezpečilo, že užívateľ bude môcť odkazovať na význam riadkov a porozumieť im, môže byť často užitočné a rozumné napísať vysvetlenie vedľa požadovaných riadkov kódov.

Tieto sa nazývajú komentáre ktoré sú napísané iba pre ľudskú alebo používateľskú referenciu a sú kódované tak, aby umožnili počítačom bezpečne ho ignorovať.

Jazyk týchto komentárov je napísaný v niekoľkých formátoch:

1. Štýl bloku komentára, v ktorom je popis komentára uzavretý pod počiatočným symbolom / * a koncovým symbolom * /
2. To nemusí obmedzovať jeden riadok, ale mohlo by to byť rozšírené na ďalšie nasledujúce riadky v závislosti od dĺžky komentára alebo popisu, ako je uvedené v nasledujúcom príklade:

/ * Toto je komentár * /

/ * Rovnako aj toto * /

/ * A
* toto
* ako
* dobre * /

Na napísanie rýchleho jednoriadkového popisu komentára postačujú dva lomky // na začiatku. Toto informuje počítač, že tento riadok nemá nič spoločné so skutočným kódom, a musí sa ignorovať. Napríklad:

// Toto je komentár, ktorý budú počítače ignorovať.

Tu uvádzame príklad:

/*
* 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 Riešenie problémov

Ak zistíte, že váš program pri kompilácii vykazuje chybu, alebo má nejaký iný problém, nasledujúce tipy vám pravdepodobne pomôžu pri opätovnej kontrole kódu a zbavení sa prekážky.

1. V jazyku vášho programu sa budú rozlišovať veľké a malé písmená. Napríklad výraz myVar nemožno napísať ako MyVar.
2. Všetky druhy medzier, ktoré sa môžu zadávať pri písaní na klávesnici, sa nakoniec vykreslia ako jeden priestor a budú viditeľné alebo pochopiteľné iba pre vás. Počítač to nebude brať do úvahy. Zjednodušene povedané, voľné miesta akéhokoľvek druhu nebudú mať žiadny vplyv na výsledky kódu.
3. Každý blok kódu musí byť uzavretý v ľavej a pravej zátvorke, „{“ a '}'
4. Číslice číslic by nemali byť oddelené čiarkami. Napríklad 1000 nemusí byť napísané ako 1 000.
5. Každý riadok kódu uzavretý medzi zloženými zátvorkami musí končiť bodkočiarkou

Vytváranie zaujímavej sekvencie LED svetiel pomocou Arduina

V našej predchádzajúcej kapitole sme sa naučili, ako nepretržite blikať LED diódou s konštantnou rýchlosťou oneskorenia.

Teraz sa dozvieme, ako je možné vykonať rôzne vzory oneskorenia na tej istej LED aktualizáciou programového kódu.

Nebudeme používať externú LED, skôr použijeme predvolenú LED zabudovanú do dosky Arduino na kolíku č. 13. Túto malú LED diódu SMD nájdete hneď za USB konektorom.

2.2 Pochopenie výrokov IF

V tejto časti sa dozvieme, ako nám riadiace štruktúry umožňujú spúšťať jednotlivé kódy, niekedy dokonca opakovane, podľa potreby.

Výkaz ak sa stáva 1. riadiacou štruktúrou. Nasledujúca implementácia ukazuje, ako sa používa:

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

Pokúsime sa postupne porozumieť vyššie uvedenému kódu a zistíme, ako sa dá tento postup použiť pri iných podobných popravách.

Kódy medzi 1. a 7. riadkom sú úplne podobné nášmu pôvodnému programu.

Prvá úprava sa skutočne deje na 8. riadku.

int delayTime = 1000

Nájdete to podobné ako kód v 1. riadku, okrem toho, že v ňom chýba výraz konšt.

Je to jednoducho preto, lebo tento kód nie je konštanta. Namiesto toho je to definované ako premenná , ktorá má v priebehu programovania vlastnosť premennej hodnoty.

Vo vyššie uvedenom príklade vidíte, že tejto premennej je priradená hodnota 1 000. Pamätajte, že také premenné, ktoré sú uvedené v zložených zátvorkách, musia byť striktne napísané iba v pároch zložených zátvorkách a sú označované ako „miestne“ premenné.

Alternatívne sú premenné, ktoré majú byť mimo zložených zátvoriek, ako je tá, o ktorej teraz hovoríme, rozpoznávané ako „globálne“ a je možné ich vykonávať takmer kdekoľvek v rámci programového kódu.

Dopredu môžete vidieť, že kódy medzi riadkami 9 a 11 sú tiež podobné ako v prvom programe, napriek tomu sa veci začnú zaujímať po riadku 11. Pozrime sa, ako!

delayTime = delayTime - 100

V tomto kóde vidíme, že predvolená hodnota delayTime sa upravuje odčítaním 100 od neho.

Od pôvodnej hodnoty 1 000 sa odpočíta význam 100, čím sa získa nová hodnota 900.

Na nasledujúcom obrázku sa pokúsime pochopiť niekoľko matematických operátorov používaných v jazyku Arduino.

Teraz poďme posúdiť kódy medzi riadkami 13 a 15.

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

Hlavným cieľom vyššie uvedeného kódu je zabezpečiť, aby LED dióda pokračovala v blikaní bez prerušenia.

Vzhľadom na to, že sa od pôvodného odpočítava 100 delayTime , zabraňuje blikaniu LED dosiahnuť nulu a umožňuje nepretržité rozsvietenie blikania.

Nasledujúci obrázok zobrazuje niekoľko operátorov porovnávania, ktoré by sme použili v našich kódoch:

V našom vyššie uvedenom kóde sme mohli otestovať, aby bol kód if(delayTime == 0).

Pretože však záporná hodnota môže byť rovnako zlá, nešli sme do toho a toto je odporúčaný postup.

Popremýšľajte, aký by to mohol byť výsledok, keby sme sa pokúsili odpočítať 300 namiesto 100 od delayTime?

Takže teraz ste si možno uvedomili, že ak delayTime je zapísané ako menšia alebo rovná nule, potom by bol čas oneskorenia nastavený späť na pôvodnú hodnotu 1000.

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

Posledné 4 riadky kódu, ako je uvedené vyššie, zodpovedajú za nepretržité zapínanie a vypínanie LED diód.

Tu si môžete jasne všimnúť, že namiesto použitia určitého počtu číslic sme použili premennú na priradenie času oneskorenia, aby sme ho mohli počas prevádzkovej doby kódu upraviť tak, ako chceme. To je v pohode, však?

2.3 INÉ vyhlásenia

Tu sa dozvieme, prečo a ako ak termín môže mať klauzulu inak aby v prípade rozhodla situácia ak tvrdenie je nepravdivé.

Je mi ľúto, ak to znie príliš mätúco, nebojte sa, pokúsime sa to pochopiť pomocou nasledujúceho príkladu:

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

Vo vyššie uvedenom príklade môžete dobre vidieť, že v 10. riadku sa kód vykoná iba pri znakoch delayTime je menšie alebo rovné 100, ak nie, vykoná sa kód v 13. riadku, ale nikdy sa nemôže stať, že dôjde k spoločnému uskutočneniu, buď bude implementovaný 10. alebo 13. riadkový kód, nikdy nie obidva.

Možno ste si všimli, že na rozdiel od toho, čo sme robili v našej predchádzajúcej časti 2.2, sme tu neporovnávali s 0, ale v porovnaní so 100. Je to preto, že v tomto príklade sme porovnávali PRED tým, ako sme odpočítali 100, naopak v časti 2.2, sme porovnali PO odpočítané. Viete povedať, čo by sa mohlo stať, keby sme porovnali 0 namiesto 100?

2.4 VYHLÁSENIA KEĎ

TO zatiaľ čo vyhlásenie je dosť podobné ak vyhlásenie, s výnimkou pravdy, že spôsobuje opakované vykonávanie bloku kódu (ktorý môže byť medzi zloženými zátvorkami) tak dlho, ako sú podmienky použiteľné, a funguje to bez inak vyhlásenie.

Nasledujúci príklad vám pomôže lepšie to pochopiť

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

Dokážete odhadnúť, na čo je vyššie uvedený kód naprogramovaný? Je navrhnutý tak, aby blikal LED rýchlejšie a potom pomalšie.

2.5 Čo je pravda a lož?

V programovacom jazyku nepravdivé označuje nulu (0). V skutočnosti sa výraz „true“ nepoužíva, namiesto toho sa predpokladá, že keď nie je nič nepravdivé, potom je zahrnuté všetko, čo je zahrnuté.

Vyzerá to trochu zvláštne, napriek tomu to robí prácu pekne pekne.

Pokúsime sa situáciu pochopiť prostredníctvom nasledujúceho príkladu.

Niekedy sa môžete stretnúť s kódom, ako je uvedené nižšie:

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

Toto je kódované a vyzerá to tak, že výkon LED bude držať bicykel navždy, pretože je k dispozícii dlhá energia.

Jedna nevýhoda tohto typu kódu by však mohla vzniknúť, keď používateľ omylom použije namiesto == a =.

Som si istý, že už viete, že = znamená priradenie, čo znamená, že sa používa na označenie vybranej hodnoty pre premennú, zatiaľ čo a == sa používa na vynútenie testu, ak je hodnota rovnaká.

Predpokladajme napríklad, že je potrebné, aby LED dióda blikala so sekvenčným zrýchlením a opakovane, ale nesprávne ste použili = namiesto ==.

Kód by sa potom javil takto:

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
}

Táto chyba priradí 0 k delayTime a povedie k ak príkaz na kontrolu, či 0 bola pravda alebo nie. Pretože 0 odkazuje na false, bude si myslieť, že to nie je pravda, a zastaví vynucovanie delayTime = 1000, ale namiesto toho funkcie delayTime sa v priebehu cyklu () drží na 0.

To vyzerá veľmi nežiaduce !!

Vždy si teda dôkladne skontrolujte program, aby ste sa uistili, že ste neurobili také hlúpe chyby.

2.6 Kombinácie

Niekedy môžete cítiť potrebu testovať viac vecí naraz. Možno budete chcieť preskúmať, či bola premenná medzi dvoma číslami. Aj keď to možno implementovať pomocou príkazu if viackrát, môže byť pohodlnejšie použiť logické kombinácie na lepšie a ľahšie čítanie.

Implementáciu kombinácií logických výrazov je možné vykonať tromi metódami, ako je uvedené v nasledujúcej tabuľke:

Bolo by zaujímavé vedieť, že operátor NOT môže pracovať ako prepínač premennej, ktorá môže byť označená ako buď pravda alebo nepravdivé (alebo NÍZKY alebo VYSOKÝ).

Nasledujúci príklad ilustruje stav:

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

Tu je ledState bude LOW a následne, hneď ako ledState = !ledState, sa zmení na HIGH. Nasledujúca slučka spôsobí ledState byť VYSOKÝ, keď ledState = !ledState je nízky.

2.7 PRE vyhlásenia

Teraz sa pokúsime pochopiť ďalšiu kontrolnú štruktúru, ktorá je a pre slučka. To môže byť veľmi užitočné, keď chcete niečo implementovať niekoľkokrát.

Poďme to pochopiť na nasledujúcom príklade:

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 rade s nájdete niečo jedinečné pre.

Je to kód i ++? . To je užitočné pre programátorov, ktorí sú dosť leniví a chcú implementovať kódovanie pomocou pohodlných skratiek

Vyššie uvedený výraz je známy ako zložené operátory, pretože kombinujú jedného operátora priradenia s iným operátorom priradenia. Najobľúbenejšie z nich si môžete prezrieť v nasledujúcej tabuľke:

Zistíte, že vo vyhlásení for sú 3 čiastkové výkazy. Je štruktúrovaný tak, ako je uvedené nižšie:

for (statement1conditionstatement2){
// statements
}

Výrok # 1 sa vyskytuje hneď na začiatku a iba raz. Podmienka sa testuje zakaždým v priebehu cyklu. Kedykoľvek to je pravda vo vnútri zložených zátvoriek sa uplatní následné vyhlásenie # 2. V prípade a nepravda, systém skočí na ďalší blok kódu.

Pripojenie ďalších LED diód

Dobre, teraz uvidíme, ako môžeme spojiť viac čísel LEd pre získanie zaujímavejších efektov.

Pripojte LED diódy a Arduino, ako je to znázornené nižšie. Červený vodič nie je v skutočnosti nevyhnutný, ale pretože je vždy dobré mať v napájacom paneli obsiahnuté obe napájacie lišty, nastavenie má zmysel.

Teraz poďme opraviť program, ktorý nám umožní skontrolovať, či je náš hardvér správne nakonfigurovaný alebo nie.

Vždy sa odporúča programovať a spúšťať malé kúsky programov postupne, aby sa skontrolovalo, či sú príslušné hardvérové ​​káble zapojené správne alebo nie.

To pomáha rýchlo vyriešiť možné chyby.

Nasledujúci príklad kódu poskytuje LED 2 až 5 špecifický vzor tým, že ich cyklicky otáča jedna za druhou.

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

Ako ste si mohli všimnúť, na kóde nie je nič zlé, až na to, že vyzerá dlho a preto je náchylný na chyby.

Samozrejme existujú lepšie spôsoby, ako vyššie uvedený kód napísať, odhalí to nasledujúca časť.

2.9 Predstavujeme polia

Polia môžu byť skupinou premenných, ktoré je možné indexovať indexovými číslami. Nasledujúci príklad nám pomôže lepšie ho pochopiť.

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

Dobre, teraz si prejdime každú časť a pochopme, ako vlastne fungujú.

const int k_numLEDs = 4

Vyššie uvedený kód definuje, koľko maximálnych prvkov máme v poli mať. Tento kód nám v nasledujúcich častiach pomáha zabezpečiť, aby bolo všetko napísané v poli a po ukončení poľa nič.

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

V tomto ďalšom riadku sme nastavili štruktúru poľa. Čísla v zátvorke označujú počet prvkov v poli. Skutočné množstvo sa síce dalo napísať, ale zápis ako konštanty funguje lepšie. Hodnoty možno bežne vidieť v zátvorke čiarkami a označiť ich v poli.

Ak nájdete pole indexované číslom 0, znamená to úplne prvý prvok v poli, ako je uvedené v znakoch code: k_LEDPins is k_LEDPins[0].

Podobne bude posledný prvok zobrazený ako k_LEDPins[3], pretože počet od 0 do 3 je 4.

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

Vyššie uvedený kód ukazuje použitie slučky na postupovanie cez jednotlivé prvky poľa a na ich nastavenie ako VÝSTUPOV. Na dosiahnutie každého z prvkov v poli implementujeme hranaté zátvorky spolu s indexom.

ak sa pýtate, či je možné použiť pin # 2 na pin # 5 bez polí, odpoveď je áno, je to možné. Ale v tomto príklade sa to nerobí, pretože sme to neurobili týmto spôsobom. V nasledujúcich častiach môžete vylúčiť pole, ak vybrané výstupné piny nie sú v rade.

Ďalej sa pozrime, čo urobí ďalší blok kódu:

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

Tu kód postupuje cez každú z LED a postupne ich zapína s medzerou alebo oneskorením 100 milisekúnd.

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

Použitie vyššie uvedeného kódu ukazuje, ako je aplikácia pre slučku by sa mohli použiť na pohyb slučkou aj v opačnom poradí.

Začína sa od k_numLEDs - 1, pretože polia sú indexované nula. Nezačíname od k_LEDPins[4] pretože by to malo za následok prekročenie cieľa poľa.

Kód používa> = 0 na kontrolu, aby prvý prvok v indexe 0 nezmeškal alebo neignoroval.

Kapitola 3

Čo je vstup

Takže sme sa naučili, ako ovládať veci pomocou Arduina. V tejto kapitole budeme diskutovať o tom, ako snímať skutočný svet prepojením vstupov z externých parametrov.

3.1 Používanie tlačidiel

Všetci vieme, čo je to tlačidlo a ako funguje. Je to druh spínača alebo tlačidla, ktoré na chvíľu spojí signál z jedného stupňa obvodu do druhého, keď je v depresívnom stave, a pri uvoľnení signál preruší.

3.1.1 Jedno tlačidlo a LED

Arduino spojíme tlačidlom s Arduinom podľa vyššie uvedených detailov a naučíme sa základné fungovanie a implementáciu nastavenia.

Označené tlačidlo, ktoré sa tiež nazýva tlačidlo mikrospínača, má celkom 4 piny (2 páry na každej strane). Po zatlačení sú každý pár kolíkov spojené vnútorne a umožňujú spojenie alebo vedenie cez ne.

V tomto príklade používame iba jeden pár týchto pinov alebo kontaktov, druhý pár je irelevantný, a preto je ignorovaný.

Pokračujme v aplikácii nasledujúceho kódu a vyskúšajte, či funguje!

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

Nájdete tu niekoľko vecí, ktoré vyzerajú nezvyčajne. Poďme na to prísť múdro.

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

Prvá vec, ktorú urobíme, je oprava buttonPin ako VSTUP. No, to je celkom základné, viem.

Ďalej priraďujeme VYSOKÁ do VSTUP špendlík. Ste zvedaví, ako je možné, že na vstup môžete niečo napísať? Iste, môže to byť zaujímavé.

Priradenie HIGH k vstupu Arduino v skutočnosti prepína interný pull-up odpor 20 kOhm na ON (LOW na tomto kolíku ho prepína do polohy OFF).

Ďalšou otázkou, ktorú môžete položiť, je rozťahovací rezistor. Venoval som sa komplexnému príspevku o pull-up rezistoroch, ktorý máte naučiť sa to tu .

Dobre, pokračujeme, teraz sa pozrime na kód hlavnej slučky:

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

Keď stlačíte tlačidlo, káblový kolík sa pripojí k zemi, čo spôsobí a NÍZKY k tomu špendlíku. A zatiaľ čo v nestlačenom stave je držaný rovnaký pin VYSOKÁ alebo + 5 V cez 20K interný pull-up rezistor.

Tu chceme, aby Arduino po stlačení tlačidla (LOW) rozsvietilo LED, preto pre každú reakciu NÍZKEHO z tlačidla, kým je stlačené, napíšeme HIGH pre výstup.

3.1.2 Dve tlačidlá a LED

Možno by vás zaujímalo, že vyššie uvedená akcia sa dala urobiť aj bez Arduina. Rozumiem, toto je však strmý kameň, ktorý sa má naučiť, ako je možné použiť tlačidlo s Ardunom.

Do tohto bodu sme študovali písanie kódov buď pre zapnutie (HIGH) alebo vypnutie (LOW) LED.

Teraz sa pozrime, ako by bolo možné ovládať jas LED pomocou Arduina.

Môže sa to robiť dvoma spôsobmi:

1. Obmedzením množstva prúdu na LED
2. Používaním PWM alebo modulácia šírky impulzu, pri ktorej sa napájanie LED veľmi rýchlo zapína / vypína požadovanou rýchlosťou, čím sa vytvára priemerné osvetlenie, ktorého intenzita by závisela od PWM.

Na doske Arduino je podpora PWM k dispozícii na kolíkoch označených vlnovkou (~), čo sú kolíky 3, 4,5,9,10 a 11) pri 500 Hz (500-krát za sekundu). Užívateľ je schopný poskytnúť ľubovoľnú hodnotu medzi 0 a 255, kde 0 znamená, že nie je HIGH alebo nie + 5V, a 255 hovorí Arduinu, aby dostal HIGH alebo + 5V po celú dobu. Pre spustenie týchto príkazov budete musieť získať prístup k analogWrite () s požadovanou hodnotou.

Môžete predpokladať, že PWM je x / 255, kde x je požadovaná hodnota, ktorú chcete poslať prostredníctvom analogWrite().

Nastavte Arduino a ďalšie parametre, ako je uvedené vyššie.

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

Možno tu nájdete 3 riadky, ktoré potrebujú vysvetlenie.

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

Riadok: ledBrightness = constrain(ledBrightness, 0, 255) ilustruje jedinečnú funkciu vo vnútri Arduina známu ako constrain ().

Táto interná funkcia obsahuje nasledujúci kód:

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

Všetky kódy prediskutované pred týmto začali neplatný , čo znamenalo nevrátiť nič (neplatné). Zatiaľ čo vyššie uvedený kód začína na int , čo znamená, že vráti celé číslo. Viac si povieme v ďalších častiach, momentálne si len zapamätajte, že celé číslo nemá zlomkové časti.

Správne, to znamená, že kód: ledBrightness = constrain(ledBrightness, 0, 255) priradí ledBrightness to be within the range of 0 and 255.

Nasledujúci riadok používa analogWrite prikáže Arduinu, aby na vybraný pin aplikovalo PWM s požadovanou hodnotou.

Nasledujúci riadok vytvára oneskorenie 20 milisekúnd, aby sa zaistilo, že neupravíme zjedenie rýchlejšie ako 50 Hz alebo 50-krát za sekundu. Je to preto, že ľudia môžu byť oveľa pomalší ako Arduino. Ak teda oneskorenie nie je urobené, program by nás mohol presvedčiť, že stlačením prvého tlačidla LED zhasla a stlačením druhého tlačidla ju zapla (vyskúšajte sami).

3.2 Potenciometre

Poďme ďalej a naučme sa, ako používať potenciometre s Arduinom.

Ak chcete vedieť, ako funguje potenciometer alebo hrniec, prečítajte si toto článok .

Pripojte zobrazené parametre k vášmu Arduinu, ako je uvedené vyššie.

Hrniec bude mať 3 terminály. Stredný terminasl sa spojí s ANALOG IN 0 na Arduine. Ďalšie dve vonkajšie svorky môžu byť pripojené k napájacej lište +5 V a 0V.

Poďme programovať a skontrolovať výsledky:

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

Nájdete niekoľko vecí, ktoré môžu vyzerať úplne novo a nie sú zahrnuté v žiadnom z našich predchádzajúcich kódov.

1. Konštanta kPinPot je priradený ako A0, kde A je skratka na opis jedného z analógových pinov. A0 sa však tiež vzťahuje na pin # 14, A1 na pin # 15 atď. A tieto vám umožňujú použiť ako digitálne vstupy / výstupy v prípade, že vám v experimente dôjdu piny. Pamätajte však, že nemôžete použiť digitálne kolíky ako analógové kolíky.
2. Riadok: ledBrightness = map(sensorValue, 0, 1023, 0, 255) predstavuje novú vnútornú funkciu v Arduine známu ako mapa (). Táto funkcia prekalibruje z daného rozsahu na iný, nazývaný ako mapa (hodnota, fromLow, fromHigh, toLow, toHigh). Toto môže byť rozhodujúce, pretože analogueRead vydáva hodnotu v rozsahu 0-1023, ale analogWrite je schopný prijať hodnotu od 0-255.

Možno si myslíte, že keďže je možné ovládať jas LED pomocou meniaceho sa odporu, jednoducho by stačil hrniec na účel, prečo je použitie Arduina. Opäť je to len základ, ktorý ukazuje, ako je možné konfigurovať banku s Arduinom.

Žiadne problémy, teraz urobíme niečo, čo sa bez Arduina nezaobíde.

V tomto experimente uvidíme, ako by sa dal použiť meniaci sa odpor hrnca na riadenie rýchlosti alebo rýchlosti blikania LED.

Tu 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 Vyvarovanie sa oneskoreniu ()

Vyššie uvedený kód vyzerá dobre, ale LED dióda nedokáže skontrolovať hodnotu potu, kým neprejde každým úplným cyklom. Pri dlhších oneskoreniach sa tento proces predlžuje a používateľ musí čakať, kým uvidí odozvu banku, kým ju pohybuje. Tomuto oneskoreniu sa dá vyhnúť pomocou inteligentného programovania, takže umožňuje používateľovi skontrolovať hodnotu bez minimálnych oneskorení. Tu je kód.

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

V čom je teda rozdiel vo vyššie uvedenom kóde? Rozdiel predstavuje nasledujúci riadok.

long lastTime = 0

Až do tejto časti sme diskutovali o premennej int. Môže však existovať mnoho ďalších typov premenných, ku ktorým máte prístup. Zoznam si môžete prečítať nižšie:

V súčasnosti môže byť iba zásadné vedieť, že na ukladanie relatívne veľkého množstva súborov do formátu int premennú, môžete použiť výraz dlho alebo a dlhá int.

Tu môžete vidieť ďalšiu zaujímavú funkciu s názvom millis ().

Toto vytvára časové rozpätie v milisekundách, ktoré Arduino od začiatku pracovalo (toto sa každých 50 dní nastaví na 0). Tu sa vráti dlho, pretože keby sa vrátil int , počítanie za dlhé obdobia nemusí byť možné. Mohli by ste presne odpovedať, ako dlho? Odpoveď je 32,767 sekundy.

Preto namiesto použitia delay () skontrolujeme millis () a hneď ako uplynie konkrétny počet milisekúnd, zmeníme LED. Čas, ktorý sme naposledy zmenili, si preto uložíme naposledy premenná, takže nám umožňuje kedykoľvek to skontrolovať znova.

3,3 RGB LED

Doteraz sme hrali s jednofarebnou LED. Aj keď farbu LED je možné zmeniť výmenou LED za inú farbu, ale čo tak použiť RGB LED na zmenu farieb LED bez výmeny LED?

RGB LED je v podstate LED, ktorá má zabudovanú červenú, zelenú a modrú LED a je zlúčená do jednej LED. Má jedno spoločné vedenie, ktoré vedie k zemi alebo napájacej lište 0V, zatiaľ čo ďalšie 3 vedenia sú napájané diverzifikovanými pozitívnymi signálmi PWM na implementáciu zamýšľaného miešanie farieb .

Môžete zapojiť zariadenie podľa obrázka nižšie:

Môže to vyzerať trochu zložito, ale v skutočnosti je to replika nášho predchádzajúceho návrhu ovládania LED pomocou PWM.

Tu je kód cvičného programu:

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 nahraní tohto kódu stačí zistiť, ako úpravy hrnca vytvárajú zaujímavý svetelný efekt na RGB, čo môže byť skutočná zábava.

Zistíte, že keď sú všetky 3 hrnce posunuté o maximálnu pozíciu, namiesto bielej farby uvidíte červenú. Je to preto, že červená farba je najvýraznejšia z 3 farieb, a preto v tejto situácii dominuje. S touto funkciou však môžete experimentovať mapa () , pred vykonaním na červenú časť LED, aby sa vytvorilo rozumnejšie vyváženie.

Zvuk s Arduino

V tejto časti sa dozvieme, ako pridať základný zvuk a hudbu do nastavenia Arduina.

Uvidíme, ako prepnúť signál na pripojený reproduktor s požadovanou frekvenciou.

Presnejšie, vyskúšame strednú notu A, čo je frekvencia 440 Hz.

Aby sme to dosiahli, jednoducho zahráme strednú notu A a optimalizujeme signál sínusovej vlny s obdĺžnikovou vlnou.

Vypočítame tiež čas, po ktorý môže reproduktor zostať ZAPNUTÝ, a to žalovaním vzorca:

timeDelay = 1 sekunda / 2 x toneFrequency.

timeDelay = 1 sekunda / 2 x 440

timeDelay = 1136 mikrosekúnd

4.1 Pripojme dosku Arduino

4.2 Pridanie jednoduchej poznámky

O funkcii sme už hovorili oneskorenie () kde je jednotka v milisekundách (sekunda / 1000), nájdete tu však ešte ďalšiu funkciu delayMicroseconds() kde je jednotka v mikrosekundách, (milisekundy / 1 000).

Pre súčasné nastavenie naprogramujeme kód na prepínanie + 5 V ZAPNUTÉ / VYPNUTÉ na zvolenom kolíku prepojenom s reproduktorom rýchlosťou 440 impulzov za sekundu.

Pripomeňme, že v poslednej diskusii sme určili hodnotu 1136 mikrosekúnd pre zamýšľanú zvukovú poznámku.

Takže toto je program, ktorý vám umožní počuť zvukovú notu 440 Hz, akonáhle naprogramujete arduino s pripojeným reproduktorom.

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

Pomocou vyššie uvedenej aplikácie je možné vytvoriť zvukovú poznámku, čo tiež znamená, že môžeme vytvoriť hudbu podľa vlastného výberu.

Z kódu chápeme, že Arduino obsahuje niekoľko integrovaných funkcií, ktoré navyše prispievajú k tvorbe hudby.

Prvý z nich je tón () ktorý pracuje s 2 prvkami spolu s 3. voliteľným prvkom označeným ako tón (pin, frekvencia, trvanie). alebo tón (pin, frekvencia)

Oba sú určené na vykonanie príslušného časového obdobia, ktoré ste určili.

Ak nebude časový úsek k dispozícii, bude hudba pokračovať v prehrávaní až do hovoru tón () sa vykoná znova, alebo kým ho nespustíte nie jeden ().

To bude potrebné urobiť pomocou funkcie oneskorenia v prípade, že hranie hudby je jedinou zásadnou vecou, ​​ktorú implementujete.

Časové trvanie môže byť rozhodujúce, pretože umožňuje určiť čas, dokedy sa hudba prehráva, takže môžete robiť iné veci. Hneď ako uplynie doba, hudba sa zastaví.

Ďalšia funkcia nie jeden () narába s jedným parametrom a zastaví zvolený tón na konkrétnom pridelenom kolíku.

Zvláštne varovanie: Kedykoľvek, keď tón () je implementovaná funkcia PWM na pinoch 3 a 11 prestane pracovať.

Preto vždy, keď sa v programe používa pripevnenie reproduktorov, nepoužívajte uvedený pin pre reproduktory, namiesto toho vyskúšajte niektoré ďalšie kolíky na pripevnenie reproduktorov.

Dobre, takže tu je program na implementáciu hudby do reproduktora, hoci nejde o skutočnú hudbu, ale skôr o stupnicu 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)
}

Vo vyššie uvedenom kóde ste si mohli všimnúť niečo nové a to je všetko # definovať .

Tento výraz funguje ako príkaz na hľadanie a nahradenie v počítači, keď sa vykonáva kompilácia.

Kedykoľvek nájde prvú vec pred medzerou, nahradí ju zvyšnou časťou riadku (nazývanou makrá).

Takže v tomto príklade, keď počítač vidí POZNÁMKA_E4 rýchlo ho nahradí množstvom 330.

Ďalšie poznámky a prispôsobenie môžete nájsť v súbore na USB kľúči s názvom ihriská.h , kde je možné nájsť väčšinu frekvencií podľa vašich preferencií.

4.4 Hudba s funkciami

Vyššie uvedený kód vyzerá dobre, ale zdá sa, že má veľa opakovaní, mala by existovať nejaká metóda na ich skrátenie, však?

Doteraz sme pracovali s dvoma základnými funkciami, ktoré sú súčasťou Arduina. Teraz môže byť čas, aby sme si vytvorili vlastné funkcie.

Každá funkcia musí začínať typom premennej, s ktorou môže byť spojená. Napríklad funkcia neplatný odkazuje na typ, ktorý nevracia nič, a preto je názov neplatný. Upozorňujeme, že o zozname premenných sme sa už zmienili v našich predchádzajúcich častiach, mali by ste ich odkázať.

V dôsledku toho dostane názov konkrétnej funkcie otvorenú zátvorku „(„ nasledovaný zoznamom parametrov oddelených čiarkou.

Každý z parametrov získa svoj typ spolu s názvom a nakoniec zánikom „)“ zátvorky.

Tieto parametre je možné v rámci funkcie aplikovať vo forme premenných.

Pozrime sa na príklad nižšie, kde vyvíjame funkciu s názvom ourTone () určené na zlúčenie tón () s oneskorenie () riadkov tak, že sa funkcia prestane vracať, kým nota nedokončí tón.

Tieto funkcie implementujeme do nášho predchádzajúceho kódu a získame program uvedený nižšie, pozri posledné riadky:

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

Funkcie môžu byť mimoriadne užitočné, aby bol program ľahšie pochopiteľný.

Nasleduje príklad, kde môžeme pomocou dvoch polí špecifikovať výber tónu, ktorý chceme hrať. Jedno pole na uchovanie nôt, druhé na uchovanie rytmov.

#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 riadku jasne vidíte úvod do #include vyhlásenie. Úlohou tohto vyhlásenia je vyzdvihnúť celý súbor medzi úvodzovkami a umiestniť ho do polohy #include vyhlásenie. Podľa štandardných pravidiel sú tieto pravidlá striktne umiestnené na začiatku programu.

Kapitola 5

Meranie teploty

Len na pripomenutie, namiesto toho, aby ste písali veľké programy úplne, je vždy rozumné písať a analyzovať malé časti kódov, čo pomáha pri rýchlom vyhľadávaní chýb.

5.1 Sériový monitor

Doteraz sa kódy, o ktorých sme diskutovali, nezdajú tak ľahké, aby umožnili rýchle riešenie problémov. Tu sa pokúsime uľahčiť monitorovanie a ľahšie riešenie možného problému.

Arduino má funkciu, ktorá mu umožňuje „rozprávať sa“ s počítačom. Možno si všimnete, že pin0 a pin1 sú označené ako RX a TX vedľa seba. Tieto piny v skutočnosti sleduje samostatný integrovaný obvod v Arduine, ktorý ich upgraduje na čítanie cez kábel USB, keď je pripojený k počítaču.

Nasledujúca časť zobrazuje plnohodnotný program, prosím, choďte na to, o nových položkách v kóde sa dozvieme neskôr. Tento kód je rovnaký ako v časti 2.2, s výnimkou skutočnosti, že obsahuje niektoré dodatočné údaje, ktoré nám umožňujú identifikovať, na čo je kódovaný.

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 môžete identifikovať dve nové veci, nový riadok v nastaviť() funkcie.

Serial.begin(9600)

Tento riadok jednoducho vyjadruje nevyhnutnosť použitia Sériové číslo 1 kód na jeho vynútenie s 9600 baudmi. (tu seriál odkazuje na bity jeden po druhom a baud znamená rýchlosť, akou sa odosiela). Táto prenosová hodnota a hodnota vo vnútri sériového monitora (o tom sa dozvieme neskôr) sa musia rovnať, inak budú údaje v sériovom monitore obsahovať smeti. Štandard 9600 sa stáva pohodlnejším na používanie.

Druhý nový záznam je nasledovný

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

Tu druhý riadok naznačuje, že následná vec vychádzajúca zo sériového portu sa začne na ďalšom riadku. Tým sa líši druhá línia od prvej línie.

Ešte jedna vec, ktorú môžete vidieť, sú úvodzovky ('). Toto sa označuje ako reťazec, ktorý sa tu bude používať iba ako konštanty, pretože ďalšia diskusia na túto tému môže byť príliš zložitá a presahujúca rámec.

Dobre, teraz môžeme nahrať vyššie uvedený kód do Arduina a zistiť, čo sa stane.

Zdá sa, že sa nič nestalo, kontrolka LED č. 13 Arduino blikla a zastavila sa, zatiaľ čo kontrolka Tx LED stále blikala.

Je to tak preto, lebo okno Serial Monitor ešte nie je opravené.

Musíte kliknúť na políčko Serial Monitor vo vašom IDE, ako je uvedené vyššie. Nezabudnite skontrolovať prenosovú rýchlosť umiestnenú vpravo dole, štandardne by mala byť 9600 a bude zodpovedať kódu. Ak nie je isté, vyberte možnosť 9600.

Nasledujúci videoklip vysvetľuje, ako sa to deje.

Poďme teraz ďalej a naučme sa, ako môže vyššie uvedená funkcia sériového monitora pomôcť pri spracovaní meranie teploty pomocou Arduina

Ako teplotný snímač použijeme IC TMP36 s rozsahom -40 až 150 stupňov Celzia.

Inštaláciu je možné vidieť nižšie:

Nasledujúci kód zaháji meranie teploty načítaním výstupu zo snímača TMP36 a ich odoslaním na sériový monitor ID.

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
}

Poďme pochopiť kód zhora.

float temperatureC = getTemperatureC()

Tu vidíte, že sme zahrnuli typ premennej plavák.

Toto je jediný typ premennej, ktorá obsahuje ukladanie všetkého okrem celočíselných čísel (čísel bez desatinných alebo zlomkových častí).

Presnosť pohyblivej premennej môže byť až 6 až 7 číslic.

Susedný kód getTemperatureC() je naša vlastná funkcia, ktorá matematicky počíta a prevádza rozdiel snímaného napätia zo snímača TMP36 na stupne Celzia.

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 ďalšej časti kódov sa od výrazu analogIn() je priradené na vrátenie čísla medzi 1 až 1023, je možné posúdiť napätie zo snímača vynásobením nášho odpočtu číslom 5 a následným vydelením číslom 1024.

Je špecifikované, že snímač TMP36 generuje 0,5 V pri 0 stupňoch Celzia a následne generuje 10 mV pri každom jednom zvýšení stupňa Celzia.

Tu je aproximácia, ktorú sme schopní vygenerovať pomocou výpočtov:

Môžete považovať za svoju prvú funkciu, ktorá vracia určitú hodnotu (všimnite si, že všetky zostávajúce funkcie doteraz nevrátili žiadnu hodnotu, pretože boli typu neplatný ).

Môžete pochopiť, že ak chcete získať hodnotu z funkcie, musíte jednoducho pridať návrat nasledované požadovaným číslom, ktoré chcete vrátiť.

Keď hovoríme návrat znamená to, že funkcia vráti odpoveď alebo odpoveď, kedykoľvek je vyvolaná, čo je možné použiť na premennú.

Keď sa to odošle na sériový monitor, čítanie sa prevedie na Fahrenheita cez convertToF ().

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

Táto funkcia sníma rozsah Celzia a prevádza ho na Fahrenheita.

Na prevod Fahrenheita na Celzia implementujeme vzorec Fahrenheit = 9 / 5 (Celzia) + 32.

5.3 Prepojenie LCD

Poďme si teraz naštudovať, ako prepojiť alebo pripojiť displej LCD s Arduino na získanie vizuálneho zobrazenia požadovaných výstupov.

V našej aplikácii použijeme grafický LCD displej s rozmermi 84 x 48 pixelov, ktorý má vodorovne 84 pixelov alebo bodov a vertikálne rozlíšenie 48 pixelov. Pretože vyhradený radič sa stáva nevyhnutným pre všetky LCD displeje, obsahuje toto zariadenie aj jeden v podobe radiča PCD8544.

V tomto výučbe spojíme vyššie uvedený LCD modul s Arduinom a pomocou určitých postupov vytvoríme textové správy na displeji.

Na nasledujúcom obrázku nájdete podrobnosti týkajúce sa prepojenia LCD displeja s malými Regulátor napätia 3,3 V . Tento regulátor je nevyhnutný, pretože displej LCD je určený na prácu s napájaním 3,3 V.

Môžete tiež vidieť 8 pinov z LCD modulu, špecifikácie pinov si môžete preštudovať z nasledujúcej tabuľky:

Teraz sa pozrime, ako môžeme prepojiť LCD a príslušné parametre s našim Arduinom. Podrobnosti je možné zobraziť na nasledujúcom obrázku:

5.4 Komunikácia s LCD

Aj keď je možné z Arduina napísať prepracované coedy pre interakciu s LCD, skôr sa naučíme, ako to urobiť pomocou knižníc.

Knižnice obsahujú sortiment kódov, ktoré je možné rýchlo použiť pre vybraný program Arduino.

To umožňuje používateľovi bez námahy volať funkciu bez toho, aby musel prechádzať zložitou prácou kódovania.

5.4.1 Ako nainštalovať knižnicu

Za týmto účelom budete musieť vo svojom počítači vytvoriť adresár s názvom knižnice Arduino IDE, ako je vysvetlené tu

5.4.2 Implementácia operácií LCD

Rovnako ako náš predchádzajúci prístup, najskôr skontrolujeme celý kód a potom sa pokúsime porozumieť podrobnostiam jednotlivých riadkov.

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

Riadok obsahuje kód #include

Kód #include dáva počítaču pokyn, aby počas kompilácie programu vyzdvihol spomínaný súbor a nahradil prvok #include obsahom súboru.

Element #include môže mať lomené zátvorky, ktoré označujú hľadanie v adresári knižnice, alternatívne môže obsahovať aj úvodzovky, ktoré označujú hľadanie v rovnakom adresári, v ktorom je program umiestnený.

Nasledujúce riadky kódu vyjadrujú pinouty LCD a potom napíšeme novú formu premennej:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Tu vyjadrujeme premennú s názvom lcd typu PCD8544 a poučujeme PC, aby prehodnotil svoje pinouty spojené s Arduinom.

V tomto procese popíšeme premennú v počítači podľa pokynov, ako sú pin clk, din, dc a reset prepojené s Arduino.

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

Riadok lcd.init() inicializuje činnosť LCD. Po vykonaní tohto kroku bude nasledujúci riadok vynucovať pohyb kurzora v ľavom hornom rohu obrazovky. A nasledujúci nasledujúci riadok sa snaží vytlačiť správu „Hello, World“.

Vyzerá to celkom identicky s technikou, ktorou sme odosielali správy cez sériový monitor. Jediným rozdielom je použitie kódu lcd.print namiesto serial.print.

Ďalší blok kódu sa v skutočnosti volá opakovane.

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

Pomocou tohto riadku lcd.setCursor(0,1) kurzor zafixujeme na 0. stĺpec úplne vľavo od 1. riadku nad LCD displejom.

V ďalšom riadku je použitá skratka: lcd.print(millis())

Ak si spomínate, spolupracovali sme s millis() v našich starších kódoch sme mohli použiť to isté aj tu prostredníctvom kódov:

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

Pretože tu však nejde o časové obdobia v milisekundách, dosiahneme to jednoduchým odoslaním millis() funkcia priamo do lcd.print() .

5.5 Kombinácia celej veci

Dobre, poďme skombinovať všetky kódy, ktoré sme sa naučili vyššie, aby sme vytvorili teplotný okruh LCD, a pozrime sa, ako to vyzerá:

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

Vo vyššie uvedenom programe vyzerá všetko štandardne, s výnimkou použitia funkcie setCursor () . Používa sa na zarovnanie textu čo najviac okolo stredu displeja.

Skvelé! A gratulujeme, práve ste si pomocou Arduina naprogramovali svoj malý LCD indikátor teploty.

Praktické aplikácie Arduino

Pretože v tomto okamihu sme podrobne prebrali rôzne techniky programovania, je na čase ich podrobiť etablovaniu pomocou niekoľkých užitočných praktických implementácií.

Začneme senzormi a po vykonaní niekoľkých vzorových kódov uvidíme, ako by sa dali senzorové zariadenia používať s Arduinom.

7.1 Úvod do senzorov

V tomto výučbe sa dozvieme o širokej škále senzorov, ktoré je možné použiť s Arduino. Môžu to byť napríklad zariadenia ako svetelný senzor LDR, magnetický Hallov efekt, snímače náklonu, vibrácie, tlaku, atď.

Začneme prepojením svetelný senzor LDR s Arduino, ako je znázornené na nasledujúcom diagrame:

Ako všetci vieme, LDR je svetloodporové rezistorové zariadenie, ktorého odpor závisí od intenzity okolitého prostredia dopadajúceho na jeho povrch.

Intenzita svetla je nepriamo úmerná hodnotám odporu LDR.

Tu sa dozvieme, ako možno túto vlastnosť integrovať do Arduina na vykonávanie užitočnej aplikácie:

Celý programový kód je možné vizualizovať, ako je uvedené nižšie:

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

Všetky parametre použité v kóde boli už prediskutované v našom kurze, ktorý sme sa doteraz naučili. Riadky môžete skontrolovať podľa príslušných častí.

Hodnoty boli vybrané náhodne, môžete ich ľahko zmeniť podľa svojich vlastných preferencií.

Senzor náklonu

Senzor náklonu je jednoduché zariadenie, pomocou ktorého je možné zistiť akciu náklonu na ľubovoľnom objekte, kde je nainštalovaný. Zariadenie má v podstate kovovú guľu vo vnútri, ktorá sa pri nakláňaní valí cez dvojicu kontaktov a spôsobuje vedenie cez tieto kontakty. Tieto kontakty ukončené ako vodiče sklopného spínača sa používajú s externým obvodom na detekciu vedenia v dôsledku nakláňania a aktiváciu požadovanej výstupnej aplikácie.

Teraz sa pozrime, ako a snímač náklonu zariadenie môže byť pripojené. Obrázok nižšie nám poskytuje predstavu o kompletnej konfigurácii:

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 tomto príklade sa ako indikátor náklonu použije predvolená LED č. 13.

Tu môžete jasne vidieť začlenenie pull-up rezistora, celkom podobného tomu, čo sme urobili v časti 3.1. Preto výraz LOW naznačuje, že funkcia naklonenia sa nespustí.

7.4 Relé s jazýčkovým spínačom (relé s aktivovaným miniatúrnym magnetom)

Teraz sa pozrime, ako zapojiť reléový spínač alebo snímač magnetického poľa pomocou Arduina. Jazýčkové relé je druh spínača, ktorý sa aktivuje alebo vedie, keď sa do jeho blízkosti dostane magnetické pole alebo magnet. V zásade má pár feromagnetických kontaktov vo vnútri miniatúrneho skleneného krytu, ktoré sa spájajú alebo nadväzujú kontaktom vďaka magnetickému ťahu, kedykoľvek je magnet v jeho tesnej blízkosti. Keď sa to stane, svorky kontaktov vykazujú vedenie v dôsledku zopnutia kontaktov.

Aj tu používame na indikáciu odozvy LED pin # 13. K tomuto kolíku môžete pripojiť externú LED, ak je to potrebné, podľa našich predchádzajúcich vysvetlení.

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

Podmienky kódu by mali byť známe a samozrejmé.

7.5 Senzor vibrácií pomocou piezoelektrického meniča

V nasledujúcom ukážkovom programe uvidíme, ako a piezoelektrický menič sa môže použiť ako snímač vibrácií na osvetlenie LED cez Arduino.

Piezoelektrický prvok je vlastne zariadenie, ktoré generuje vibrácie alebo oscilácie, keď sa na jeho svorky aplikuje frekvencia. To isté piezo sa však mohlo použiť v opačnom procese pre generovanie elektrických impulzov v reakcii na vibrácie pôsobiace na jeho telo. Táto vibrácia môže byť vo forme klepania alebo nárazu na povrch piezo.

Nastavte Arduino a piezoelektrický prvok, ako je uvedené na nasledujúcom obrázku

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

Prahová hodnota 100 je zavedená len preto, aby sa zabezpečilo, že Arduino reaguje iba na skutočné vibrácie klepaním, a nie na ďalšie menšie vibrácie, napríklad z hlasných zvukov alebo klaksónov.

Výber kolíka A5 nie je povinný, môžete si zvoliť akékoľvek iné analógové vstupy podľa vašich preferencií a zodpovedaním ich v programovom kóde.

Používanie servomotora s Arduino

Servomotor je typ jednosmerného motora, ktorý je možné otáčať do presných uhlov podľa požiadavky konkrétnej aplikácie. Môže sa to vykonať uplatnením vypočítaného príkazu na príslušné vstupy motora, čím sa na motore vytvorí presný uhol natočenia alebo natočenia v rozmedzí 180 stupňov.

Servomotor má zvyčajne 3 vodiče alebo vstupy. Kladné vodiče majú zvyčajne červenú farbu, záporný alebo uzemňovací vodič sú čierne a ich príkazový alebo signalizačný vodič má zvyčajne bielu alebo žltú farbu.

Arduino uľahčuje ovládanie servomotorov prostredníctvom zabudovaného podporného jazyka, vďaka čomu je ovládanie veľmi pohodlné a ideálne pre servomotory.

Nasledujúci príklad nám ukáže základný nastavovací program pre implementáciu riadenia servomotorov cez Arduino:

Kód je uvedený nižšie:

#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 môžeme vidieť niekoľko nových záznamov. Jeden, ktorý povie pripojenému vodiču serva, k akému kolíku je priradený. Druhým je kód, ktorý poskytuje kolíku hodnotu medzi 0 a 180 na určenie uhla otáčania serva.

Záver

Subjekt Arduino môže byť nekonečne dlhý, a teda nad rámec tohto článku. Dúfam však, že vyššie uvedený tutoriál vám mal určite pomôcť naučiť sa úplne základné základy Arduina a pochopiť dôležité parametre prostredníctvom rôznych príkladov aplikačných kódov.

Dúfajme, že tu môžu byť z času na čas aktualizované ďalšie informácie, kedykoľvek budú k dispozícii.

Zatiaľ si užívajte svoj programovací kurz, Happy Arduinoing vám !!