Naučit se základní programování Arduina - výukový program pro nováčky

Naučit se základní programování Arduina - výukový program pro nováčky

V tomto tutoriálu se naučíme základní programování Arduina pomocí ukázkových kódů a ukázkových programů. Tento tutoriál může být nesmírně cenným kurzem pro všechny nováčky, kteří chtějí pochopit základy jednoduchým a srozumitelným jazykem.



Úvod

Podle wikipedia mikrokontrolér je ekvivalentní minipočítači zabudovanému do jediného IC čipu, který má vlastní základní procesor, programovatelné vstupy, paměť a výstupní periferie.

Mikrokontrolér se stává pro uživatele tak užitečným, protože nabízí vestavěný procesor, paměť a vstupní / výstupní porty (nazývané také GPIO nebo univerzální vstupní / výstupní piny), které můžeme ovládat uživatelem podle libovolných požadovaných specifikací.





V tomto tutoriálu budeme pracovat s deskou Arduino Uno pro učení a testování programů. Pro testování a integraci hardwarové montáže použijeme prkénko.

Nyní pojďme rychle a naučíme se, jak začít s programováním Arduina.



1.2 Instalace softwaru (Windows)

K tomu budete potřebovat přístup k internetu, který byste samozřejmě měli ve svém počítači. Přejděte na následující odkaz a stáhněte si software IDE:

Soubor Windows Windows pro instalaci bez oprávnění správce

Po stažení najdete ve složce pro stahování ikonu nastavení Arduina, která by vypadala takto:

ikona stahování Arduino

Jakmile to získáte, můžete na něj jednoduše dvakrát kliknout a nainstalovat do svého počítače Arduino the Integrated Development Environment (IDE). Celý proces lze vizualizovat v následujícím videu:

https://youtu.be/x7AMn1paCeU

1.4 Počínaje naším prvním okruhem

Než se začneme učit skutečné programovací techniky, pro každého nováčka by bylo užitečné začít se základní komponentou, jako je LED, a pochopit, jak ji propojit s Arduinem.

Jak víme, LED je světelná dioda, která má polaritu a nebude svítit, pokud není připojena ke správným napájecím pólům.

Dalším aspektem LED je, že tato zařízení pracují s nízkým proudem a mohou se okamžitě poškodit, pokud není v sérii s jedním z jeho kolíků zahrnut správně vypočítaný odpor.

Pravidlem je, že 330 ohmový 1/4 watt je ideální pro každé zvýšení napájecího vstupu o 5 V, aby se proud omezil na požadovanou bezpečnou úroveň. Proto pro 5V to může být 330 ohmů, pro 10V to může být 680 ohmů a tak dále.

Použití prkénka pro montáž

Ujistěte se, že víte, jak používat a prkénko na prkénko před vyzkoušením tutoriálu vysvětleného v této kapitole, protože bychom pro všechny zde použité experimenty používali prkénko.

Níže je uvedeno základní nastavení připojení LED:

LED s Arduino

Nahoře můžete vidět 3 základní komponenty:

  1. 5 mm, 20 mA LED
  2. odpor 330 ohmů 1/4 wattů
  3. An Deska Arduino

Stačí sestavit systém podle schématu.

Dále připojte 5V z USB počítače do Arduina. Jakmile to uděláte, uvidíte rozsvícení LED.

Vím, že je to docela základní, ale vždy je dobré začít od nuly. Ujišťujeme vás, že s postupem vpřed začnou být věci čím dál zajímavější.

1.5 Ovládání LED pomocí Arduina

Nyní se naučíme, jak ovládat LED pomocí programu Arduino.

Abychom mohli napsat program, musíme mít v každém programu alespoň 2 funkce.

Funkci lze chápat jako řadu programovacích příkazů, kterým lze přiřadit název, jak je uvedeno níže:

  1. založit() toto je vyvoláno nebo provedeno během spuštění programu.
  2. smyčka() toto se nazývá nebo provádí opakovaně po celou dobu provozu Arduina.

Proto, i když nemusí mít žádnou praktickou funkčnost, lze technicky nejkratší legitimní program Arduino napsat jako:

Nejjednodušší program

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

Možná jste si všimli, že v mnoha programovacích jazycích systém začíná zobrazením jednoduchého tisku „Hello, World“ na displeji

Elektronickým ekvivalentem pro tuto frázi v interpretaci mikrokontroléru je blikání LED ZAPNUTO a VYPNUTO.

Toto je nejzákladnější program, který lze napsat a implementovat, aby indikoval správné fungování systému.

Pokusíme se implementovat a porozumět postupu prostřednictvím následující části 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)
}

Dobře, pojďme pochopit, co každý řádek kódu znamená a jak funguje spuštění funkce:

const int kPinLed = 13

Funguje to jako konstanta, která nám umožňuje používat ji během celého kurzu programování, aniž bychom museli používat skutečnou hodnotu, která je proti ní nastavena.

Podle standardních pravidel jsou tyto konstanty rozpoznávány počátečním písmenem k . I když to není povinné, vše bude jasnější a srozumitelnější, kdykoli budete chtít projít podrobnostmi kódu.

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

Tento kód konfiguruje konkrétní pin, ke kterému je naše LED připojena. Jinými slovy, kód říká Arduinu, aby ovládalo aspekt „psaní“ na tomto kolíku, místo aby jej „četl“.

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

Výše uvedené řádky označují skutečné spuštění aplikace. Kód začíná zapsáním a vykreslením hodnoty HIGH na příslušném připojení LED a rozsvícením LED.

Zde termín HIGH jednoduše znamená dostat + 5V na příslušný kolík Arduina. Doplňující termín LOW jednoduše označuje nulu nebo 0V na určeném kolíku.

Dále voláme delay() jehož funkcí je vytvořit zpoždění o milisekundy (1/1 000 sekundy). Protože je zadáno číslo 500, implementované zpoždění bude 1/2 sekundy.

Jakmile tato 1/2 sekunda uplynula, provede se další řádek, který vypne LED s termínem LOW na stejném pinu.

Následující řádek opět generuje zpoždění 1/2 sekundy, aby LED zůstala nesvítí po dobu 1/2 sekundy.

A proces pokračuje nekonečně prováděním řádků kódu, pokud je Arduino napájeno.

Než přejdete na další úroveň, doporučuji vám naprogramovat výše uvedený kód a zkontrolovat, zda jste schopni správně implementovat sekvenci LED ON / OF.

Jelikož je výchozí LED v Arduinu spojena s pinem # 13, měla by okamžitě reagovat na výše uvedený program a začít blikat. Pokud však zjistíte, že vaše externí LED nebliká, mohlo by dojít k chybě připojení s vaší LED, můžete zkusit obrátit polaritu vaší LED a doufejme, že také bliká.

