Po co mi to całe Arduino?

Oczywiście tytuł ma być jedynie prowokacją. Chociaż nie do końca - artykuł jest właśnie poświęcony pracy w Arduino IDE z mikrokontrolerami, ale bez płytek Arduino.
Czym jest Arduino - wiemy wszyscy, zarówno początkujący fani programowania elektroniki, jak i zaawansowani mikrokontrolerowcy. Jeśli jednak nie do końca wiemy, zachęcam do odwiedzenia strony domowej projektu (link 5 na końcu artykułu) oraz zerknięcia np. w poradnik (link 4).

Jakiś czas temu, przełamując się i zmieniając zdanie ("o 180 stopni" ;-)) nabyłem sobie Arduino Leonardo, głównie w celu jego "obwąchania" i zapoznania się z bogatym zbiorem bibliotek dostępnych dla tej platformy. Zgoda, różne biblioteki są dostępne niezależnie od Arduino, ale i tak się zdecydowałem. Dlaczego Leonardo? Otóż miałem ochotę przyrządzić dwie pieczenie na jednym ogniu - mieć Arduino i przetestować ATmegę 32u4. Dziś doskonale zdaję sobie sprawę, że żeby pobawić się Arduino nie trzeba go w ogóle posiadać... Ale po kolei.

Pierwsza rzecz: wiem doskonale, że temat "Arduino bez Arduino" opisały już setki blogerów i pasjonatów, pozwoliłem sobie jednak przedstawić tutaj wyłącznie moje doświadczenia oraz pewien pogląd na temat owych włoskich (?) wynalazków. Zacznę od poglądu.

Płytka Arduino jest płytką prototypową. Oznacza to, że nie została ona - poza kilkoma konstrukcjami, które to przewidują - zaprojektowana do montażu w gotowych urządzeniach. Owszem, można, ale się to najnormalniej nie opłaca. ATmega328P kosztuje około 17 zł, a tak na prawdę tylko ona jest nam potrzebna. Ponadto zakładam, że każdy pasjonat AVR-ów posiada jakiś programator. A gdyby nie posiadał, to USBAsp kosztuje około 25 zł (i kupujemy go tylko raz). Dla porównania Arduino UNO kosztuje około 90 zł. Dla mnie wniosek był prosty: ponieważ bardzo wygodnie pisze się w C/C++ na Arduino i chciałoby się wykorzystać prototyp do wykonania wersji końcowej, należy znaleźć sposób przeniesienia programu z Arduino na "swobodną" ATmegę. Lub ATtiny - wszak nie zawsze potrzebujemy kobylastego układu do sterowania; czasem np. ATtiny85 jest w sam raz.
Sposób taki znalazłem - czyli pora na podzielenie się doświadczeniami. Od razu uprzedzam, że przykłady i screeny pochodzą ze środowiska linuksowego i dotyczą Arduino IDE w wersji 1.0.5, ale wszystko, co opisałem, zostało również przetestowane w systemie Windows (pozostaje jedynie kwestia ścieżek). A podejrzewam, że w MacOS-ach tradycyjnie już nie trzeba nic konfigurować ani testować, bo wszystko jest i działa... ;-) Oczywiście żart - z makówkami najprawdopodobniej działamy jak z linuksami (nie sprawdzałem w MacOS-ie).

Najpierw użyjemy mikrokontrolera ATmega32P.

Do zabawy potrzebujemy:

• Arduino IDE 1.0.5 dla posiadanego systemu operacyjnego;
• programator mikrokontrolerów AVR (np. USBAsp - użyty w przykładach);
• płytkę stykową (breadboard) i kabelki;
• mikrokontroler ATmega328P (wersja z picoPower nie jest konieczna, ale może się przydać);
• opcjonalnie rezonator kwarcowy 16MHz i dwa kondensatory 22pF;
• elementy do zasilania obwodów ATmegi - zgodne z dokumentacją (żeby nie zaciemniać, uprościłem sobie obwody zasilania, ale zasadniczo nie jest to wskazane - krótko mówiąc układ może nie działać tak, jakbyśmy chcieli/zakładali, a w gotowym urządzeniu prawidłowe podłączenie obwodów zasilania to podstawa);
• jeśli z jakiegoś powodu chcemy wgrać do "swobodnej" ATmegi bootloader, to warto takowy pobrać (link 1).

Zacznijmy od tego, że na płytce stykowej przygotujemy sobie ATmegę w postaci gotowej do pracy (linie zasilania, kwarc - zgodnie z dokumentacją układu) i podłączymy programator. Ze strony sprzętowej to już wszystko :-) Włączmy programator do USB i jeśli nasz komputer przeżyje, możemy zabrać się do konfiguracji Arduino IDE.

