Programovací jazyk Arduino. Arduino - Základy programování

Po seznámení se základními prvky Arduina a napsání programu „Hello World!“ je čas seznámit se s programovacím jazykem.

Struktura jazyka je založena především na C/C++, takže ti, kteří dříve programovali v tomto jazyce, nebudou mít žádné potíže se zvládnutím programování Arduino. Zbytek by se měl naučit základní informace o ovládacích příkazech, datových typech a funkcích.

Mnoho zde obsažených informací bude kompatibilní s jakýmkoliv kurzem C/C++, s výhradou rozdílů v datových typech, stejně jako s několika konkrétními pokyny týkajícími se programování I/O portů.

Základy základů

Pár formálních věcí, tedy těch, o kterých každý ví, ale občas zapomene...

V Arduino IDE, stejně jako v C/C++, si musíte být vědomi velikosti písmen. Klíčová slova jako if, for jsou vždy psána malými písmeny. Každá instrukce končí ";". Středník říká kompilátoru, kterou část má interpretovat jako příkaz.

Závorky (..) se používají k označení programových bloků. Používáme je k vymezení těla funkce (viz níže), cyklů a podmíněných příkazů.

Je dobrým zvykem přidávat komentáře k obsahu programu, díky tomu je kód snadno srozumitelný. Jednořádkové komentáře začínají na // (dvojité lomítko). Víceřádkové komentáře začínají na /* a skončit s */

Pokud chceme do našeho programu zahrnout jakoukoli knihovnu, použijeme příkaz include. Zde jsou příklady připojení knihoven:

#zahrnout // standardní knihovna #include "svoya_biblioteka.h" // knihovna v adresáři projektu

Funkce v Arduinu

Funkce (podprogram) je samostatná část programu, která provádí nějakou operaci. Funkce se používají ke zjednodušení hlavního programu a zlepšení čitelnosti kódu. Je užitečné používat funkce, protože je můžeme snadno použít v mnoha našich projektech.

Standardní kurz programování obsahuje informace o funkcích, které si představíme v následujících článcích. V případě Arduina budou funkce probrány na začátku, protože i ten nejjednodušší program musí mít dvě speciální funkce. To již bylo zmíněno v předchozích článcích, ale zde tyto informace systematizujeme.

Deklarace funkce

Schéma deklarace funkce vypadá takto:

Zadejte název_funkce(parametr) ( // instrukce k provedení (tělo funkce) return (/* návratová hodnota*/); )

typ je název libovolného dostupného datového typu v daném programovacím jazyce. Seznam typů dostupných při programování Arduina bude uveden v samostatném článku.

Po provedení funkce vrátí hodnotu deklarovaného typu. Pokud funkce nepřijme žádnou návratovou hodnotu, pak bude datový typ "neplatný".

název_funkce umožňuje jeho jednoznačnou identifikaci. Abychom mohli funkci zavolat (spustit), pojmenujeme ji.

parametr— parametr volání funkce. Parametry jsou volitelné, ale často užitečné. Pokud píšeme funkci, která nemá žádné argumenty, necháme závorky prázdné.

Uvnitř závorek "(...)" obsahuje skutečné tělo funkce nebo instrukce, kterou chceme provést. Popis konkrétních pokynů bude uveden v samostatném článku.

Všechny funkce, které vracejí hodnotu, končí příkazem return následovaným návratovou hodnotou. Pouze funkce deklarované s nulovým ukazatelem ("void") neobsahují příkaz return. Musíte vědět, že příkaz return ukončuje provádění funkce bez ohledu na umístění.

Následuje několik příkladů deklarací funkcí.

Void f1() ( //tělo funkce ) —————————————— int minus() ( //návrat těla funkce (0); ) ———————————— ——— int plus(int a, int b) ( return (a+b); )

Jak můžete vidět z příkladů, deklarace funkce může mít mnoho podob v závislosti na vašich potřebách.

Důrazně doporučujeme, abyste se naučili a používali funkce při psaní vlastních programů. Postupem času má každý programátor vlastní knihovnu funkcí „pro všechny příležitosti“, což usnadňuje a zrychluje psaní nových programů.

Nyní, když víme, jak napsat vlastní funkci, musíme se ji naučit používat.

Volání funkce

Všechny funkce zapisujeme do jednoho souboru/programu. Existuje samozřejmě i elegantnější řešení, ale to se pokusíme popsat příště.

Deklarováním funkce ji můžeme použít v dalších funkcích s příslušným názvem a libovolnými požadovanými parametry. Následují příklady volání funkcí, které jsme uvedli výše:

Fl(); plus(2,2); y=plus(1,5);

Jak můžete vidět na příkladech, volání funkce se provádí zadáním jejího názvu a požadovaného počtu parametrů. Důležité je volat funkci vždy podle její deklarace.

Pokud je funkce f1() deklarována bez parametrů, pak nelze při jejím volání specifikovat žádné parametry, tzn. volání funkce f1(0) bude nesprávné.

Funkce plus(int a, int b) vyžaduje právě dva parametry, takže volání s jedním nebo třemi parametry není možné.

Volání y=plus(1,5) provede funkci "plus" s parametry "1" a "5" a uloží návratovou hodnotu do proměnné "y".

funkce setup() a loop().

Se znalostmi o deklarování a volání funkcí můžeme přejít k funkcím systému Arduino: založit() A smyčka(). Pro deklaraci těchto dvou funkcí je vyžadováno Arduino IDE.

setup() je funkce, která se volá automaticky po zapnutí napájení nebo po stisknutí tlačítka RESET.

Jak jeho název napovídá, slouží k nastavení počátečních hodnot proměnných, deklarací vstupů a výstupů systému, které jsou obvykle uvedeny v počátečních parametrech. Tato funkce vzhledem ke své specifičnosti nevrací hodnotu a není volána s parametry. Správná deklarace funkce setup() je uvedena níže:

Void setup () ( // tělo funkce - inicializace systému )

loop() je funkce, která se volá v nekonečné smyčce. Tato funkce také nevrací hodnotu a není volána s parametry. Následuje správná deklarace funkce loop():

Prázdná smyčka () ( // tělo funkce - kód programu )

Jak vidíte, deklarace funkce loop() je totožná s deklarací funkce setup(). Rozdíl spočívá ve výkonu těchto funkcí mikrokontrolérem.

Nyní budeme analyzovat následující pseudokód:

void setup () ( on_led1 (); // zapnout led1 off_led1 (); // vypnout led1 ) void loop () ( on_led2 (); // zapnout led2 off_led2 (); // vypnout led2 )

Ve funkci setup() jsou dvě instrukce, první zapíná LED1 připojenou k desce (například pin 13) a druhá vypíná LED1.

Funkce loop() má shodné instrukce pro zapnutí a vypnutí led2 připojené k desce (např. pin 12).

V důsledku spuštění programu LED1 jednou blikne, zatímco LED2 se rozsvítí a zhasne, dokud je Arduino zapnuté.

Stisknutí tlačítka RESET způsobí, že LED1 znovu zabliká a LED2 začne znovu blikat.

Shrnout:

• Funkce setup() a loop() jsou systémové funkce, které musí být definovány v každém projektu. I v situaci, kdy do jedné z nich nenapíšeme žádný kód, musíme tyto dvě funkce stále deklarovat;
• Funkce setup() běží jednou, loop() běží nepřetržitě;
• Vytváříme vlastní funkce v jednom souboru;
• Naše funkce můžeme volat jak z setup () a loop (), tak z jiných funkcí;
• Naše vlastní funkce lze volat s parametry a vrátit hodnotu;
• Volání funkce musí být provedeno v souladu s její deklarací.

V životě arduinisty dříve nebo později přijde okamžik, kdy se to v běžném vývojovém prostředí hemží. Pokud vašim náčrtům dojde paměť, potřebujete tvrdý realtime a práci s přerušeními nebo se jen chcete přiblížit hardwaru, pak je čas přejít na C. Zkušení elektrotechnici se při zmínce o Arduinu opovržlivě zamračí a pošlou nováček v rádiu pro páječku. Možná to není nejhorší rada, ale zatím se jí řídit nebudeme. Pokud zahodíme Arduino IDE a kabeláž / procesorový jazyk, budeme mít v rukou vynikající ladicí desku, již vybavenou vším potřebným pro provoz mikrokontroléru. A co je důležité, bootloader je již všitý do paměti řadiče, což vám umožňuje stahovat firmware bez použití programátoru.

Pro programování v C potřebujeme AVR GCC Toolchain.

Potřebujeme také nainstalovat Arduino IDE, protože. obsahuje utilitu avrdude, která je potřebná pro stažení firmwaru do ovladače. CrossPack také obsahuje avrdude, ale verze, která je s ním dodávána, nefunguje s Arduinem.

Poté, co je vše nainstalováno, pojďme vytvořit náš první projekt. Pro začátek si napišme Makefile. Umožní nám to vyhnout se ručnímu zadávání dlouhých příkazů pokaždé, když kompilujeme a stahujeme firmware.

#Ovladač nainstalovaný na desce. Mohou být různé, například atmega328 DEVICE = atmega168 #Frekvence hodin 16MHz HODINY = 16000000 #Start příkaz avrdude. Je třeba jej zkopírovat z Arduino IDE. AVRDUDE=/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/bin/avrdude -C/Applications/Arduino.app/Contents/Resources/Java/hardware/tools/avr/etc/avrdude.conf -carduino -P/dev/tty.usbserial-A600dAAQ -b19200 -D -p atmega168 OBJECTS = main.o KOMPILOVAT = avr-gcc -Wall -Os -DF_CPU=$(CLOCK) -mmcu=$(DEVICE) all: main .hex .c.o: $(KOMPILOVAT) -c $< -o $@ .S.o: $(COMPILE) -x assembler-with-cpp -c $< -o $@ .c.s: $(COMPILE) -S $< -o $@ flash: all $(AVRDUDE) -U flash:w:main.hex:i clean: rm -f main.hex main.elf $(OBJECTS) main.elf: $(OBJECTS) $(COMPILE) -o main.elf $(OBJECTS) main.hex: main.elf rm -f main.hex avr-objcopy -j .text -j .data -O ihex main.elf main.hex avr-size --format=avr --mcu=$(DEVICE) main.elf

V tomto souboru musíme zadat náš příkaz ke spuštění avrdude. Na různých systémech to bude vypadat jinak. Chcete-li zjistit svou možnost, spusťte Arduino IDE a v nastavení zaškrtněte políčko „Zobrazit podrobný výstup během nahrávání“.

Nyní načteme libovolný náčrt do Arduina a podíváme se na zprávy zobrazené ve spodní části okna. Najdeme tam volání avrdude, zkopírujeme vše kromě parametru -Uflash a vložíme do Makefile za "AVRDUDE =".

Malá poznámka: veškeré odsazení v Makefile se provádí pomocí tabulátorů (klávesa Tab). Pokud váš textový editor nahradí tyto znaky mezerami, příkaz make odmítne sestavit projekt.

Nyní vytvoříme soubor hlavní.c- aktuální text našeho programu, ve kterém tradičně blikáme LED.

#zahrnout #zahrnout #define LED_PIN 5 int main() ( DDRB |= 1<< LED_PIN; while(1) { PORTB |= 1 << LED_PIN; _delay_ms(1000); PORTB &= ~(1 << LED_PIN); _delay_ms(1000); } return 0; }

Náš projekt je připraven. Otevřete konzolu v adresáři našeho projektu a zadejte příkaz "make":

Jak vidíte, velikost výsledného firmwaru je pouze 180 bajtů. Podobná skica Arduina zabírá 1116 bajtů v paměti řadiče.

Nyní se vraťte do konzole a zadejte „make flash“ pro načtení kompilovaného souboru do ovladače:

Pokud stahování proběhlo bez chyb, tak LEDka připojená na 13. pin desky bude vesele blikat. Někdy avrdude nemůže najít desku nebo vyprší časový limit - v tomto případě může pomoci kroucení kabelu USB. Abyste se vyhnuli konfliktům v přístupu k desce, nezapomeňte před příkazem „make flash“ zavřít Arduino IDE.

Možná se mnoho z věcí popsaných v tomto článku bude zdát ostříleným vývojářům samozřejmých. Snažil jsem se proces popsat co nejsrozumitelnějším jazykem pro začínajícího arduinistu a shromáždit na jednom místě informace, které se mi podařilo získat z různých zdrojů a ověřené zkušenostmi. Možná tento článek někomu ušetří pár hodin času.

Hodně štěstí při ovládání mikrokontrolérů!

Takže máte procesor. Asi chápete, že procesor lze nějak naprogramovat, aby dělal, co chcete. Aby mohla být vykonána užitečná práce, je nutné (a) napsat užitečný program a (b) dát jej procesoru k provedení.

Obecně je jedno, jaký máte procesor: nejnovější Intel Pentium v ​​notebooku nebo mikrokontrolér na desce Arduino. Principy psaní programu, tzn. programování jsou v obou případech stejné. Jediným rozdílem je rychlost a rozsah možností pracovat s jinými zařízeními.

Co je to program a kam ho napsat

Procesor je i přes náročnost výroby ve své podstatě vcelku jednoduchá a přímočará věc. Neví, jak myslet. Může pouze slepě, bajt po bajtu, provádět instrukce, které mu byly podány. Zde je hrubý příklad posloupnosti pokynů:

V důsledku provedení takové sekvence pokynů se na obrazovce zobrazí panická fráze „AAAA!“.

Docela hodně kódu pro tak jednoduchý cíl! Je jasné, že pokud by byly všechny programy napsány takto, přímo, vývoj složitých produktů by trval staletí.

Proč jsou potřeba programovací jazyky

Aby se tento úkol milionkrát zjednodušil, byly vynalezeny programovací jazyky. Existuje mnoho z nich a dokonce i těch, které neustále slyšíte, si můžete rychle vybavit tucet nebo dva: Assembler, C, C++, C #, Java, Python, Ruby, PHP, Scala, JavaScript.

Programy v těchto jazycích jsou mnohem blíže lidskému přirozenému jazyku. A proto se píší snadněji, rychleji a příjemněji a hlavně jsou mnohem jednodušší číst: Vám ihned po napsání, Vám za rok nebo Vašemu kolegovi.

Problém je v tom, že takové jazyky nejsou pro procesor srozumitelné a než mu dáte tento program, musí být kompilovat: přeložte z přirozeného jazyka do stejných pokynů ve formě nul a jedniček. K tomu slouží programy tzv kompilátory. Každý jazyk, pokud nezůstal na úrovni fantazie, má svůj vlastní překladač. U populárních jazyků je obvykle na výběr několik, od různých výrobců a pro různé platformy. Většina z nich je volně dostupná na internetu.

Existují tedy programy v jazyce, který je pro člověka docela srozumitelný: také se jim říká „zdrojový kód“, jednoduše „kód“ nebo „zdrojové kódy“. Jsou zapsány do prostého textového souboru pomocí žádný textový editor, dokonce i s poznámkovým blokem. Poté jsou pomocí kompilátoru převedeny na sady nul a jedniček srozumitelné procesoru: kompilátor obdrží zdrojový kód jako vstup a vytvoří binární spustitelný soubor, který rozumí zpracovatel.

Binární soubory nejsou čitelné a jsou obecně určeny pouze ke spuštění procesorem. Mohou mít různý typ podle toho, za co byly přijaty: .exe - jedná se o programy pro Windows, .hex - programy pro spouštění mikrokontrolérem Arduino atd.

Proč existuje tolik programovacích jazyků a jaký je rozdíl?

Proč? Protože na Zemi je mnoho lidí a společností a mnozí věřili, že to dokážou lépe než kdokoli jiný: pohodlněji, přehledněji, rychleji, štíhleji.

Jaký je rozdíl: různé jazyky mají různou rovnováhu mezi rychlostí zápisu, čitelností a rychlostí provádění.

Podívejme se na stejný program, který na obrazovce zobrazuje písničku o 99 lahvích piva v různých programovacích jazycích.

Například jazyk Perl. Napsáno rychle; je nemožné pochopit, co tím programátor myslel; prováděno pomalu:

jazyk Java. Píše se poměrně dlouho; snadné čtení; provádí se poměrně rychle, ale zabírá hodně paměti:

jazyk symbolických instrukcí. Píše se dlouho; obtížné čtení; běží velmi rychle:

Jak se Arduino programuje?

Když už jsme u Arduina nebo mikrokontrolérů od Atmelu, v jakém jazyce se pro ně dají psát programy? Teoretická odpověď: na jakékoli. Ale v praxi je výběr omezen na Assembler, C a C++. Je to dáno tím, že oproti stolnímu počítači mají velmi omezené prostředky. Kilobajty paměti, ne gigabajty. Megahertz na procesoru, ne gigahertz. To je cena za levnost a energetickou účinnost.

Potřebujete tedy jazyk, který lze efektivně zkompilovat a spustit. Tedy překládat do těch samých nul a jedniček z instrukcí co nejoptimálněji, bez utrácení drahocenných instrukcí a prázdné paměti. Tyto jazyky jsou stejně účinné. Pomocí nich můžete psát programy bohaté na funkce, které běží rychle, dokonce i v rámci úzkých limitů zdrojů mikrokontroléru.

Assembler, jak jste viděli, není nejjednodušší a nejelegantnější, a proto je C/C++ vlajkovou lodí pro Arduino.

Mnoho zdrojů uvádí, že Arduino je naprogramováno v jazyce Arduino, Processing, Wiring. To není úplně správné tvrzení. Arduino je naprogramováno v C / C ++ a to, co se těmito slovy nazývá, je jen pohodlný „body kit“, který vám umožní vyřešit mnoho typických úkolů, aniž byste museli pokaždé znovu vynalézat kolo.

Proč jsou C a C++ zmíněny ve stejné větě? C++ je doplněk k C. Každý program C je platným programem C++, ale ne naopak. Můžete použít obojí. Nejčastěji vás při řešení aktuálního problému ani nenapadne, co používáte.

Jděte k věci: první program

Pojďme napsat první program pro Arduino a nechat jej spustit desku. Je třeba vytvořit textový soubor se zdrojovým kódem, zkompilovat jej a výsledný binární soubor umístit na mikrokontrolér na desce.

Jdeme popořadě. Pojďme napsat zdrojový kód. Můžete to napsat do poznámkového bloku nebo jiného editoru. Aby však byla práce pohodlná, existují tzv. vývojová prostředí (IDE: Integrated Development Environment). Poskytují formou jediného nástroje textový editor se zvýrazňováním a nápovědou, kompilátor spouštěný tlačítkem a mnoho dalších radostí. Pro Arduino se toto prostředí nazývá Arduino IDE. Je volně ke stažení na oficiálních stránkách.

Nainstalujte prostředí a spusťte jej. V okně, které se objeví, uvidíte: většina místa je věnována textovému editoru. Je to místo, kde je napsán kód. Kód ve světě Arduina se také nazývá skica.

Napišme tedy skicu, která nic nedělá. Tedy nejmenší možný správný C++ program, který prostě pálí čas.

Významu psaného kódu se zatím věnovat nebudeme. Pojďme to zkompilovat. Chcete-li to provést, v IDE Arduino je na panelu nástrojů tlačítko "Ověřit". Klikněte na něj a za několik sekund bude binární soubor připraven. Toto bude oznámeno nápisem "Done compiling" pod textovým editorem.

Výsledkem je binární soubor s příponou .hex, který může mikrokontrolér spustit.

Nyní jej musíte vložit do Arduina. Tento proces se nazývá bootování, flashování nebo flashování. Chcete-li provést nahrání v IDE Arduino, na panelu nástrojů je tlačítko "Nahrát". Připojte Arduino k počítači pomocí USB kabelu, klikněte na "Upload" a za pár okamžiků se program nahraje do Arduina. V tomto případě bude program, který tam byl předtím, vymazán.

Úspěšný firmware bude oznámen nápisem „Done Uploading“.

Pokud při pokusu o stažení narazíte na chybu, ujistěte se, že:

V menu Tools → Board se vybere port, ke kterému je Arduino skutečně připojeno. Můžete připojit a odpojit USB kabel, abyste viděli, který port se objeví a zmizí: toto je Arduino.

Nainstalovali jste potřebné ovladače pro Arduino. To je vyžadováno pro Windows, není vyžadováno pro Linux a je vyžadováno pouze pro starší desky před Arduino Duemilanove na MacOS.

Gratulujeme! Prošli jste celou cestu od čistého štítu k fungujícímu programu Arduino. Ať nic nedělá, ale tohle už je úspěch.

Učení mikrokontrolérů se zdá být něco složitého a nepochopitelného? Před příchodem Arudina to opravdu nebylo jednoduché a vyžadovalo to určitou sadu programátorů a dalšího vybavení.

Jedná se o druh elektronického návrháře. Prvotním cílem projektu je umožnit lidem, aby se snadno naučili programovat elektronická zařízení a přitom elektronické části věnovali minimální čas.

Montáž nejsložitějších obvodů a spojování desek lze provádět bez páječky, ale pomocí propojek s odnímatelnými samčími a samičími spoji. Tímto způsobem lze připojit jak nástavce, tak rozšiřující desky, které se v lexikonu arduinoschikov nazývají jednoduše „Štíty“ (štít).

Jaká je první deska Arduino, kterou si jako začátečník koupíte?

Je považována za základní a nejoblíbenější desku. Tento poplatek je přibližně velký jako kreditní karta. Docela velké. Většina štítů, které jsou v prodeji, se k němu perfektně hodí. Na desce jsou zdířky pro připojení externích zařízení.

V tuzemských obchodech pro rok 2017 se jeho cena pohybuje kolem 4-5 dolarů. Na moderních modelech je jeho srdcem Atmega328.

Obrázek Arduino desky a dekódování funkcí každého pinu, Arduino UNO pinout

Mikrokontrolér na této desce je dlouhý čip v pouzdře DIP28, což znamená, že má 28 pinů.

Další nejoblíbenější deska stojí téměř dvakrát levněji než předchozí - 2-3 dolary. Toto je poplatek. Současné desky jsou postaveny na stejném Atmega328, funkčně jsou podobné UNO, rozdíly jsou ve velikosti a řešení přizpůsobení USB, o tom později. Dalším rozdílem je, že pro připojení zařízení k desce jsou k dispozici zástrčky ve formě jehel.

Počet pinů (noh) této desky je stejný, ale vidíte, že mikrokontrolér je vyroben v kompaktnějším pouzdru TQFP32, v balení jsou přidány ADC6 a ADC7, další dvě „extra“ nohy duplikují napájecí sběrnici . Jeho rozměry jsou poměrně kompaktní – zhruba na velikost vašeho palce.

Třetí nejoblíbenější deska je, nemá USB port pro připojení k počítači, jak se připojení provádí, řeknu trochu později.

Jde o nejmenší desku ze všech recenzovaných, jinak je podobná předchozím dvěma a jejím srdcem je stále Atmega328. Nebudeme uvažovat o dalších deskách, protože toto je článek pro začátečníky a srovnání desek je téma na samostatný článek.

V horní části schéma zapojení USB-UART, pin “GRN” je zapojen do resetovacího obvodu mikrokontroléru, dá se to nazvat jinak, proč je to potřeba se dozvíte později.

Pokud je UNO užitečné pro krájení, pak jsou Nano a Pro Mini dobré pro finální verze vašeho projektu, protože zabírají málo místa.

Jak připojit Arduino k počítači?

Arduino Uno a Nano jsou připojeny k počítači přes USB. Zároveň chybí hardwarová podpora USB portu, je zde použito řešení obvodů pro převod úrovní, obvykle nazývané USB-to-Serial nebo USB-UART (rs-232). Zároveň je do mikrokontroléru naflashován speciální zavaděč Arduino, který umožňuje problikávání těchto sběrnic.

Arduino Uno implementuje toto zapojení na mikrokontroléru s podporou USB - ATmega16U2 (AT16U2). Ukazuje se, že pro flashování hlavního mikrokontroléru je potřeba další mikrokontrolér na desce.

V Arduino Nano je to implementováno čipem FT232R nebo jeho protějškem CH340. Toto není mikrokontrolér - je to převodník úrovní, tato skutečnost umožňuje snadno postavit Arduino Nano od nuly vlastníma rukama.

Obvykle se ovladače nainstalují automaticky při připojení desky Arduino. Když jsem si však koupil čínskou kopii Arduina Nano, zařízení bylo rozpoznáno, ale nefungovalo, na převodník byla nalepena kulatá nálepka s datem vydání, nevím, jestli to bylo uděláno schválně, ale když jsem to sloupnul, viděl jsem označení CH340.

Předtím jsem se s tím nesetkal a myslel jsem si, že všechny převodníky USB-UART byly namontovány na FT232, musel jsem si stáhnout ovladače, dají se velmi snadno najít na dotaz "Ovladače Arduino ch340". Po jednoduché instalaci - vše fungovalo!

Mikrokontrolér lze také napájet přes stejný USB port, tzn. pokud jej připojíte k adaptéru mobilního telefonu, váš systém bude fungovat.

Co mám dělat, když na desce není žádné USB?

Deska Arduino Pro Mini je menší. Toho bylo dosaženo odstraněním USB konektoru pro firmware a stejného převodníku USB-UART. Proto je nutné jej zakoupit samostatně. Nejjednodušší převodník na CH340 (nejlevnější), CPL2102 a FT232R, se prodává za 1 $.

Při nákupu věnujte pozornost tomu, pro jaké napětí je tento adaptér určen. Pro mini se dodává ve verzi 3,3 a 5 V, na měničích je často propojka pro přepínání napájecího napětí.

Při flashování Pro Mini je těsně před jeho spuštěním potřeba stisknout RESET, ale u převodníků s DTR to není nutné, schéma zapojení je na obrázku níže.

Jsou spojeny speciálními svorkami "Mother-Mother" (female-female).

Vlastně všechna připojení lze provést pomocí takových svorek (Dupont), jsou na obou stranách se zásuvkami i se zástrčkami a na jedné straně je zásuvka a na druhé zástrčka.

Jak psát programy pro Arduino?

Pro práci s náčrty (název firmwaru v jazyce arduino) existuje speciální integrované prostředí pro vývoj Arduino IDE, které si můžete zdarma stáhnout z oficiálních stránek nebo z jakéhokoli tematického zdroje, obvykle existují žádné problémy s instalací.

Takto vypadá rozhraní programu. Programy můžete psát ve zjednodušeném jazyce C AVR speciálně vyvinutém pro Arduino, ve skutečnosti jde o sadu knihoven s názvem Wiring, stejně jako v čistém C AVR. Jeho použití usnadňuje kód a urychluje jeho práci.

V horní části okna je známé menu, kde můžete otevřít soubor, nastavení, vybrat desku, se kterou pracujete (Uno, Nano a mnoho, mnoho dalších) a také otevřít projekty s hotovými příklady kódu. Níže je sada tlačítek pro práci s firmwarem, přiřazení kláves uvidíte na obrázku níže.

Ve spodní části okna je oblast pro zobrazení informací o projektu, o stavu kódu, firmwaru a přítomnosti chyb.

Základy programování v Arduino IDE

Na začátku kódu musíte deklarovat proměnné a připojit další knihovny, pokud existují, to se provádí následovně:

#include biblioteka.h; // zahrnout knihovnu s názvem "Biblioteka.h"

#define proměnná 1234; // Deklarujte proměnnou s hodnotou 1234

Příkaz Define umožňuje kompilátoru vybrat si typ proměnné sám, ale můžete jej nastavit ručně, například celé číslo int nebo plovoucí desetinnou čárku.

int led = 13; // vytvořil proměnnou "led" a přiřadil jí hodnotu "13"

Program může definovat stav pinu jako 1 nebo 0. 1 je logická jednotka, pokud je pin 13 1, pak se napětí na jeho fyzické noze bude rovnat napájecímu napětí mikrokontroléru (pro arduino UNO a Nano - 5 V )

Digitální signál se zapisuje pomocí příkazu digitalWrite(pin, value), například:

digitalWrite(led, high); //zaznamenejte jednotku do pinu 13 (deklarovali jsme to výše) log. Jednotky.

Jak jste mohli pochopit, odvolání k portům jde podle číslování na desce, odpovídajícího čísla. Zde je příklad podobný předchozímu kódu:

digitalWrite(13, vysoká); // nastavit pin 13 na jedničku

Často požadovaná funkce časového zpoždění je volána pomocí příkazu delay(), jehož hodnota je udávána v milisekundách, mikrosekundy jsou dosaženy pomocí

delayMicroseconds() Delay(1000); //mikrokontrolér bude čekat 1000 ms (1 sekunda)

Nastavení portu pro vstup a výstup se nastavují ve funkci void setup() pomocí příkazu:

pinMode(NOMERPORTA, OUTPUT/INPUT); // argumenty - název proměnné nebo číslo portu, vstup nebo výstup na výběr

Pochopení prvního programu Blink

Jako jakési „Ahoj světe“ pro mikrokontroléry existuje program pro blikání LED, podívejme se na jeho kód:

Na začátku jsme příkazem pinMode řekli mikrokontroléru, aby k výstupu přiřadil port s LED. Již jste si všimli, že kód nedeklaruje proměnnou “LED_BUILTIN”, faktem je, že v deskách Uno, Nano a dalších z výroby je na pin 13 připojena vestavěná LED a ta je na desce připájena. Můžete jej použít pro indikaci ve vašich projektech nebo pro jednoduché testování vašich flasher programů.

Dále nastavíme pin, ke kterému je LED připájena, na jednu (5 V), další řádek nechá MK čekat 1 sekundu a poté nastaví pin LED_BUILTIN na nulu, počká sekundu a program se opakuje v kruhu, takže když je LED_BUILTIN 1 - LED (a jakákoli další zátěž připojená k portu) je povolena, při nastavení na 0 je deaktivována.

Přečtěte hodnotu z analogového portu a použijte načtená data

Mikrokontrolér AVR Atmega328 má vestavěný 10bitový analogově-digitální převodník. 10bitový ADC umožňuje číst hodnotu napětí od 0 do 5 voltů v krocích po 1/1024 celé amplitudy signálu (5 V).

Aby to bylo jasnější, zvažte situaci, řekněme, že hodnota napětí na analogovém vstupu je 2,5 V, což znamená, že mikrokontrolér načte hodnotu z pinu "512", pokud je napětí 0 - "0", a pokud je 5 V - (1023). 1023 - protože počítání začíná od 0, tzn. 0, 1, 2, 3 atd. celkem až 1023 - 1024 hodnot.

Zde je návod, jak to vypadá v kódu, s použitím standardního náčrtu „analogInput“ jako příkladu.

int sensorPin = A0;

int ledPin = 13;

int sensorValue = 0;

pinMode(ledPin, OUTPUT);

sensorValue = analogRead(sensorPin);

digitalWrite(ledPin, HIGH);

delay(sensorValue);

digitalWrite(ledPin, LOW);

delay(sensorValue);

Deklarujeme proměnné:

Ledpin - nezávisle přiřadit pin s vestavěnou LED k výstupu a dát individuální název;

sensorPin - analogový vstup, nastavený podle označení na desce: A0, A1, A2 atd.;

sensorValue - proměnná pro uložení načtené celočíselné hodnoty a další práci s ní.

Kód funguje takto: sensorValue ukládá analogovou hodnotu načtenou z sensorPin (příkaz analogRead). - zde končí práce s analogovým signálem, pak je vše jako v předchozím příkladu.

Zapíšeme jednotku do ledPin, LED se rozsvítí a čekáme po dobu rovnající se hodnotě sensorValue, tzn. 0 až 1023 milisekund. Zhasneme LED a znovu počkáme po tuto dobu, po které se kód opakuje.

Pozicí potenciometru tedy nastavíme frekvenci blikání LED.

mapová funkce pro Arudino

Ne všechny funkce pro akční členy (o žádných nevím) podporují jako argument "1023", např. servo je omezeno úhlem natočení, tedy na půl otáčky (180 stupňů) (půl otáčky) servomotoru , maximální argument funkce je "180"

Nyní o syntaxi: map (hodnota, kterou překládáme, minimální hodnota vstupu, maximální hodnota vstupu, minimální výstup, maximální výstupní hodnota).

V kódu to vypadá takto:

(map(analogRead(pot), 0, 1023, 0, 180));

Odečteme hodnotu z potenciometru (analogRead (pot)) od 0 do 1023 a na výstupu dostaneme čísla od 0 do 180

Hodnoty mapy velikosti:

V praxi to aplikujeme na kód stejného serva, podívejte se na kód z Arduino IDE, pokud si pozorně přečtete předchozí části, pak to nevyžaduje vysvětlení.

A schéma zapojení.

Arduino je velmi šikovný nástroj pro výuku práce s mikrokontroléry. A pokud použijete čistý C AVR, nebo jak se někdy říká „Pure C“ – výrazně snížíte váhu kódu a vejde se ho více do paměti mikrokontroléru, ve výsledku získáte vynikající tovární ladicí deska s možností flashování přes USB.

Líbí se mi arduino. Je škoda, že jí mnoho zkušených programátorů mikrokontrolérů bezdůvodně nadává, že je příliš zjednodušená. V zásadě je zjednodušený pouze jazyk, ale nikdo vás nenutí ho používat, navíc můžete mikrokontrolér flashnout přes ICSP konektor a nahrát si tam požadovaný kód bez zbytečných bootloaderů.

Pro toho, kdo si chce hrát s elektronikou, bude jako pokročilý konstruktér perfektní a zkušeným programátorům se jako deska, která nevyžaduje montáž, bude hodit také!

Více informací o Arduinu a vlastnostech jeho použití v různých obvodech naleznete v e-booku - .

Úvod

Freeduino/Arduino je naprogramováno ve speciálním programovacím jazyce – je založeno na C/C++ a umožňuje využívat libovolné jeho funkce. Přísně vzato, neexistuje žádný samostatný jazyk Arduino, stejně jako neexistuje žádný kompilátor Arduino - napsané programy jsou převedeny (s minimálními změnami) do programu C / C ++ a poté kompilovány kompilátorem AVR-GCC. Takže ve skutečnosti je použita varianta C / C ++ specializovaná na mikrokontroléry AVR.

Rozdíl je v tom, že získáte jednoduché vývojové prostředí a sadu základních knihoven, které usnadňují přístup k periferiím „na palubě“ mikrokontroléru.

Souhlasíte, je velmi výhodné začít pracovat se sériovým portem rychlostí 9600 bitů za sekundu a volat na jedné lince:

Serial.begin(9600);

A při použití "holého" C / C ++ byste se museli vypořádat s dokumentací pro mikrokontrolér a zavolat něco takového:

UBRR0H = ((F_CPU / 16 + 9600 / 2) / 9600 - 1) >> 8;
UBRR0L = ((F_CPU / 16 + 9600 / 2) / 9600 - 1);
sbi(UCSR0B, RXEN0);
sbi(UCSR0B, TXEN0);
sbi(UCSR0B, RXCIEO);

Zde je stručný přehled hlavních funkcí a vlastností programování Arduino. Pokud nejste obeznámeni se syntaxí jazyků C/C++, doporučujeme vám nahlédnout do jakékoli literatury o tomto problému nebo internetových zdrojů.

Na druhou stranu jsou všechny uvedené příklady velmi jednoduché a s největší pravděpodobností nebudete mít potíže s porozuměním zdrojovým textům a psaním vlastních programů i bez přečtení další literatury.

Kompletnější dokumentace (v angličtině) je k dispozici na oficiálních stránkách projektu – http://www.arduino.cc. Je zde také fórum, odkazy na další knihovny a jejich popis.

Analogicky s popisem na oficiálních stránkách projektu Arduino se „port“ vztahuje na kontakt mikrokontroléru, výstup na konektor pod odpovídajícím číslem. Navíc je zde sériový datový port (COM port).

Struktura programu

Ve svém programu musíte deklarovat dvě hlavní funkce: setup() a loop().

Funkce setup() je volána jednou, po každém zapnutí nebo resetu desky Freeduino. Použijte jej k inicializaci proměnných, nastavení režimů digitálního portu a tak dále.

Funkce loop() sekvenčně provádí příkazy popsané v jejím těle znovu a znovu. Tito. po skončení funkce bude volána znovu.

Vezměme si jednoduchý příklad:

void setup() // počáteční nastavení
{
beginSerial(9600); // nastavte rychlost sériového portu na 9600 bps
pinMode(3, INPUT); // nastavení 3. portu pro vstup dat
}

// Program zkontroluje 3. port, zda na něm není signál, a odešle odpověď
// jako textová zpráva na sériový port počítače
void loop() // tělo programu
{
if (digitalRead(3) == HIGH) // podmínka pro polling port 3
serialWrite("H"); // odeslání zprávy ve tvaru písmene "H" na COM port
jiný
serialWrite("L"); // odeslání zprávy ve tvaru písmene "L" na COM port
zpoždění(1000); // zpoždění 1 sec.
}

pinMode(port, režim);

Popis:

Konfiguruje určený port pro vstup nebo výstup signálu.

Možnosti:

port – číslo portu, jehož režim chcete nastavit (celé číslo od 0 do 13).

režim - buď INPUT (vstup) nebo OUTPUT (výstup).

pinMode(13, OUTPUT); //Výstupem bude 13. pin
pinMode(12, INPUT); //a 12. je vstup

Poznámka:

Analogové vstupy lze použít jako digitální vstupy/výstupy, pokud k nim přistupují čísla 14 (analogový vstup 0) až 19 (analogový vstup 5)

digitalWrite(port, hodnota);

Popis:

Nastaví úroveň napětí na zadaném portu na vysokou (HIGH) nebo nízkou (LOW).

Možnosti:

port: číslo portu

hodnota: HIGH nebo LOW

digitalWrite(13, VYSOKÝ); // nastavení pinu 13 do stavu "high".

hodnota = digitalRead(port);

Popis:

Přečte hodnotu na zadaném portu

Možnosti:

port: číslo portu dotazovaného

Návratová hodnota: vrací aktuální hodnotu na portu (HIGH nebo LOW) typu int

int hodnota;
val = digitalRead(12); // dotazování na 12. výstup

Poznámka:

Pokud k portu pro čtení není nic připojeno, funkce digitalRead() může náhodně vrátit hodnotu HIGH nebo LOW.

Analogový vstupní/výstupní signál

hodnota = analogRead(port);

Popis:

Přečte hodnotu ze zadaného analogového portu. Freeduino obsahuje 6 kanálů, každý 10bitový A/D převodník. To znamená, že vstupní napětí 0 až 5V je převedeno na celočíselnou hodnotu 0 až 1023. Rozlišení čtení je: 5V/1024 hodnot = 0,004883V/hodnota (4,883mV). Načtení hodnoty analogového vstupu trvá přibližně 100 nS (0,0001 S), takže maximální rychlost čtení je přibližně 10 000krát za sekundu.

Možnosti:

Návratová hodnota: Vrací hodnotu int v rozsahu 0 až 1023 načtenou ze zadaného portu.

int hodnota;
val = analogRead(0); // přečtení hodnoty na analogovém vstupu 0

Poznámka:

Analogové porty jsou standardně definovány jako vstup signálu a na rozdíl od digitálních portů je není nutné konfigurovat voláním funkce pinMode.

analogWrite(port, hodnota);

Popis:

Výstup analogové hodnoty na port. Tato funkce funguje na: 3, 5, 6, 9, 10 a 11 digitálních portech Freeduino.

Lze jej použít ke změně jasu LED, k ovládání motoru atd. Po vyvolání funkce analogWrite bude příslušný port pracovat v režimu pulzně modulovaného napětí, dokud nenastane další volání funkce analogWrite (nebo funkcí digitalRead / digitalWrite na stejném portu).

Možnosti:

port: číslo dotazovaného analogového vstupu

hodnota: celé číslo mezi 0 a 255. Hodnota 0 generuje 0 V na zadaném portu; hodnota 255 generuje +5V na specifikovaném portu. Pro hodnoty mezi 0 a 255 bude port rychle cyklovat mezi 0 a +5V – čím vyšší je hodnota, tím častěji port generuje HIGH (5V).

analogWrite(9, 128);// nastavení pinu 9 na hodnotu ekvivalentní 2,5V

Poznámka:

Před voláním funkce analogWrite není nutné volat funkci pinMode k nastavení portu na pin.

Frekvence generování signálu je přibližně 490 Hz.

čas = milis();

Popis:

Vrátí počet milisekund od okamžiku, kdy Freeduino provedlo aktuální program. Počítadlo přeteče a vynuluje se přibližně po 9 hodinách.

Návratová hodnota: vrací hodnotu typu unsigned long

dlouho nepodepsaný; // deklarování časové proměnné typu unsigned long
čas = milis(); // předání počtu milisekund

delay(time_ms);

Popis:

Pozastaví program na zadaný počet milisekund.

Možnosti:

time_ms – doba zpoždění programu v milisekundách

zpoždění(1000); //pauza 1 sekunda

zpožděníMikrosekundy

delayMicroseconds(time_µs);

Popis:

Pozastaví program na zadaný počet mikrosekund.

Možnosti:

time_µs – doba zpoždění programu v mikrosekundách

delayMicroseconds(500); //pauza 500 mikrosekund

pulseIn(port, hodnota);

Popis:

Čte puls (vysoký nebo nízký) z digitálního portu a vrací dobu trvání pulsu v mikrosekundách.

Pokud je například parametr "value" při volání funkce nastaven na HIGH, pak pulseIn() čeká, až port přijme vysokou úroveň signálu. Od okamžiku, kdy dorazí, začne odpočítávání, dokud port nepřijme nízkou úroveň signálu. Funkce vrací délku pulzu (vysokou úroveň) v mikrosekundách. Pracuje s pulzy od 10 mikrosekund do 3 minut. Pamatujte, že tato funkce nevrátí výsledek, dokud nebude detekován puls.

Možnosti:

port: číslo portu, ze kterého čteme puls

hodnota: typ pulzu HIGH nebo LOW

Návratová hodnota: vrací dobu trvání pulzu v mikrosekundách (typ int)

int trvání; // deklarace proměnné doby trvání typu int
trvání = pulseIn(pin, HIGH); // změří dobu trvání pulsu

Sériová komunikace

Freeduino má vestavěný sériový řadič, který lze použít ke komunikaci mezi zařízeními Freeduino/Arduino nebo k počítači. Na počítači je odpovídající připojení reprezentováno portem USB COM.

Komunikace probíhá na digitálních portech 0 a 1, a proto je nemůžete použít pro digitální I/O, pokud používáte funkce sériových dat.

Serial.begin(přenosová rychlost);

Popis:

Nastavuje přenosovou rychlost portu COM v bitech za sekundu pro sériovou komunikaci. Pro komunikaci s počítačem použijte jednu z těchto standardních rychlostí: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600 nebo 115200. Další rychlosti můžete definovat také pomocí jiného mikrokontroléru, když com a 1.

Možnosti:

přenosová rychlost: rychlost přenosu dat v bitech za sekundu.

Serial.begin(9600); //nastavíme rychlost na 9600 bps

sériový.k dispozici

počet = serial.available();

Popis:

Byty přijaté přes sériový port vstupují do vyrovnávací paměti mikrokontroléru, odkud je váš program může číst. Funkce vrací počet bajtů nashromážděných ve vyrovnávací paměti. Sériová vyrovnávací paměť může uložit až 128 bajtů.

Návratová hodnota:

Vrátí hodnotu int, počet bajtů dostupných pro čtení v sériové vyrovnávací paměti nebo 0, pokud není nic k dispozici.

if (Serial.available() > 0) ( // Pokud jsou ve vyrovnávací paměti data
// zde by měl být příjem a zpracování dat
}

char = Serial.read();

Popis:

Přečte další bajt ze sériové vyrovnávací paměti.

Návratová hodnota:

První dostupný bajt příchozích dat ze sériového portu nebo -1, pokud nejsou žádná příchozí data.

incomingByte = Serial.read(); // čtení bajtu

Popis:

Vymaže vstupní vyrovnávací paměť sériového portu. Data ve vyrovnávací paměti jsou ztracena a další volání Serial.read() nebo Serial.available() budou mít smysl pro data přijatá po volání Serial.flush().

Serial.flush(); // Vymažte vyrovnávací paměť - začněte přijímat data "od začátku"

Popis:

Výstup dat na sériový port.

Možnosti:

Funkce má několik volacích formulářů v závislosti na typu a formátu výstupních dat.

Serial.print(b, DEC) vytiskne řetězec ASCII, desetinnou reprezentaci b.

int b = 79;

Serial.print(b, HEX) vytiskne řetězec ASCII, hexadecimální reprezentaci čísla b.

int b = 79;

Serial.print(b, OCT) vytiskne řetězec ASCII, osmičkovou reprezentaci čísla b.

int b = 79;
serial print(b, oct); //vypíše na port řetězec "117".

Serial.print(b, BIN) vytiskne řetězec ASCII, binární reprezentaci čísla b.

int b = 79;
Serial.print(b, BIN); //vypíše na port řetězec "1001111".

Serial.print(b, BYTE) vytiskne dolní bajt b.

int b = 79;
Serial.print(b, BYTE); //vytiskne číslo 79 (jeden bajt). V monitoru
//sériový port získáme znak "O" - jeho
//kód je 79

Serial.print(str) pokud str je řetězec nebo pole znaků, odešle str na COM port bajt po byte.

char bytes = (79, 80, 81); //pole 3 bajtů s hodnotami 79,80,81
Serial.print("Zde jsou naše bajty:"); //vytiskne řetězec "Tady naše bajty:"
Sériový tisk (bajty); //vypíše 3 znaky s kódy 79,80,81 -
//toto jsou znaky "OPQ"

Serial.print(b) pokud b je typu byte nebo char, vytiskne na port samotné číslo b.

charb = 79;
Sériový tisk(b); //vydá znak "O" do portu

Serial.print(b) je-li b celé číslo, vytiskne na port desetinnou reprezentaci b.

int b = 79;
Sériový tisk(b); //vypíše na port řetězec "79".

Popis:

Funkce Serial.println je podobná funkci Serial.print a má stejné možnosti volání. Jediný rozdíl je v tom, že po datech jsou vypsány dva další znaky – znak návratu vozíku (ASCII 13 nebo "\r") a znak nového řádku (ASCII 10 nebo "\n").

Příklad 1 a příklad 2 vydají na port to samé:

int b = 79;
Serial.print(b, DEC); //vypíše na port řetězec "79".
Serial.print("\r\n"); //zobrazí znaky "\r\n" - nový řádek
Serial.print(b, HEX); //vypíše na port řetězec "4F".
Serial.print("\r\n");//vytiskne znaky "\r\n" - nový řádek

int b = 79;
Serial.println(b, DEC); //vypíše na port řetězec "79\r\n".
Serial.println(b, HEX); //vypíše na port řetězec "4F\r\n".

V monitoru sériového portu dostaneme.