Můžete hrát s dobou zpoždění změnou číslice „500“ na jinou hodnotu a najít LED „naslouchající“ povelům a způsobit její blikání podle zadaných hodnot zpoždění.

Nezapomeňte však, že pokud LED dioda nebliká s konstantní rychlostí 1 sekundy, bez ohledu na změnu doby zpoždění, může to znamenat, že kód kvůli nějaké chybě nefunguje. Protože ve výchozím nastavení bude Arduino naprogramováno s frekvencí blikání 1 s. Proto se tato sazba musí pro váš správný chod měnit podle vašeho kódu.

1.7 Komentáře

Řádky kódů, kterým jsme rozuměli výše, byly konkrétně napsány pro počítačový software.

Aby se však zajistilo, že uživatel bude moci odkazovat na význam řádků a porozumět jim, může být často užitečné a rozumné napsat vysvětlení vedle požadovaných řádků kódů.

Tito se nazývají komentáře které jsou psány pouze pro referenci člověka nebo uživatele a jsou kódovány, aby je počítače mohly bezpečně ignorovat.

Jazyk těchto komentářů je napsán v několika formátech:

  1. Styl bloku komentáře, přičemž popis komentáře je uzavřen pod počátečním symbolem / * a koncovým symbolem * /
  2. To nemusí omezovat v jednom řádku, spíše by mohlo být rozšířeno na další následující řádky v závislosti na délce komentáře nebo popisu, jak je znázorněno v následujícím příkladu:

/ * Toto je komentář * /

/ * Tak je to * /

/* A
* tento
* tak jako
* studna */

Pro psaní rychlého popisu jednoho řádku pro komentář postačují dva lomítka // na začátku. To řekne počítači, že tento řádek nemá nic společného se skutečným kódem a musí být ignorován. Například:

// Toto je komentář, který budou počítače ignorovat.

Zde je příklad pro referenci:

/*
* 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 Řešení problémů

Pokud zjistíte, že váš program při kompilaci vykazuje „chybu“, nebo nějaký jiný problém, následující tipy vám pravděpodobně pomohou překontrolovat kód a zbavit se překážky.

  1. Váš programový jazyk bude rozlišovat velká a malá písmena. Například výraz myVar nelze zapsat jako MyVar.
  2. Všechny druhy bílých mezer, které mohou být spuštěny při psaní na klávesnici, jsou nakonec vykresleny jako jeden prostor a jsou viditelné nebo chápané pouze vámi, počítač to nebude brát v úvahu. Jednoduše řečeno, volná místa jakéhokoli druhu nebudou mít žádný vliv na výsledky kódu.
  3. Každý blok kódu musí být uzavřen levou a pravou složenou závorkou, '{' a '}'
  4. Číslice číslic by neměly být odděleny čárkami. Například 1000 nemusí být zapsáno jako 1000.
  5. Každý řádek kódu uzavřený mezi složenými závorkami musí končit středníkem

Vytváření zajímavé LED sekvence světla pomocí Arduina

V naší předchozí kapitole jsme se naučili, jak trvale blikat LED ON / OFF s konstantní rychlostí zpoždění.

Nyní se naučíme, jak by bylo možné provést různé vzory zpoždění na stejné LED upgradováním programového kódu.

Nebudeme používat externí LED, spíše použijeme výchozí LED zabudovanou do desky Arduino na pin # 13. Tuto malou SMD LED najdete hned za USB konektorem.

2.2 Vysvětlení IF prohlášení

V této části se naučíme, jak nám řídicí struktury umožňují spouštět jednotlivé kódy a někdy dokonce opakovaně, jak je požadováno.

Prohlášení -li se stane 1. kontrolní strukturou. Následující implementace ukazuje, jak se používá:

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

Pokusíme se krok za krokem porozumět výše uvedenému kódu a zjistíme, jak to lze použít pro další podobné popravy.

Kódy mezi 1. a 7. řádkem jsou přesně podobné našemu původnímu programu.

První úprava se skutečně odehrává na 8. řádku.

int delayTime = 1000

Zjistíte, že je to podobné jako kód na 1. řádku, kromě toho, že mu chybí termín konst.

Je to jednoduše proto, že tento kód není konstanta. Místo toho je to definováno jako proměnná , která má v průběhu programování vlastnost proměnné hodnoty.

Ve výše uvedeném příkladu vidíte, že této proměnné je přiřazena hodnota 1 000. Pamatujte, že takové proměnné, které jsou uzavřeny ve složených závorkách, musí být striktně zapsány pouze do dvojic složených závorek a jsou označovány jako „místní“ proměnné.

Alternativně jsou proměnné, které mají být mimo složené závorky, jako je ta, o které nyní diskutujeme, rozpoznány jako „globální“ a lze je spustit téměř kdekoli v rámci programového kódu.

Do budoucna můžete vidět, že kódy mezi řádky 9 a 11 jsou také podobné prvnímu programu, nicméně věci začnou být zajímavé po řádku 11. Podívejme se, jak!

delayTime = delayTime - 100

V tomto kódu vidíme, že výchozí hodnota zpoždění se upravuje odečtením 100 od něj.

Význam 100 se odečte od jeho počáteční hodnoty 1000, což mu dává novou hodnotu 900.

Prostřednictvím následujícího obrázku se pokusíme porozumět několika matematickým operátorům používaným v jazyce Arduino.

Symboly operátora matematiky Arduino

Nyní pojďme posoudit kódy mezi řádky 13 a 15.

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

Hlavním cílem výše uvedeného kódu je zajistit, aby LED dioda pokračovala v blikání bez jakéhokoli přerušení.

Vzhledem k tomu, že 100 se odečítá od originálu zpoždění , brání blikání LED v dosažení nuly a umožňuje nepřetržité rozsvícení blikání.

Následující obrázek ukazuje několik operátorů porovnání, které bychom použili v našich kódech:

operátor porovnání pro arduino kódy

V našem výše uvedeném kódu jsme mohli testovat, aby byl kód if(delayTime == 0).

Protože však záporná hodnota může být stejně špatná, nešli jsme do toho a toto je doporučený postup.

Přemýšlejte, jaký by mohl být výsledek, kdybychom se pokusili odečíst 300 místo 100 od delayTime?

Možná jste si nyní uvědomili, že pokud delayTime je zapsán jako menší nebo rovný nule, pak by se doba zpoždění nastavila zpět na původní hodnotu 1000.

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

Poslední 4 řádky kódu, jak je uvedeno výše, jsou zodpovědné za trvalé rozsvícení / zhasnutí LED, zapnutí / vypnutí.

Zde si můžete jasně všimnout, že namísto použití čísla jsme použili proměnnou pro přiřazení doby zpoždění, abychom ji mohli během provozní doby kódu upravit, jak chceme. To je skvělé, že?

2.3 JINÉ výpisy

Zde se dozvíme, proč a jak -li termín může mít klauzuli jiný aby v případě rozhodlo o situaci -li prohlášení je nepravdivé.

Je mi líto, pokud to zní příliš matoucí, nebojte se, pokusíme se to pochopit pomocí následujícího pří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)
}

Ve výše uvedeném můžete dobře vidět, že v 10. řádku je kód spuštěn pouze tehdy, když delayTime je menší nebo roven 100, pokud ne, pak je proveden kód ve 13. řádku, ale oba společně se nikdy nemohou stát, bude implementován buď 10. řádek, nebo 13. řádek, nikdy oba.

Možná jste si všimli, že na rozdíl od toho, co jsme udělali v naší předchozí části 2.2, zde jsme neporovnávali s 0, spíše ve srovnání se 100. Je to proto, že v tomto příkladu ve srovnání PŘED odečtením 100 jsme naproti tomu v části 2.2 porovnali PO odečteno. Můžete říct, co by se mohlo stát, kdybychom porovnali 0 místo 100?

2.4 VÝKAZY WHILE

NA zatímco prohlášení je docela podobné -li prohlášení, s výjimkou pravdy, že způsobí opakované spuštění bloku kódu (který může být mezi složenými závorkami) po tak dlouhou dobu, kdy jsou podmínky použitelné, a to funguje bez jiný tvrzení.

Následující příklad vám pomůže lépe to pochopit

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 uhodnout, na co je výše uvedený kód naprogramován? Je navržen tak, aby blikal LED rychleji a pomaleji.

2.5 Co je pravda a nepravda?

V programovacím jazyce Nepravdivé označuje nulu (0). Ve skutečnosti se „true“ nepoužívá, místo toho se předpokládá, že když nic není falešné, pak vše, co je zahrnuto, je true.

Vypadá to trochu divně, ale dělá to docela hezky.

Pokusíme se situaci uchopit prostřednictvím následujícího příkladu.

Někdy se můžete setkat s kódem, jak je uvedeno níže:

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

Toto je kódované, vypadá to, že provedení LED bude cyklovat navždy, protože je k dispozici dlouhá energie.

Jedna nevýhoda tohoto typu kódu by však mohla vzniknout, když uživatel omylem použije = místo ==.

Jsem si jistý, že už víte, že = znamená přiřazení, což znamená, že se používá k označení vybrané hodnoty proměnné, zatímco == se používá k vynucení testu, pokud byla hodnota stejná.

Předpokládejme například, že jste požadovali, aby LED dioda blikala sekvenčním vzorem rychlosti a opakovaně, ale nesprávně jste použili = místo ==.

Kód by pak vypadal 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
}

Chyba přiřadí 0 k delayTime a povede k -li příkaz ke kontrole, zda 0 byla pravda nebo ne. Protože 0 odkazuje na false, bude si myslet, že to není pravda, a zastaví vynucování delayTime = 1000, ale místo toho funkce delayTime je udržován na 0 během smyčky ().

To vypadá velmi nežádoucí !!

Vždy tedy zkontrolujte svůj program, abyste se ujistili, že jste neudělali žádné takové hloupé chyby.

2.6 Kombinace

Někdy můžete cítit potřebu testovat více věcí společně. Stejně jako budete chtít prozkoumat, zda proměnná byla mezi dvěma čísly. I když to lze implementovat pomocí příkazu if několikrát, může být pohodlnější použít logické kombinace pro lepší a snadnější čtení.

Implementaci kombinací logických podmínek lze provést pomocí 3 metod, jak ukazuje následující tabulka:

tabulka ukazující kombinované metody Arduina

Bylo by zajímavé vědět, že operátor NOT může pracovat jako přepínač pro proměnnou, která může být označena jako buď skutečný nebo Nepravdivé (nebo NÍZKÝ nebo VYSOKÝ).

Následující příklad ilustruje podmínku:

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

Zde je ledState bude LOW a následně, jakmile ledState = !ledState, se změní na HIGH. Následující smyčka způsobí ledState být VYSOKÝ, když ledState = !ledState je nízký.

2.7 PRO prohlášení

Nyní se pokusíme porozumět další kontrolní struktuře, kterou je pro smyčka. To může být velmi užitečné, když chcete něco implementovat několikrát.

Pochopme to na následujícím příkladu:

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 řádku s můžete najít něco jedinečného pro.

To je kód i ++? . To je užitečné pro programátory, kteří jsou spíše líní a chtějí implementovat kódování pomocí pohodlných zkratek

Výše uvedený termín je známý jako složené operátory, protože kombinují jednoho operátora přiřazení s jiným operátorem přiřazení. Nejoblíbenější z nich lze vizualizovat v následující tabulce:

operátoři arduino sloučeniny

Zjistíte, že v příkazu for jsou 3 dílčí příkazy. Je strukturován tak, jak je uvedeno níže:

for (statement1conditionstatement2){
// statements
}

Prohlášení # 1 se vyskytuje hned na začátku a pouze jednou. Podmínka se testuje pokaždé v průběhu cyklu. Kdykoli to je skutečný uvnitř složených závorek je vynuceno následné prohlášení # 2. V případě a Nepravdivé, systém skočí na další blok kódu.

Připojení více LED

Dobře, teď uvidíme, jak můžeme propojit větší počet LEds pro získání zajímavějších efektů.

Připojte LED diody a Arduino, jak je znázorněno níže. Červený vodič ve skutečnosti není nutný, ale protože je vždy dobré mít v napájecím poli zahrnuty obě přívodní kolejnice, má nastavení smysl.

Arduino více LED připojení

Nyní pojďme opravit program, který nám umožní zkontrolovat, zda je náš hardware správně nakonfigurován nebo ne.

Vždy se doporučuje kódovat a spouštět malé kousky programů krok za krokem, aby se zkontrolovalo, zda jsou příslušné hardwarové součásti připojeny správně nebo ne.

To pomáhá rychle vyřešit případnou chybu.

Níže uvedený příklad kódu poskytuje LED 2 až 5 specifický vzor jejich cyklickým otáčením jeden po druhém.

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

Jak si můžete všimnout, na kódu není nic špatného, ​​kromě skutečnosti, že vypadá dlouho a je proto náchylný k chybám.

Samozřejmě existují lepší způsoby, jak napsat výše uvedený kód, odhalí to následující část.

2.9 Představujeme pole

Pole mohou být skupinou proměnných, které lze indexovat čísly indexu. Následující příklad nám pomůže lépe jej pochopit.

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

Dobře, pojďme projít každou sekci a pochopit, jak ve skutečnosti fungují.

const int k_numLEDs = 4

Výše uvedený kód definuje, kolik maximálních prvků máme v poli mít. Tento kód nám v následujících částech pomůže zajistit, aby bylo vše napsáno v poli a po ukončení pole nic.

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

V tomto dalším řádku nastavíme strukturu pole. Čísla uvnitř závorky označují počet prvků v poli. Skutečné množství však mohlo být napsáno, psaní jako konstanty funguje lépe. Hodnoty lze běžně vidět uvnitř závorky čárkami a určit hodnoty do pole.

Když najdete pole indexované číslem 0, znamená to úplně první prvek v poli, jak je znázorněno v code: k_LEDPins is k_LEDPins[0].

Podobně se poslední prvek zobrazí jako k_LEDPins[3], protože počet od 0 do 3 je 4.

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

Výše uvedený kód ukazuje použití smyčky pro procházení jednotlivými prvky pole a pro jejich nastavení jako VÝSTUPY. K dosažení každého z prvků v poli implementujeme hranaté závorky spolu s indexem.

pokud vás zajímá, zda je možné použít pin # 2 na pin # 5 bez polí, odpověď zní ano, je to možné. Ale v tomto příkladu se to nedělá, protože jsme to tak neudělali. V následujících částech můžete eliminovat maticový přístup, pokud vybrané výstupní piny nejsou v řadě.

Pokračujeme, podívejme se, co udělá další blok kódu:

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

Zde kód postupuje každou z LED a postupně je zapíná s mezerou nebo zpožděním 100 milisekund.

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

Použití výše uvedeného kódu ukazuje, jak aplikace pro smyčku lze použít k pohybu smyčkou i v opačném pořadí.

Začíná to od k_numLEDs - 1 protože pole jsou nulová indexována. Nezačínáme od k_LEDPins[4] protože by to vedlo k překročení cíle pole.

Kód používá> = 0 ke kontrole, aby první prvek v indexu 0 nebyl zmeškán nebo ignorován.

Kapitola 3

Co je to vstup

Takže jsme se naučili, jak ovládat věci pomocí Arduina. V této kapitole budeme diskutovat o tom, jak vnímat skutečný svět propojením vstupů z externích parametrů.

3.1 Používání tlačítek

Všichni víme, co je to tlačítko a jak funguje. Jedná se o druh spínače nebo tlačítka, které na chvíli spojí signál z jednoho stupně obvodu do druhého, když je v depresivním stavu, a při uvolnění signál přeruší.

3.1.1 Jedno tlačítko a LED

tlačítko rozhraní s Arduino

Propojíme Arduino pomocí tlačítka s Arduinem podle výše uvedených detailů a naučíme se základní práci a implementaci nastavení.

Uvedené tlačítko, které se také nazývá tlačítko mikrospínače, má celkem 4 piny (2 páry na každé straně). Po zatlačení jsou každý pár kolíků spojeny interně a umožňují spojení nebo vedení přes ně.

V tomto příkladu používáme pouze jeden pár těchto pinů nebo kontaktů, druhý pár je irelevantní, a proto je ignorován.

Pojďme pokračovat, použijeme následující kód a zkontrolujeme jeho funkčnost!

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

Najdete zde několik věcí, které vypadají neobvykle. Pojďme na ně přijít krok za krokem.

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

První věc, kterou uděláme, je opravit buttonPin jako VSTUP. No, to je docela základní, já vím.

Dále přiřadíme VYSOKÝ do VSTUP kolík. Zajímalo by vás, jak je možné na vstup něco napsat? Jistě, to může být zajímavé.

Přiřazení HIGH ke vstupu Arduino ve skutečnosti přepíná interní pull-up rezistor 20 kOhm na ON (LOW na tomto pinu jej přepíná do polohy OFF).

Další otázkou, kterou můžete, je to, co je pull-up rezistor. Pokryl jsem komplexní příspěvek o pull-up rezistorech, které vy naučte se to zde .

Dobře, pokračujeme, podívejme se nyní na kód hlavní smyčky:

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

Když stisknete tlačítko, kabelový kolík se připojí k zemi, což způsobí a NÍZKÝ k tomu kolíku. A zatímco je v nestlačeném stavu, drží se stejný kolík VYSOKÝ nebo + 5 V přes 20K interní pull-up rezistor.

Zde chceme, aby Arduino rozsvítilo LED, když je stisknuto tlačítko (LOW), proto píšeme HIGH pro výstup pro každou reakci LOW z tlačítka, zatímco je stisknuto.

3.1.2 Dvě tlačítka a LED

Možná se divíte, že výše uvedená akce by se dala udělat i bez Arduina. Chápu, ale toto je strmý kámen, který se učí, jak lze tlačítko použít s Arduno.

Do tohoto okamžiku jsme studovali psaní kódů pro zapnutí LED (VYSOKÁ) nebo VYPNUTÍ (NÍZKÁ) LED.

Nyní se podívejme, jak lze ovládat jas LED pomocí Arduina.

To lze provést dvěma způsoby:

  1. Omezením proudu na LED
  2. Používáním PWM nebo pulzní šířková modulace, při které se napájení LED velmi rychle zapíná / vypíná požadovanou rychlostí, čímž vytváří průměrné osvětlení, jehož intenzita by závisela na PWM.

Na desce Arduino je podpora PWM k dispozici na pinech označených vlnovkou (~), což jsou piny 3, 4,5,9,10 a 11) při 500 Hz (500krát za sekundu). Uživatel je schopen poskytnout libovolnou hodnotu mezi 0 a 255, kde 0 znamená, že není HIGH nebo no + 5V, a 255 říká Arduino, aby dostalo HIGH nebo + 5V po celou dobu. Pro spuštění těchto příkazů budete muset získat přístup k analogWrite () s požadovanou hodnotou.

Můžete předpokládat, že PWM je x / 255, kde x je požadovaná hodnota, kterou chcete odeslat pomocí analogWrite().

Arduino PWM ovládání

Nastavte Arduino a další parametry, jak je uvedeno výše.

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

Naleznete zde 3 řádky, které vyžadují vysvětlení.

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

Řádek: ledBrightness = constrain(ledBrightness, 0, 255) ilustruje jedinečnou funkci uvnitř Arduina známou jako constrain ().

Tato interní funkce obsahuje kód podobný tomuto:

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

Všechny kódy diskutované před tímto začaly prázdnota , což znamenalo nevrátit nic (neplatnost). Zatímco výše uvedený kód začíná int , což znamená, že vrací celé číslo. O dalších si povíme v dalších částech, v tuto chvíli si jen pamatujte, že celé číslo nemá žádné zlomkové části.

Správně, takže z toho vyplývá, kód: ledBrightness = constrain(ledBrightness, 0, 255) přiřadí ledBrightness to be within the range of 0 and 255.

Další řádek používá analogWrite přikazuje Arduino, aby na vybraný pin aplikovalo PWM s požadovanou hodnotou.

Následující řádek vytváří zpoždění 20 milisekund, to má zajistit, že neupravíme rychlost rychleji než 50 Hz nebo 50krát za sekundu. Je to proto, že lidé mohou být mnohem pomalejší než Arduino. Pokud tedy nedojde ke zpoždění, program by nás mohl přimět k pocitu, že stisknutím prvního tlačítka LED zhasla a stisknutím druhého tlačítka ji zapla (potvrďte sami).

3.2 Potenciometry

Pojďme dál a naučme se používat potenciometry s Arduino.

Chcete-li vědět, jak funguje potenciometr nebo hrnec, přečtěte si toto článek .

Pomocí potenciometru s Arduino

Připojte zobrazené parametry k vašemu Arduinu, jak je uvedeno výše.

Hrnec bude mít 3 terminály. Prostřední terminasl se připojí k ANALOG IN 0 na Arduinu. Další dvě vnější svorky mohou být připojeny k napájecím lištám + 5V a 0V.

Pojďme programovat a zkontrolovat 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)
}

Najdete zde několik věcí, které mohou vypadat zcela nové a nejsou zahrnuty v žádném z našich dřívějších kódů.

  1. Konstanta kPinPot je přiřazen jako A0, kde A je zkratka k popisu jednoho z analogových pinů. A0 však také odkazuje na pin # 14, A1 na pin # 15 a tak dále, a ty vám umožní být použity jako digitální vstupy / výstupy pro případ, že by vám v experimentu došly piny. Pamatujte však, že nelze použít digitální piny jako analogové piny.
  2. Řádek: ledBrightness = map(sensorValue, 0, 1023, 0, 255) představuje novou vnitřní funkci v Arduinu známou jako mapa(). Tato funkce překalibruje z daného rozsahu do jiného, ​​nazývaného jako mapa (hodnota, fromLow, fromHigh, toLow, toHigh). To může být rozhodující, protože analogueRead vydává hodnotu v rozsahu 0-1023, ale analogWrite je schopen přijmout hodnotu od 0-255.

Možná si myslíte, že jelikož je možné ovládat jas LED pomocí měnícího se odporu, mohl by stačit pouze hrnec pro účel, proč je použití Arduina. Opět je to jen základ, který ukazuje, jak by bylo možné nakonfigurovat hrnec s Arduinem.

Žádné problémy, teď uděláme něco, co se bez Arduina neobejde.

V tomto experimentu uvidíme, jak by bylo možné použít měnící se odpor hrnce pro řízení rychlosti nebo rychlosti blikání LED.

Zde 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 Zamezení zpoždění ()

Výše uvedený kód vypadá dobře, ale dioda LED nemůže kontrolovat hodnotu potu, dokud neprojde každým celým cyklem. U delších zpoždění se tento proces prodlužuje, takže uživatel musí čekat, až uvidí reakci banku, zatímco s ní pohybuje. Tomuto zpoždění se lze vyhnout pomocí inteligentního programování, takže umožňuje uživateli zkontrolovat hodnotu bez minimálních zpoždění. Tady 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)
}
}

Co se tedy ve výše uvedeném kódu liší? Rozdíl je v následujícím řádku.

long lastTime = 0

Do této části jsme diskutovali o proměnné int. Může však existovat mnoho dalších proměnných typů, ke kterým máte přístup. Seznam si můžete přečíst níže:

Typy proměnných Arduino

V současné době může být jen zásadní vědět, že pro ukládání relativně velkého počtu pro int proměnnou, můžete použít výraz dlouho nebo a dlouhá int.

Zde můžete vidět další zajímavou funkci s názvem millis ().

To vytváří časové rozpětí v milisekundách, které Arduino pracovalo ve svém provozu od začátku (po každých 50 dnech se resetuje na 0). Zde se vrací dlouho, protože pokud se vrátil int , počítání po dlouhou dobu nemusí být možné. Mohl byste přesně odpovědět, jak dlouho? Odpověď je 32,767 sekundy.

Proto místo použití delay () zkontrolujeme millis () a jakmile uplyne konkrétní počet milisekund, vyměníme LED. Následně ukládáme čas, kdy jsme jej naposledy změnili naposledy proměnnou, takže nám umožňuje znovu ji kdykoli zkontrolovat.

3,3 RGB LED

Dosud jsme hráli s jednobarevnou LED. Barvu LED lze sice změnit výměnou LED za jinou barvu, ale co takhle použít RGB LED změnit barvy LED beze změny LED?

RGB LED je v zásadě LED s integrovanou červenou, zelenou a modrou LED a sloučenou do jedné LED. Má jeden společný vodič, který vede k zemi nebo napájecí přívod 0 V, zatímco další 3 vodiče jsou napájeny diverzifikovanými pozitivními signály PWM pro realizaci zamýšleného míchání barev .

Instalaci můžete zapojit, jak je znázorněno níže:

Ovládejte RGB pomocí Arduina

Může to vypadat trochu složitě, ale ve skutečnosti je to replika našeho dřívějšího návrhu ovládání LED pomocí PWM.

Zde 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 nahrání tohoto kódu se podívejte, jak úpravy hrnce vytvářejí zajímavý světelný efekt na RGB, může to být skutečná zábava.

Zjistíte, že když jsou všechny 3 hrnce posunuty o maximální pozice, místo bílé barvy uvidíte červenou. Je to proto, že červená barva je nejvýznamnější mezi 3 barvami, a proto v této situaci dominuje. S touto funkcí však můžete experimentovat mapa() , před provedením do červené části LED, aby se vytvořila rozumnější rovnováha.

Zvuk s Arduino

V této části se naučíme, jak přidat základní zvuk a hudbu do nastavení Arduina.

Uvidíme, jak přepnout signál na připojený reproduktor s požadovanou frekvencí.

Přesněji řečeno, vyzkouší se střední nota A, což je nota o frekvenci 440 Hz.

Za tímto účelem jednoduše zahrajeme střední notu A a optimalizujeme signál sinusové vlny čtvercovou vlnou.

Také vypočítáme dobu, po kterou může reproduktor zůstat ZAPNUTÝ podle vzorce:

timeDelay = 1 sekunda / 2 x toneFrequency.

timeDelay = 1 sekunda / 2 x 440

timeDelay = 1136 mikrosekund

4.1 Zapojme desku Arduino

Používání zvukového efektu v Arduinu

4.2 Přidání jednoduché poznámky

O této funkci jsme již hovořili zpoždění() kde je jednotka v milisekundách (sekunda / 1000), najdete však ještě další funkci delayMicroseconds() kde je jednotka v mikrosekundách (milisekundy / 1000).

Pro současné nastavení naprogramujeme kód pro přepínání + 5V ZAPNUTO / VYPNUTO na vybraném kolíku spojeném s reproduktorem rychlostí 440 pulsů za sekundu.

Připomeňme, že v poslední diskusi jsme určili hodnotu 1136 mikrosekund pro zamýšlenou zvukovou notu.

Tady je program, který vám umožní slyšet zvukovou notu 440 Hz, jakmile naprogramujete arduino s připojeným reproduktorem.

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

S výše uvedenou aplikací je možné vytvořit zvukovou poznámku, což také znamená, že můžeme vytvořit hudbu podle vlastního výběru.

Z kódu chápeme, že Arduino obsahuje několik integrovaných funkcí, které navíc přispívají k tvorbě hudby.

První je tón() který pracuje se 2 prvky spolu s 3. volitelným prvkem označeným jako tón (pin, frekvence, doba trvání). nebo tón (pin, frekvence)

Oba jsou určeny k provedení příslušného časového období, které jste určili.

Při absenci časového období bude hudba pokračovat v přehrávání až do hovoru tón() se provede znovu, nebo dokud neprovedete ne jeden ().

To bude muset být provedeno pomocí funkce zpoždění v případě, že přehrávání hudby je jedinou základní věcí, kterou implementujete.

Doba trvání může být rozhodující, protože umožňuje určit dobu, po kterou se hudba přehrává, takže můžete dělat jiné věci. Jakmile uplyne doba trvání, hudba se zastaví.

Další funkce ne jeden () zpracovává jeden parametr a zastaví vybraný tón na konkrétním přiřazeném pinu.

Zvláštní varování: Kdykoli tón() funkce PWM na pinech 3 a 11 přestane fungovat.

Proto, kdykoli se v programu použije připevnění reproduktoru, ujistěte se, že nepoužíváte zmíněný pin pro reproduktory, místo toho vyzkoušejte nějaké jiné piny pro připevnění reproduktoru.

Dobře, takže tady je program pro implementaci hudby na reproduktoru, i když to není skutečná hudba, spíše základní nota 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)
}

Ve výše uvedeném kódu jste si možná všimli něčeho nového a to je #definovat .

Tento termín funguje jako příkaz pro hledání a nahrazení počítače, zatímco probíhá kompilace.

Kdykoli najde první věc před mezerou, nahradí ji zbývající částí řádku (tzv. Makra).

Takže v tomto příkladu, když počítač vidí POZNÁMKA_E4 rychle jej nahradí množstvím 330.

Další poznámky a přizpůsobení naleznete v souboru na USB flash disku s názvem hřiště. h , kde lze podle vašich preferencí najít většinu frekvencí.

4.4 Hudba s funkcemi

Výše uvedený kód vypadá dobře, ale zdá se, že má mnoho opakování, měla by existovat nějaká metoda, jak tato opakování zkrátit, že?

Dosud jsme pracovali se dvěma základními funkcemi, které jsou součástí Arduina. Nyní může být čas, abychom si vytvořili vlastní funkce.

Každá funkce musí začínat typem proměnné, ke které může být přidružena. Například funkce prázdnota odkazuje na typ, který nevrací nic, proto název neplatný. Všimněte si, že jsme již diskutovali o seznamu proměnných v našich dřívějších částech, můžete je odkázat.

V důsledku toho získá název konkrétní funkce otevřenou závorku '(' následuje seznam parametrů oddělených čárkami.

Každý z parametrů získává svůj typ spolu s názvem a nakonec zavřením ')' závorky.

Tyto parametry lze v rámci funkce aplikovat ve formě proměnných.

Podívejme se níže na příklad, kde vyvíjíme funkci nazvanou ourTone () určené ke sloučení tón() s zpoždění() řádky takovým způsobem, že se funkce přestane vracet, dokud nota nedokončí přehrávání tónu.

Tyto funkce implementujeme v našem předchozím kódu a získáte níže uvedený program, viz poslední řádky:

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

Funkce mohou být nesmírně užitečné, aby usnadnily pochopení programu.

Následuje příklad, kde jsme schopni určit výběr tónu, který chceme hrát, pomocí dvou polí. Jedno pole pro uchování not, druhé pro uchování rytmů.

#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 prvním řádku jasně vidíte úvod #zahrnout tvrzení. Úkolem tohoto příkazu je vyzvednout celý soubor mezi uvozovkami a umístit jej na pozici #zahrnout tvrzení. Podle standardních pravidel jsou přísně umístěna na začátku programu.

Kapitola 5

Měření teploty

Jen pro připomenutí, nezapomeňte místo toho, abyste psali velké programy úplně, je vždy rozumné psát a analyzovat malé části kódů, což pomáhá při rychlém sledování chyb.

5.1 Sériový monitor

Doposud se kódy, o kterých jsme diskutovali, nezdají tak snadné, aby umožnily rychlé řešení problémů. Zde se pokusíme usnadnit monitorování a snazší řešení možného problému.

Arduino má funkci, která mu umožňuje „mluvit zpět“ s počítačem. Můžete si všimnout, že pin0 a pin1 jsou označeny jako RX a TX vedle sebe. Tyto piny jsou ve skutečnosti sledovány samostatným integrovaným obvodem v Arduinu, který je upgraduje na čtení přes kabel USB, zatímco je připojen k počítači.

Níže uvedená část ukazuje plnohodnotný program, prosím projděte si ho, později se dozvíme o nových položkách v kódu. Tento kód je stejný jako v části 2.2, s výjimkou skutečnosti, že obsahuje některá další data, která nám umožňují identifikovat, pro co je kódován.

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

Zde můžete identifikovat dvě nové věci, nový řádek v založit() funkce.

Serial.begin(9600)

Tento řádek jednoduše vyjadřuje nutnost použití Sériové číslo 1 kód pro jeho vynucení s 9600 baudy. (zde seriál odkazuje na bity jeden po druhém a baud znamená rychlost, za kterou je odeslán). Tato přenosová hodnota a hodnota uvnitř sériového monitoru (o tom se dovíme později) se musí rovnat, jinak budou data v sériovém monitoru vykazovat nesmysl. Standard 9600 se stává pohodlnějším.

Druhá nová položka je následující

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

Zde druhý řádek naznačuje, že následující věc vycházející ze sériového portu začne na dalším řádku. Tím se druhá řada liší od první linie.

Ještě jedna věc, kterou můžete vidět, jsou uvozovky ('). Toto je známé jako řetězec, který se zde použije pouze jako konstanty, protože další diskuse na toto téma může být příliš komplikovaná a nad rámec rozsahu.

Dobře, nyní můžeme nahrát výše uvedený kód do Arduina a zjistit, co se stane.

Zdá se, že se nic nestalo, LED č. 13 Arduino blikla a zastavila se, zatímco Tx LED zůstala blikat.

Je to proto, že okno Serial Monitor ještě není opraveno.

Musíte kliknout na pole Serial Monitor ve vašem IDE, jak je uvedeno výše. Nezapomeňte zkontrolovat přenosovou rychlost umístěnou vpravo dole, ve výchozím nastavení by měla být 9600 a bude odpovídat kódu. Pokud to není jisté, vyberte 9600.

Následující videoklip vysvětluje, jak se to dělá.

https://youtu.be/ENg8CUyXm10

Nyní pojďme kupředu a naučme se, jak výše uvedená funkce Serial Monitor může pomoci při zpracování měření teploty pomocí Arduina

Jako teplotní senzor použijeme IC TMP36 s rozsahem -40 až 150 stupňů Celsia.

Nastavení je vidět níže:

TMP36 s Arduino pro měření teploty

Následující kód zahájí měření teploty načtením výstupu ze snímače TMP36 a jejich odeslání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
}

Rozumíme kódu shora.

float temperatureC = getTemperatureC()

Zde vidíte, že jsme zahrnuli typ proměnné plovák.

Toto je jediný typ proměnné, který obsahuje ukládání všeho kromě celočíselných čísel (čísel bez desetinných nebo zlomkových částí).

Přesnost plovoucí proměnné může být až 6 až 7 číslic.

Sousední kód getTemperatureC() je naše vlastní funkce, která matematicky vypočítává a převádí rozdíl snímaného napětí ze snímače TMP36 na stupně Celsia.

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 další části kódů od termínu analogIn() Je-li přiřazeno vrácení čísla mezi 1 až 1023, je možné vyhodnotit napětí ze snímače vynásobením naší hodnoty číslem 5 a následným vydělením 1024.

Je specifikováno, že snímač TMP36 generuje 0,5 V při 0 stupních Celsia a následně generuje 10 mV pro každý jednotlivý nárůst ve stupních Celsia.

Tady je aproximace, kterou jsme schopni vygenerovat pomocí výpočtů:

Kalibrace teploty Arduino

Můžete považovat za svou první funkci, která vrací nějakou hodnotu (všimněte si, že všechny zbývající funkce zatím nevrátily žádnou hodnotu, protože byly typu prázdnota ).

Můžete pochopit, že k získání hodnoty z funkce stačí přidat vrátit se následuje požadované číslo, které chcete vrátit.

Když řekneme vrátit se to znamená, že funkce vrací odpověď nebo odpověď, kdykoli je vyvolána, což lze použít na proměnnou.

Když se to pošle do Serial Monitoru, čtení se převede na Fahrenheit prostřednictvím convertToF ().

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

Tato funkce snímá rozsah Celsia a převádí jej na Fahrenheita.

Pro převod Fahrenheita na Celsia implementujeme vzorec Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Propojení LCD

Nyní pojďme studovat, jak propojit nebo připojit LCD displej s Arduino pro získání vizuálního zobrazení požadovaných výstupů.

V naší aplikaci použijeme grafický LCD displej s rozměry 84 x 48 pixelů, který má vodorovně 84 pixelů nebo bodů a vertikální rozlišení 48 pixelů. Vzhledem k tomu, že vyhrazený řadič se stává nezbytným pro všechny LCD, předkládané zařízení také obsahuje jeden v podobě řadiče PCD8544.

V tomto tutoriálu propojíme výše uvedený LCD modul s Arduinem a použijeme určité rutiny k vytváření textových zpráv na displeji.

Na následujícím obrázku najdete podrobnosti týkající se propojení LCD a malého Regulátor napětí 3,3 V . Tento regulátor je nezbytný, protože LCD je specifikován pro práci s napájením 3,3V.

Můžete také vidět 8 pinů z LCD modulu, specifikace pinů můžete studovat z následující tabulky:

Detaily LCD pinout

Nyní se podívejme, jak můžeme propojit LCD a příslušné parametry s naším Arduinem. Podrobnosti lze vizualizovat na níže uvedeném obrázku:

Arduino základní učení

5.4 Komunikace na LCD

I když je možné z Arduina psát propracovaná jádra pro interakci s LCD, raději se naučíme, jak to udělat pomocí knihoven.

Knihovny obsahují sortiment kódů, které lze rychle použít pro vybraný program Arduino.

To umožňuje uživateli bez námahy volat funkci bez nutnosti složité práce s kódováním.

5.4.1 Jak nainstalovat knihovnu

K tomu budete muset vytvořit adresář s názvem knihovny ve vašem počítači Arduino IDE, jak je vysvětleno tady

5.4.2 Implementace operací LCD

Stejně jako náš předchozí přístup nejprve zkontrolujeme celý kód a poté se pokusíme porozumět podrobnostem jednotlivých řádků.

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

Řádek obsahuje kód #include

Kód #include instruuje PC, aby během kompilace programu vyzvedl uvedený soubor a nahradil element #include obsahem souboru.

Prvek #include může mít lomené závorky, které označují hledání v adresáři knihovny, alternativně může také obsahovat uvozovky, které označují hledání ve stejném adresáři, ve kterém je program umístěn.

Následující řádky kódu vyjadřují pinouty LCD a poté napíšeme novou formu proměnné:

PCD8544 lcd(kPin_CLK, kPin_DIN, kPin_DC, kPin_RESET)

Zde vyjadřujeme proměnnou s názvem lcd mající typ PCD8544 a instruujeme PC, aby přehodnotil své pinouty spojené s Arduino.

V tomto procesu popisujeme proměnnou pro PC instrukcí, jak jsou pin clk, din, dc a reset propojeny s Arduino.

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

Řádek lcd.init() inicializuje provoz LCD. Jakmile je toto provedeno, další řádek vynutí kurzor v levé horní části displeje. A další následující řádek se snaží vytisknout zprávu „Hello, World“.

Vypadá to docela shodně s technikou, kterou jsme posílali zprávy přes sériový monitor. Jediným rozdílem je použití kódu lcd.print místo serial.print.

Další blok kódu se vlastně opakovaně nazývá.

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

Pomocí tohoto řádku lcd.setCursor(0,1) zafixujeme kurzor na 0. sloupec zcela vlevo od 1. řádku nad LCD displejem.

Další řádek používá zkratku: lcd.print(millis())

Pokud si vzpomínáte, pracovali jsme s millis() v našich dřívějších kódech jsme mohli použít stejné i zde prostřednictvím kódů:

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

Avšak vzhledem k tomu, že zde nejsou zahrnuta žádná časová období v milisekundách, dosáhneme toho jednoduše zasláním millis() funkce přímo do lcd.print() .

5.5 Kombinace celé věci

Dobře, pojďme nyní zkombinovat všechny kódy, které jsme se naučili výše pro vytvoření teplotního okruhu LCD, a podívejme se, jak to vypadá:

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

Ve výše uvedeném programu vypadá všechno standardně, s výjimkou použití této funkce setCursor () . Slouží k zarovnání textu co nejvíce kolem středu displeje.

Skvělý! A gratulujeme, právě jste naprogramovali svůj vlastní malý LCD indikátor teploty pomocí Arduina.

Praktické aplikace Arduino

Jelikož jsme v tomto bodě podrobně podrobně popsali různé programovací techniky, je na čase je etstovat tak, že je použijeme pro několik užitečných praktických implementací.

Začneme se senzory a uvidíme, jak lze senzorová zařízení používat s Arduinem provedením několika ukázkových kódů.

7.1 Úvod do senzorů

V tomto tutoriálu se dozvíte o široké škále senzorů, které lze s Arduino použít. Mohou to zahrnovat zařízení, jako je světelný senzor LDR, snímač magnetického Hallova jevu, snímače náklonu, snímač vibrací, snímač tlaku atd.

Začneme propojením světelný senzor LDR s Arduino, jak je znázorněno na následujícím diagramu:

použijte LDR s Arduino

Jak všichni víme, LDR je rezistorové zařízení závislé na světle, jehož odpor závisí na intenzitě okolního prostředí dopadajícího na jeho povrch.

Intenzita světla je nepřímo úměrná odečtu odporu LDR.

Zde se dozvíme, jak lze tuto vlastnost integrovat do Arduina pro spuštění užitečné aplikace:

Celý programový kód lze vizualizovat, jak je uvedeno níže:

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šechny parametry použité v kódu byly již probrány v našem kurzu, který jsme se zatím naučili. Řádky můžete zkontrolovat podle příslušných částí.

Hodnoty byly vybrány náhodně, můžete je snadno změnit podle svých vlastních preferencí.

Senzor náklonu

Snímač náklonu je jednoduché zařízení, které lze použít k detekci náklonu na jakémkoli objektu, kde je nainstalován. Zařízení má v podstatě kovovou kouli uvnitř, která se při naklápění valí přes dvojici kontaktů a způsobuje vedení přes tyto kontakty. Tyto kontakty, které jsou zakončeny jako vodiče sklopného spínače, se používají s externím obvodem pro detekci vedení v důsledku naklánění a aktivaci požadované výstupní aplikace.

Nyní se podívejme, jak snímač náklonu zařízení lze připojit. Obrázek níže nám dává představu o kompletní konfiguraci:

integrovaný senzor náklonu s Arduino

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 příkladu se jako indikátor náklonu použije výchozí LED č. 13.

Zde můžete jasně vidět zahrnutí pull-up rezistoru, docela podobné tomu, co jsme udělali v sekci 3.1. Proto termín LOW označuje, že funkce naklonění není spuštěna.

7.4 Relé jazýčkového spínače (relé aktivované miniaturním magnetem)

Nyní se podívejme, jak zapojit reléový spínač nebo snímač magnetického pole pomocí Arduina. Jazýčkové relé je druh spínače, který se aktivuje nebo vede, když se do jeho blízkosti dostane magnetické pole nebo magnet. V zásadě má pár feromagnetických kontaktů uvnitř miniaturního skleněného krytu, které se spojují nebo vytvářejí kontakt v důsledku magnetického tahu, kdykoli je magnet v jeho těsné blízkosti. Když k tomu dojde, svorky kontaktů ukazují vedení v důsledku sepnutí kontaktů.

I zde používáme pro indikaci odezvy LED č. 13. Z tohoto pinu můžete připojit externí LED, pokud je to požadováno podle našich dřívějších vysvětlení.

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

Podmínky kódu by měly být známé a samozřejmé.

7.5 Senzor vibrací s piezoelektrickým měničem

V dalším ukázkovém programu uvidíme, jak a piezoelektrický měnič lze použít jako snímač vibrací k osvětlení LED přes Arduino.

Piezoelektrický prvek je ve skutečnosti zařízení, které generuje vibrace nebo oscilace, když je na jeho svorky aplikována frekvence. Stejný piezo však mohl být použit v obráceném procesu pro generování elektrických impulsů v reakci na vibrace působící na jeho tělo. Tato vibrace může být ve formě klepání nebo nárazu na povrch piezoelektrického snímače.

Nastavte Arduino a piezoelektrický prvek, jak je uvedeno na následujícím obrázku

pomocí piezoelektrického snímače vibrací u Arduina

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 zavedena pouze proto, aby bylo zajištěno, že Arduino reaguje pouze na skutečné vibrace klepáním, a nikoli na jiné menší vibrace, například z hlasitých zvuků nebo rohů.

Volba pinů A5 není povinná, můžete si vybrat libovolné jiné analogové vstupy podle svých preferencí a porovnáním v programovém kódu.

Používání servomotoru s Arduinem

Servomotor je typ stejnosměrného motoru, který lze otáčet do přesných úhlů podle požadavků konkrétní aplikace. Lze to provést použitím vypočítaného příkazu na příslušné vstupy motoru, aby se na motoru vytvořil přesný úhel otáčení nebo otáčení v rozsahu 180 stupňů.

Servomotor má obvykle 3 vodiče nebo vstupy. Kladné vodiče mají obvykle červenou barvu, záporný nebo uzemňovací vodič jsou černé, přičemž ovládací vodič nebo signalizační vodič mají obvykle bílou nebo žlutou barvu.

Arduino usnadňuje ovládání servomotoru prostřednictvím vestavěného podpůrného jazyka, díky čemuž je ovládání velmi pohodlné a ideální pro servomotory.

Následující příklad nám ukáže základní instalační program pro implementaci řízení servomotoru přes Arduino:

Ovládání servomotoru Arduino

Kód je uveden níže:

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

Zde můžeme vidět několik nových záznamů. Jeden, který říká připojenému vodiči serva k jakému kolíku je přiřazen. Druhým je kód, který poskytuje kolíku hodnotu mezi 0 a 180 pro určení úhlu natočení serva.

Závěr

Předmět Arduino může být nekonečně dlouhý, a proto přesahuje rámec tohoto článku. Doufám však, že vám výše uvedený výukový program určitě pomohl naučit se základy Arduina a porozumět důležitým parametrům prostřednictvím různých příkladů aplikačních kódů.

Doufejme, že zde budou čas od času aktualizovány další informace, kdykoli budou k dispozici.

Do té doby si užijte svůj programovací kurz, Happy Arduinoing vám !!




Předchozí: Obvod detektoru alkoholu pomocí modulu snímače MQ-3 Další: Obvod podavače psů ovládaný mobilními telefony