Zanim cokolwiek zmienimy w którymkolwiek z plików konfiguracyjnych, sugeruję wykonać kopie bezpieczeństwa - tak na marginesie.

Po pierwsze zatem rozpakowujemy archiwum z bootloaderem ATmegi 328 i kopiujemy plik ATmegaBOOT_328.hex do katalogu:

[katalog z Arduino IDE]/hardware/arduino/bootloaders/atmega

Następnie modyfikujemy plik boards.txt, znajdujący się w katalogu [katalog z Arduino IDE]/hardware/arduino, dodając poniższe linie (jest to modyfikacja konfiguracji zaproponowanej w serwisie majsterkowo.pl):

#################################################################

majsterkowo_atmega328p8.name=ATmega328P @ 8 MHz

majsterkowo_atmega328p8.upload.maximum_size=32768
majsterkowo_atmega328p8.upload.using=arduino:arduinoisp

majsterkowo_atmega328p8.bootloader.low_fuses=0xC2
majsterkowo_atmega328p8.bootloader.high_fuses=0xD9
majsterkowo_atmega328p8.bootloader.extended_fuses=0x04

majsterkowo_atmega328p8.bootloader.path=atmega
majsterkowo_atmega328p8.bootloader.file=ATmegaBOOT_328.hex
majsterkowo_atmega328p8.bootloader.unlock_bits=0x3F
majsterkowo_atmega328p8.bootloader.lock_bits=0x0F

majsterkowo_atmega328p8.build.mcu=atmega328p
majsterkowo_atmega328p8.build.f_cpu=8000000L
majsterkowo_atmega328p8.build.core=arduino
majsterkowo_atmega328p8.build.variant=standard

#################################################################

majsterkowo_atmega328p16.name=ATmega328P @ 16 MHz

majsterkowo_atmega328p16.upload.maximum_size=32768
majsterkowo_atmega328p16.upload.using=arduino:arduinoisp

majsterkowo_atmega328p16.bootloader.low_fuses=0xDF
majsterkowo_atmega328p16.bootloader.high_fuses=0xD9
majsterkowo_atmega328p16.bootloader.extended_fuses=0x04

majsterkowo_atmega328p16.bootloader.path=atmega
majsterkowo_atmega328p16.bootloader.file=ATmegaBOOT_328.hex
majsterkowo_atmega328p16.bootloader.unlock_bits=0x3F
majsterkowo_atmega328p16.bootloader.lock_bits=0x0F

majsterkowo_atmega328p16.build.mcu=atmega328p
majsterkowo_atmega328p16.build.f_cpu=16000000L
majsterkowo_atmega328p16.build.core=arduino
majsterkowo_atmega328p16.build.variant=standard

Zaprezentowany dodatek do pliku boards.txt zawiera definicje dla ATmegi 328P z wewnętrznym zegarem 8MHz i zewnętrznym oscylatorem kwarcowym 16MHz. Pozwoliłem sobie zmodyfikować i poprawić ustawienia fusebitów - w obu przypadkach mam ustawioną BOD na poziomie 4,3V i prawidłowo zdefiniowane taktowanie. Ponadto parametr maximum_size ustawiony jest na pełny rozmiar dostępnej pamięci flash (programu). Jeśli chcemy użyć bootloadera, powinniśmy przywrócić wartość z oryginalnego pliku (z serwisu majsterkowo.pl).

Fusebity można ustawić z poziomu Arduino IDE, ale wiąże się to - w takiej konfiguracji - z wgraniem bootloadera. Żeby tego uniknąć, można zmodyfikować konfigurację Arduino IDE, albo użyć np. programu AVR8 Burn-o-Mat (nakładka graficzna na avrdude - patrz link 5) do wstępnej konfiguracji układu. Ja właśnie preferuję tę opcję - zanim zacznę ładować z poziomu Arduino IDE programy do ATmegi, przygotowuję ją Burn-o-Matem. Oto ustawienia fusebitów widoczne w okienkach tego programu - najpierw hardkorowo, po hackersku, a następnie elegancko i intuicyjnie:

• dla procesora taktowanego wewnętrznym zegarem 8MHz

• dla procesora taktowanego zegarem stabilizowanym zewnętrznym rezonatorem kwarcowym 16MHz

• oczywiście konfiguracja BOD jest niezależna od taktowania i taka sama w obu przypadkach

Jeśli wszystko pójdzie zgodnie z planem - mamy przygotowaną ATmegę i środowisko - jedyne, co musimy zrobić, to napisać program w Arduino IDE, skompilować go i wgrać do układu... Najpierw jednak musimy określić wykorzystywaną "płytkę":

• dla zegara wewnętrznego 8MHz

• i dla kwarca 16MHz

oraz wybrać programator (u mnie jest to USBAsp) - w zasadzie nie ma potrzeby wprowadzania związanych z programatorem zmian do plików konfiguracyjnych Arduino IDE:

Dotychczas o tym nie wspominałem, ale po jakichkolwiek zmianach w konfiguracji musimy zrestartować Arduino IDE.

Jeśli chodzi o użycie innego mikrokontrolera ze środowiskiem Arduino IDE, to sprawa wygląda bardzo podobnie. Ostatnio - ze względu na bogate "ficzery" - przypadł mi do gustu malutki ATtiny85 (osiem wyprowadzeń), który ma za dużo pamięci flash żeby z nim "walczyć" w BASCOMie (w wersji demo z ograniczeniem rozmiaru kodu wynikowego do 4KB). Postanowiłem więc - a jakże - programować ten układ za pomocą Arduino IDE.

W przypadku mikrokontrolera ATtiny dostosowanie Arduino IDE jest dużo prostsze - tym bardziej, że nie musimy ingerować w ustawienia środowiska, a jedynie utworzyć odpowiednie foldery w katalogu roboczym, zwykle umieszczonym w naszym katalogu domowym. Pobieramy zatem paczkę z konfiguracją ATtiny dla Arduino IDE (ja preferuję zestaw dostępny pod adresem wskazanym w linku 2), rozpakowujemy i kopiujemy do folderu ~/sketchbook/hardware (jeśli nie ma folderu hardware to go tworzymy), zmieniamy nazwę pliku Prospective Boards.txt na boards.txt i... już!

Możemy przystąpić do programowania ATtiny85 (i innych) za pomocą Arduino IDE. Tyle, że w przypadku tego mikrokontrolera musimy najpierw "wgrać bootloader", co w tym przypadku polega wyłącznie na ustawieniu fusebitów (wybieramy odpowiednią konfigurację "płytki" i klikamy Wypal Bootloader):

Pozostaje tylko jedna, bardzo ważna kwestia: otóż Arduino ma swój system numeracji wyprowadzeń używany również w środowisku, w kodzie źródłowym. Na szczęście istnieją świetne opracowania pokazujące, które piny układów odpowiadają poszczególnym wyprowadzeniom Arduino - proszę kliknąć w link 7.

I to wszystko! Można teraz spokojnie zająć się produkcją tanich urządzeń prototypowanych na płytkach Arduino i wdrażanych na "swobodnych" ATmegach i ATtiny. Idąc krok dalej, można w ogóle nie kupować Arduino... Ba, nawet nie trzeba budować całej płytki (klona)!

Istnieje jednak "drobny" wyjątek, dla którego posiadanie płytki jest praktycznie koniecznością - dostępne na rynku shieldy dla Arduino. Z drugiej jednak strony - zawsze można kupić/zrobić odpowiednią PCB i wlutować gniazdka...

Jeśli ktoś uważałby jednak, że mimo wszystko lepiej w gotowych urządzeniach stosować pełnoprawne płytki Arduino, niech przejrzy artykuł zalinkowany poniżej w punkcie trzecim.

Linki dotyczące artykułu:

1. Bootloader do ATmegi328.
2. Paczka z dodatkiem do Arduino IDE dla mikrokontrolerów ATtiny.
3. Ciekawy artykuł o mitach związanych z Arduino.
4. Poradnik dla początkujących Arduiniarzy.
5. Strona domowa projektu Arduino.
6. AVR8 Burn-o-Mat - must have ;-)
7. Strona m.in. z pinoutami mikrokontrolerów dla środowiska Arduino (innymi słowy: który pin np. ATtiny85 odpowiada któremu wyprowadzeniu Arduino).

A na koniec przykładowy program prototypowany w Arduino Leonardo i wdrożony przeze mnie na mikrokontrolerze ATmega328P - sterowanie oświetleniem kuchennym za pomocą pilota do tunera TV, z czujnikiem ruchu i kilkoma ficzerami... ;-) Warstwa sprzętowa tego projektu to zasilacz na dwa napięcia (5V, 12V), ATmega z kwarcem, kilka standardowych części w obwodzie zasilania procesora, tranzystor BD437 do "zapalania" taśmy LED, czujnik PIR, odbiornik podczerwieni (popularny "tsop") i parę innych drobnostek.