Arduino – Twój mały interaktywny przyjaciel

Arduino – Twój mały interaktywny przyjaciel

Interakcje wizualno - muzyczne
Marcin Wierzbicki
Arduino – Twój mały interaktywny przyjaciel
4 – 6 marca 2011
I. Zamiast wstępu
1. Arduino – co to za zwierzę?
Arduino powstało w roku 2005 jako projekt typu OpenHardware przede wszystkim
z myślą o studentach robotyki i kierunków technicznych. Urządzenie stanowić miało
programowalny, a więc uniwersalny sterownik oraz platformę do konstruowania
projektów interakcyjnych. Jeśli do powyższego opisu dodać, iż Arduino od początku
dawało się sprzęgać z komputerem za pośrednictwem portu szeregowego oraz
posiadało kilka do kilkunastu wejść analogowych oraz wejść/wyjść cyfrowych,
oczywistym się staje, iż to małe urządzenie musiało paść prędzej niż później ofiarą
zainteresowania ludzi sztuki, w szczególności zaś sztuki multimedialnej. Nim
rozpoczniemy interaktywną przygodę z Arduino w świecie dźwięku i obrazu, warto
jednak nadmienić, choćby dla porządku, iż Arduino jest urządzeniem posiadającym
wiele różnych praktycznych zastosowań we wszelkich niemal dziedzinach życia
i nauki. Od sterownika systemem fontann, poprzez superszybki i super precyzyjny
wyzwalacz migawki aparatu fotograficznego sterowany dźwiękiem (pozwalający na
przykład sfotografować kulę w momencie uderzenia w cel, albo rozprysk jaki tworzy
kropla wpadając do wody), po przeróżnego rodzaju systemy cross-platform
pozwalające na zastosowanie popularnych sterowników gier komputerowych
(WiiMote, GameBoy) do sterowania urządzeniami gospodarstwa domowego,
projektami naukowymi czy grami, niekoniecznie jednak komputerowymi. Liczba
zastosowań Arduino – tych już wdrożonych, jak i tych czysto teoretycznych, wydaje
się być ograniczona jedynie ludzką fantazją. Nie tylko zresztą pomysłowość, ale
i poczucie humoru jest cechą jakże pomocną w pracy z tym małym urządzeniem.
Obok realizacji niezwykle poważnych, znajdujemy w internecie wiele projektów
kompletnie zwariowanych, wśród których moim faworytem jest BotaniCalls
(http://www.botanicalls.com/) pozwalający roślinom doniczkowym na kontaktowanie
się z ich opiekunami za pośrednictwem telefonu komórkowego (sic!).
Większość tych projektów, podobnie jak samo Arduino posiada status OpenSource,
dzięki czemu (oraz oczywiście dzięki niezwykle precyzyjnym opisom ich realizacji,
dostępnym w internecie), każdy posiadacz Arduino może skorzystać z tej skarbnicy
wiedzy i doświadczenia oraz wybrać własną drogę poznania świata kreatywnej
technologii, z preferencją wyboru trasy od zabawy poprzez sztukę do nauki lub
w kierunku odwrotnym – od nauki poprzez sztukę do zabawy, albo też rozpoczynając
w dowolnym jej miejscu, na sztuce skończywszy. Tej właśnie, ostatniej marszruty
niniejszy skrypt stanowić będzie mini przewodnik.
2. Szczypta historii
2.1. Rozwój technologii. Prezentacja modeli
Arduino w ciągu 6 lat od chwili powstania dorobiło się nie tylko kilkunastu wersji,
ale także licznych „klonów“. Obrosło także w różnego rodzaju peryferia i gadżety.
Pierwszym Arduino było Serial Arduino zbudowane na bazie 8-bitowego procesora
AVR ATmega8, miało 6 wejść analogowych oraz 14 programowalnych wejść/wyjść
cyfrowych w standardzie TTL z czego niektóre mogły także obsługiwać sygnał PWM.
Ponadto posiadało wyjście zasilające 5V oraz 9V oraz wyprowadzenie masy.
Ten standard powielony został w następnym wcieleniu – Arduino USB (w wersji
2
poprawionej znanym jako Arduino Extreme), po raz pierwszy wyposażonym w złącze
USB, które mogło jednocześnie doprowadzać zasilanie z komputera do układu
(wejście zasilacza jednak pozostawiono, z uwagi na to, iż równie popularnym
jak interakcja z komputerem, jest działanie Arduino jako niezależnego w pełni
funkcjonalnego procesora/kontrolera). W takiej postaci układ powielono w kolejnych
wersjach, wprowadzając rozszerzenia i modyfikacje, a czasem – przeciwnie –
redukując konstrukcje urządzenia w celu jego miniaturyzacji. Tak powstało:
Arduino NG – następca Arduino Extreme posiadający te same właściwości, jednak
o ulepszonej konstrukcji oraz poprawionym oprogramowaniu
Arduino NG+ – zbudowany na bazie nowego układu ATMega168 (głowną różnicą
było rozszerzenie pamięci operacyjnej układu do 16 kB)
Arduino Mini – zminiaturyzowana wersja Arduino zbudowana na bazie
powierzchniowo montowanego układu ATMega168, pozbawiona większości
„wystających“ i dużych elementów, jak gniazdo zasilania czy złącza typu pin (zamiast
tego posiadająca wyprowadzenia do lutowania kabli połączeniowych bezpośrednio
na płytce). Wyposażona w gniazdo miniUSB typu „B“. Do zastosowań, gdzie
kontroler powinien byc zamontowany na niewielkiej powierzchni lub dobrze
schowany. Wersja pierwsza Arduino Mini nazywała się Arduino Stamp 02
Arduino Bluetooth (BT) – wariant Arduino NG z wbudowanym transmiterem/
/receiverem Bluetooth. Ten model nie posiadał złącza USB (komunikacja
z komputerem odbywać się mogła za pośrednictwem Bluetooth), mógł być za to
zasilany z baterii. Bez wątpienia jest to pierwszy układ przeznaczony do działań
w warunkach, w których połączenia kablowe kontrolera z innymi elementami (jak
np. komputer) utrudniałyby lub uniemożliwiałyby realizację projektu. Trzeba jednak
przy tym nadmienić, iż niewielki zasięg transmitera Bluetooth nawet i w tym
przypadku nie pozwalał na oddalanie kontrolera od komputera na odległość większą
niż kilka metrów i to wyłącznie w warunkach idealnych (brak fizycznych przeszkód
czy zakłóceń osłabiających sygnał)
Arduino Diecimilla – w zasadzie nie ma istotnych różnic konstrukcyjnych pomiędzy
tym modelem a wczesniejszym (NG+). Jedyną istotną, i rzeczywiście przydatną,
nową cechą modelu Diecimilla była możliwość zdalnego resetu kontrolera
za pomocą komputera. Tu należy wyjaśnić, iż załadowanie nowego programu
do pamięci Arudino poprzedzone być musi resetem kontrolera, co w przypadku
starszych wersji Arduino należało wykonywac wciskając przycisk umieszczony
na płytce kontrolera, i to w określonej kolejności i czasie, a konkretnie na
ok. 1 sekundę przed transmisją (tzw. upload) programu z komputera do Arduino.
Zbyt wczesny reset mógł spowodować, iż mikroprocesor zaczął już wykonywać
załadowany w nim wcześniej program, natomiast reset zbyt późny, iż pamięć FLASH
nie była jeszcze gotowa na przyjęcie nowego kodu. W obu tych przypadkach
transmisja kodu programu kończyła się niepowodzeniem. Od modelu Diecimilla
kontroler wykonuje automatycznie reset na zlecenie komputera przed wysłaniem
nowego kodu. Mimo to przycisk reset na płytce kontrolera został zachowany. Nazwa
tego modelu w jęz. polskim oznacza „dziesięć tysięcy“ i wskazuje na fakt, iż przed
3
wypuszczeniem tego modelu na rynek sprzedano ponad 10.000 wcześniejszych
wersji Arduino.
Arduino Duemillanove („2009“) – w swojej drugiej wersji, której produkcja
rozpoczęła się 1 marca 2009 r. wprowadził zupełnie nowy procesor ATmega328,
z pamięcią rozszerzoną do 32 kB, dzięki czemu model ten posiada nie tylko więcej
miejsca na kod programu, ale także można w niej tworzyć większe bufory danych
(np. w celu przechowywania krótkich sampli względnie większych tablic z danymi).
Ten model zawiera także szereg drobniejszych usprawnień, m.in. automatycznie
wybiera źródło zasilania (USB/zasilacz). Wcześniejsze modele wymagały ustawienia
tego za pomocą odpowiedniego przełącznika na płytce układu.
Arduino Duemillanove
Arduino Mega – jest zupełnie inną konstrukcją pod wieloma względami, przy
zachowaniu jednak całkowitej zgodności z wersjami starszymi, co do oprogramowania jak i co do możliwości podłączania peryferiów. Bazujący na mikroprocesorze
ATmega1280, posiada nie tylko więcej pamięci FLASH od poprzednich modeli,
ale także znacznie większą liczbę wyprowadzeń. Przede wszystkim mamy tu aż
16 wejść analogowych. Pojawiają się także nowe wejścia/wyjścia cyfrowe
z podziałem na te, które przyjmują/wysyłają sygnał PWM w liczbie 14, te które służą
do komunikacji z peryferiami lub innymi urządzeniami działającymi w standardzie
UART (w sumie 4 porty w układzie TX/RX), oraz 32 „zwykłe“ wejścia/wyjścia cyfrowe
numerowane od 22 do 52.
______________
Opisane powyżej modele, jakkolwiek już nie produkowane, pokazują w sposób
klarowny poszczególne etapy rozwoju Arduino. Sam kontroler rozwija się nadal
bardzo dynamicznie, a lista obecnie dostępnych modeli obejmuje:
______________
Arduino Uno – najnowsza konstrukcja, w której głównie poprawiono design oraz
funkcjonalność. Nowy kontroler USB zastosowany w tej wersji Arduino ma
rozszerzone możliwości komunikacji
z komputerem.
Arduino Mega 2560 – stworzona równolegle
z „Uno“ wersja Arduino Mega z podwojoną
pamięcią FLASH (256 kB) oraz nowym, takim
samym jak w „Uno“ kontrolerem USB.
4
Tyle, jeśli chodzi o rozwój technologii. Warto jednak pamiętać, iż Arduino to przede
wszystkim kontroler mogący działać samodzielnie, dający się zastosować tam, gdzie
użycie komputera, ze względu na jego gabaryty, byłoby niemożliwe. Dlatego też
osobną gałęzią rozwoju Arduino jest miniaturyzacja zapoczątkowana przez Arduino
Mini. Do tej linii należą:
Arduino Nano – funkcjonalnie odpowiednik Arduino Diecimilla, posiadający jednak
8 (zamiast 6) wejść analogowych
Arduino Fio – w zasadzie to samo, co Nano, jednak wyposażony w złącze
pozwalające na sprzęgnięcie go ze specjalną zminiaturyzowaną wersją XBee,
tj. urządzenia do komunikacji bezprzewodowej
LilyPad – odpowiednik Arduino Duemillanove na bazie układu ATmega168V
(względnie ATmega328V) o niższym niż wersje podstawowe zużyciu prądu.
Bardzo ciekawa konstrukcja na płaskiej, okrągłej płytce. Do niezbędnego minimum
zredukowano tu wszystkie wystające części – nie ma
wypukłych lutowań, brak jest też gniazd czy złącz, poza 4pinowym złączem „serwisowym“ służącym przede wszystkim
do podpięcia kontrolera USB, niebędącego standardowym
wyposażeniem płytki. Wszystkie wyprowadzenia znajdują się
na obwodzie płytki w postaci otoczonych warstwą
przewodzącą dziurek. Podłączenia LilyPad za pomocą tych
wyprowadzeń można dokonać na dwa sposoby: albo
przeszywając przez daną dziurkę specjalną przewodzącą nitkę albo wykorzystując
otaczającą ją przewodzącą strukturę jako podstawe do zlutowania z typowym
przewodem zaizolowanym. Ponadto dziurki służyć mają umocowaniu/przyszyciu
samego LilyPad do kostiumu, bowiem ta wersja Arduino stworzona została z myślą
o projektach lub instalacjach, gdzie kontroler powinien w jakiś sposób być
zintegrowany z wykonawcą lub też kostium, jaki nosi wykonawca jest sam w sobie
interaktywną częścią instalacji.
Powyższa skrócona prezentacja nie jest w żadnym wypadku pełna. Pominięte
zostały (a niekiedy zaledwie wspomniane) wersje próbne lub pośrednie niektórych
modeli, brak też jest opisu modeli wymagających od użytkownika większej wiedzy na
temat elektroniki (jak np. Arduino Pro lub Pro Mini). Szczegółowy wykaz wszystkich
produkowanych i nieprodukowanych już modeli Arduino znaleźć można pod tym
adresem: http://arduino.cc/en/Main/Hardware
2.2. Shields czyli dodatki i gadżety
Wraz z powstawaniem kolejnych modeli Arduino oraz z rosnącym zainteresowaniem
tym kontrolerem, w szczególności zaś pod wpływem rosnącej listy potencjalnych
zastosowań tego urządzenia, wzrastała także liczba dodatkowych urządzeń
zgodnych z Arduino i pozwalających się montować bezpośrednio na nim względnie
podpinać pod odpowiednie złącza, których zadaniem jest rozszerzanie możliwości
sprzętowych kontrolera. Budowane są one najczęściej w bardzo prosty sposób,
na płytkach montażowych, stąd nazywane są shields. Obecnie liczba produkowanych
odmian różnych peryferiów jest tak duża, iż ich choćby pobieżna prezentacja
5
wykracza znacznie poza ramy tego skryptu. Z najważniejszych i najbardziej
popularnych warto z pewnością wyliczyć:
XBee – urządzenie służące do bezprzewodowej transmisji w protokole IEEE
802.15.4. Należy podkreślić, iż niestety nie jest to protokół zgodny z obecnie
najpopularniejszym standardem transmisji bezprzewodowej, tzn. WiFi (IEEE 802.11),
stąd też aby dokonać transmisji pomiędzy Arduino a komputerem potrzebujemy co
najmniej dwóch układów XBee nałożonych na dwa XBee Shield. Nie potrzebujemy
natomiast dwóch Arduino, gdyż sam XBee Shield posiada interfejs USB i jest w
stanie komunikować się z komputerem bez pomocy Arduino. Oprócz komunikacji
bezprzewodowej pomiędzy Arduino a komputerem, para XBee w obudowach XBee
Shield może także służyć do komunikacji pomiędzy dwoma Arduino bez
pośrednictwa komputera. Generalnie istnieje możliwość tworzenia sieci wielu Arduino
wyposażonych w XBee. Teoretyczny zasięg XBee to ok. 30 m w pomieszczeniach i
ok. 100 m w przestrzeni otwartej. Trzeba jednak pamiętać, o tym, iż wszelkie
przeszkody oraz zakłócenia (np. działanie innych urządzeń bezprzewodowych, w tym
WiFi) może znacznie zmniejszać siłę sygnału. Praktyczne doświadczenia pokazują,
iż gwarantowany zasięg XBee w warunkach scenicznych przy zastosowaniu
nadajnika XBee wszytego w kostium wykonawcy, przez co osłoniętego, ogranicza się
do 10-15 m. Przy większym dystansie transmisja jest co prawda możliwa, ale jej
stabilność może nie być zadowalająca.
XBee Shield
Ethernet Shield – wyposażona w standarodowe gniazdko Ethernetowe płytka
umożliwiająca podłączenie Arduino do internetu lub sprzęgnięcie z innymi
urządzeniami posiadającymi złącza Ethernet w wewnętrzną sieć. Istniejące
w zasobach internetu darmowe biblioteki oprogramowania pozwalają na szeroki
zakres wykorzystania Arduino w sieci zgodnie z protokołami transmisji TCP oraz
UDP. Bardzo interesujące rozwiązanie szczególnie w czasach ekspansji sztuki
w internecie oraz zdecydowanie wiodącego standardu w dziedzinie komunikacji
pomiędzy urządzeniami i oprogramowaniem multimedialnym, jakim jest OSC.
Motor Shield – płytka, dzięki której można bezpośrednio z programu uruchomionego
w Arduino sterować niskonapięciowymi silniczkami na prąd stały (takimi, jakie
powszechnie używa się w modelarstwie). Tego typu rozwiązanie sprawdzi się
doskonale w konstruowaniu mobilnych instalacji, ruchomych rzeźb czy innych form
artystycznych, których podstawę stanowi ruch, przemieszczanie się lub obrót obiektu
wokół własnej osi.
6
Spośród niezwykle długiej listy peryferiów do Arduino, której najpełniejszą chyba
prezentację w internecie odnaleźć można pod tym adresem: http://shieldlist.org/
wymienić warto takie, jak elementy tzw. user interface (joysticki, systemy
włączników/wyłączników, dotykowe ekrany LED, etc.), mikrofony lub głośniki
sprzężone z przedwzmacniaczami oraz inne proste urządzenia audio na płytkach od
razu do montażu na Arduino, interfejsy video typu TV-out lub video capture,
odbiorniki GPS, czytniki kart SD oraz kart kredytowych (sic!), interfejsy MIDI czy
proste samplery a nawet syntezatory sterowane z Arduino.
Motor Shield Kit
2.3. „Klony“
Decyzją konstruktorów Arduino było niezastrzeganie praw patentowych do tej
konstrukcji, toteż rozwiązanie to funkcjonuje na zasadach licencji OpenHardware.
Konsekwencją tego faktu jest olbrzymia ilość różnego rodzaju wariantów Arduino
produkowanych czy to komercyjnie, czy to metodami domowymi na całym świecie.
Walorem tych alternatywnych rozwiązań niekoniecznie jest konkurencyjna cena;
częściej chodzi o rozszerzenie możliwości względem konstrukcji bazowej, jak np.
Zigduino, posiadające wbudowany interfejs bezprzewodowy XBee czy Illuminato
Genesis, konkurencyjny względem Duemillanove dzięki swoim 64 kB pamięci oraz
42 wejściom/wyjściom (dopiero Arduino serii Mega podbiło tu znacznie standard
oferując nie tylko 256 kB pamieci w wersji mega 2560 ale także zestaw 16 wejść
analogowych oraz 54 wejścia cyfrowe w różnej konfiguracji). Wśród „klonów“
znajdujemy także konstrukcje kompaktowe, czasem nawet mniejsze od oryginalnych
Mini czy Fio. Do najpopularniejszych przykładów należą tu Boarduino, Modified Pico
czy Femtoduino – bazujący na zgodnym z ATmega328p układzie QFN32 kontroler
wielkości... paznokcia!
________________________
Uwaga! W dalszej części opisu pracy z kontrolerem Arduino wszystkie przykłady,
rozwiązania oraz szczegóły techniczne odnosić się będą do modelu Arduino Uno,
chyba, że zostanie wyraźnie zaznaczone, iż jest inaczej. W zdecydowanej większości
zastosowań Arduino Uno zgodne jest w dół ze wszystkimi modelami linii
podstawowej (NG+, Diecimilla, Duemillanove) oraz, przynajmniej co do zgodności na
poziomie oprogramowania, ze wszystkimi innymi kontrolerami. Arduino Mega (w tym
Mega 2560), jako układowi o rozszerzonych możliwościach poświęcony zostanie
osobny rozdział.
7
3. Łyk technologii
3.1. Wejścia, wyjścia itp.
Charakter tej pracy (szczęśliwie) nie wymaga analizowania struktury nalutowanych
na płytce Arduino komponentów, ich właściwości elektrycznych oraz funkcji
w strukturze całej konstrukcji. Znacznie ważniejszym dla użytkownika Arduino,
który nie będąc z zawodu inżynierem elektronikiem, ma jednak jako takie pojęcie
o elektryce, oraz podstawach fizyki i informatyki, przede wszystkim zaś chciałby
zastosować ten kontroler w działaniach kreatywnych, będzie zapoznanie
się z funkcjonalnością Arduino, a konkretnie co i jak możemy do niego podłączyć,
by uzyskać satysfakcjonujący rezultat.
3.1.1 Wejścia analogowe
Typowe Arduino posiada 6 wejść analogowych (Arduino Mega ma ich 16; niektóre
„klony“ mogą też charakteryzować się inną ilością wejść), przyjmujących napięcie
w zakresie od 0 do +5V, a więc w zakresie typowym dla większości podzespołów
elektronicznych. Konwerter analogowo-cyfrowy Arduino pracuje w rozdzielczości 10bitowej, co oznacza, że wartości na wejściu analogowym reprezentowane są przez
liczby w zakresie 0–1023. Warto nadmienić, iż choć w obecnej wersji wejścia
analogowe zabezpieczone są, do pewnego pułapu tolerancji, przed przepięciami
oraz zwarciami, obciążanie wejść Arduino wyższymi napięciami może doprowadzić
do spalenia układu. W przypadku wejść analogowych istotna jest nie tylko wielkość
napięcia ale także pozytywna polaryzacja. Wejście nie reaguje poprawnie na
napięcia ujemne (a jeśli nawet, to najczęściej uszkodzeniem układu), tak więc
w przypadku podłączania urządzeń audio typu mikrofon, działających w zakresie
symetrycznym od wartości ujemnej do dodatniej napięcia (np. -2.5V do +2.5V) należy
pomiędzy nózkę sygnałową takiego urządzenia a wejście analogowe Arduino
wstawić odpowiedni opornik lub potencjometr by odpowiednio przesunąć tzw.
DC offset sygnału w stronę wartości dodatnich.
Do wejść analogowych podłączyć można takie urządzenia jak: fotorezystory,
potencjometry, analogowe (napięciowe) czujniki temperatury, ruchu, nacisku
(pressure), zgięcia (flex), analogowe akcelerometry (czujniki przyspieszenia)
oraz wiele innych urządzeń pracujących w zakresie napięć od 0 do +5V.
Urządzenia pracujące w innym zakresie napięć (np. mikrofony elektretowe)
mogą zostać podłączone po zastosowaniu odpowiedniego układu
wzmacniającego/redukującego napięcie wyjściowe tych urządzeń.
3.1.2. Wejścia/wyjścia cyfrowe
Każdy spośród 14 wyprowadzeń cyfrowych Arduino może być „zaprogramowany“
jako wejście lub wyjście. Dodatkowo niektóre wyprowadzenia (różnie w zależności od
modelu Arduino) posiadają możliwość przyjmowania lub wysyłania sygnały PWM,
dzięki czemu możliwe jest zastosowanie samego Arduino bez specjalnych nakładek,
aczkolwiek nie bez pomocy kilku/kilkunastu prostych elementów elektronicznych,
jako urządzenia sterującego silnikami czy prostego syntezatora.
Do wyprowadzeń cyfrowych, po ustawieniu ich jako wejścia, podpiąć możemy
wszelkie tranzystorowe lub diodowe układy pomiarowe, w tym fotodiody, odbiorniki
8
IR, czujniki ruchu, ultradzwiękowe czujniki zbliżeniowe (podobne do czujników
parkowania montowanych w samochodach), włączniki typu switch lub button, bramki
inne układy logiczne działające w standardzie TTL.
Do wyprowadzeń cyfrowych ustawionych jako wyjścia podłączyć możemy zwykłe
diody, zegary cyfrowe, dowolne inne urządzenia sterowane cyfrowym sygnałem TTL,
a do wyjść typu PWM – w przypadku Arduino Uno są to wyprowadzenia 3, 5, 6 oraz
9 do 11 – głośniczki (tzw. beepery lub buzzery) w celu otrzymania dźwięku
generowanego bezpośrednio przez Arduino.
Warto wiedzieć, iż cyfrowe piny 0 i 1 są na stałe sprzężone z szyną RX i TX portu
szeregowego Arduino, co w praktyce oznacza, że jeśli Arduino jest podłączone do
komputera przez dowolny port szeregowy, względnie sprzężone z innym
urządzeniem typu shield piny 0 i 1 blokowane są na potrzeby dwukierunkowej
transmisji szeregowej pomiędzy Arduino a urządzeniem peryferyjnym i jako takie,
nawet jeśli nie obsadzone, nie mogą być wykorzystane jako cyfrowe wejścia wyjścia.
3.1.3 port szeregowy USB
Służy do transmisji danych pomiędzy komputerem a Arduino. W obecnej wersji
Arduino port nie wymaga specjalnych sterowników po stronie komputera; jest
automatycznie rozpoznawany przez większość oprogramowania działającego
w takich systemach jak Windows czy MaxOS. Komunikacja odbywa
się dwukierunkowo. Transmisję z komputera do Arduino najczęściej stosuje się
w celu załadowania programu dla procesora ATmega napisanego w specjalnej wersji
języka Wiring w edytorze Arduino zainstalowanym w komputerze. Z kolei dane
z Arduino do komputera wysyłane są najczęściej w wyniku działania załadowanego
do Arduino programu. Dane te pochodzące z analizy (względnie przetworzenia)
sygnałów pojawiających się na wejściach analogowych i cyfrowych Arduino stanowią
podstawę interakcji w wielu projektach z wykorzystaniem Arduino i komputera.
Ponadto port szeregowy służyć może także jako źródło zasilania Arduino.
3.1.4 Wejścia wyjścia napięciowe
Arduino dysponuje dwoma wyprowadzeniami, na których podawane jest napięcie
o stałej wartości odpowiednio +3,3V oraz +5V. Napięcie to użyte może być do
zasilania podpiętych do Arduino czujników (np. fotorezystorów) względnie urządzeń
peryferyjnych lub urządzeń, którymi Arduino steruje (np. silniczek elektryczny).
Na płytce Arduino znajdziemy także 3 wyprowadzenia GND, do których można
podpiąć masę wszelkich urządzeń i czujników podłączane do Arduino. Ponadto
Arduino posiada wyprowadzenie Vin, za pomocą którego możemy zasilać Arduino,
jeśli jest montowane jako komponent większego systemu zasilanego z zewnątrz oraz
standardową wtyczkę zasilacza niskonapięciowego, do którego podpiąć możemy taki
właśnie zasilacz o napięciu 5V, w przypadku, gdy Arduino ma działać samodzielnie,
a więc także bez podłączenia go z komputerem przez kabel USB, z którego w takim
przypadku byłoby zasilane.
3.1.5 Przycisk Reset
9
Na płytce Arduino znajduje się w widocznym miejscu przycisk Reset. Obecnie jego
zastosowanie jest mocno ograniczone, aczkolwiek w starszych wersjach (np. NG),
konieczne było wciśnięcie tego przycisku za każdym razem tuż przed transmisją
nowego programu z komputera. W nowszych wersjach Arduino reset wykonywany
jest na zlecenie komputera automatycznie przed każdym uploadem. Sytuacje,
w których przycisk Reset może być przydatny związane są przede wszystkim
z niewłaściwym podpięciem do Arduino komponentów projektowanego systemu.
W szczególności w przypadku podania na dowolne z wejść napięcia wyższego niż
5V lub spowodowanie zwarcia pomiędzy pinem napięciowym, a masą Arduino może
spowodować jego zawieszenie. Trudno jest natomiast zawiesić Arduino poprzez
nieprawidłowy kod programu, gdyż po pierwsze język programowania Wiring jest
bardzo prosty i przejrzysty i zawiera niewiele możliwości wprowadzenia procesora
w błąd, po drugie zaś kod programu kompilowany jest już w trakcie transmisji,
a większość błędów wykrywana już na tym etapie prowadząc do przerwania
transmisji kodu i zablokowania jego wykonania w Arduino.
3.1.6. Diody kontrolne LED
Arduino posiada 4 diody kontrolne LED: ON, L, TX oraz RX. Dioda ON świeci się
kiedy Arduino jest zasilane z dowolnego ze źródeł (z komputera, z zasilacza
względnie z innego urządzenia wpiętego w złącze Vin Arduino). Dioda ON świecić
będzie nawet, jeśli do procesora Arduino nie został załadowany żaden program,
a więc samo urządzenie ani nie odbiera ani nie wysyła żadnych danych.
Dioda „L“ sprzężona jest z cyfrowym wyprowadzeniem nr 13 w Arduino. Jeśli na tym
wyjściu ustawiony jest poziom wysoki (cyfrowa „1“), dioda świeci. W przeciwnym
wypadku dioda pozostaje zgaszona. Najprostszy, podstawowy program dla Arduino
(omówiony w następnym rodziale) polegający na zaświeceniu diody połączonej
z wyprowadzeniem nr 13 w Arduino powyżej modelu NG (który nie posiadał diody
„L“) nie wymaga wpięcia diody zewnętrznej – po załadowaniu program będzie
odpowiednio zapalał i gasił diodę „L“ nalutowaną na płytce Arduino.
Diody RX i TX migają za każdym razem kiedy odbywa się transmisja danych do (RX)
lub z (TX) Arduino poprzez złącze USB lub cyfrowe wyprowadzenia 0 i 1.
Obserwacja tych właśnie diod jest najprostszym sposobem na sprawdzenie, czy taka
transmisja się odbywa, bez sięgania do bardziej skomplikowanych procedur typu
skanowanie portu szeregowego komputera.
4. Przygotowanie składników
Zanim zajmiemy się realizacją najprostszego przepisu na interakcję z użyciem
Arduino, warto wiedzieć, jakie elementy systemu – tak co do sprzętu jak i co do
oprogramowania – powinniśmy zgromadzić. Oto wykaz najbardziej podstawowych.
4.1. Tzw. hardware
Przede wszystkim Arduino. W zależności od założeń projektu będzie to standardowa
płytka (w tym wypadku Uno), lub płytka o rozszerzonych możliwościach (np. Mega),
względnie wersja zminiaturyzowana (np. Nano) albo pozwalająca się łatwo wszyć
(LilyPad) i ukryć w materiale z którego skonstruowana jest przygotowywana
instalacja. Konieczny będzie także kabel USB, typowy (tzw. A-B) w przypadku
10
standardowych kontrolerów lub A-miniB w przypadku kontrolerów zminiaturyzowanych. Uwaga: w niektórych przypadkach (np. LilyPad) należy także dokupić
specjalny interfejs USB, gdyż sam kontroler nie jest wyposażony w takie złącze.
Jeśli po wysłaniu kodu programu Arduino ma działać niezależnie od komputera,
będziemy potrzebowali zasilić je z zewnętrznego zasilacza 5V lub z baterii (jeśli
dana płytka dopuszcza możliwość zasilania z baterii).
Powyższe to zestaw podstawowy, żeby jednak nasz projekt był w jakimkolwiek
znaczeniu tego słowa „interaktywny“, potrzebujemy jeszcze co najmniej dwóch
elementów: urządzeń wejściowych (np. fotorezystorów) oraz urządzeń wyjściowych
(np. diod, głośniczków albo... komputera). Tu zestaw komponentów może być
nieograniczony, względnie ograniczony jedynie naszą fantazją i wiedzą.
Niekiedy dołączenie danego komponentu wejściowego lub wyjściowego wymaga
użycia dodatkowych elementów elektronicznych – oporników, kondensatorów,
tranzystorów itp. Należy zatem dokładnie przestudiować opis projektu zanim
zabierzemy się za jego instalację. Czasem brak prostego opornika czyni cały system
bezużytecznym, innym razem brak odpowiedniego składnika lub niewłaściwe
dobranie jego parametrów może doprowadzić do uszkodzenia Arduino. Oczywiście
zamiast bawić się w elektronika-amatora, skorzystać możemy z licznych gotowych
konstrukcji oferowanych w internecie (tzw. shields), jednakowoż w pewnych bardzo
prostych zastosowaniach nadal najbardziej opłacalne a czasem jedyne możliwe są
rozwązania wykonane metodą chałupniczą, w innych zaś dostępność i cena
peryferiów jest często czynnikiem bardziej deprymującym niż konieczność sięgniecia
po cynę i lutownicę.
Na koniec – aby zbudować system interaktywny potrzebować będziemy nie tylko
cegieł ale i zaprawy. Na etapie konstruowania bardzo przyda się tzw. płytka
prototypowa (ang. breadboard) – plastikowa podstawka z licznymi otworami,
wewnątrz których znajduje się materiał przewodzący uformowany w rodzaj
minizacisku. Kabel włożony w taki otwor nie wypadnie samoczynnie (choć relatywnie
łatwo będzie się dał wyciągnąć).
Płytka prototypowa (Breadboard)
Poszczególne otworki połączone są ze sobą w obwód rzędami lub kolumnami,
co daje możliwość spięcia w szereg kilku do kilkunastu elementów. Aby pracować
z płytką prototypową najczęściej stosujemy zestawy specjalnie przygotowanych
zaizolowanych krótkich przewodów jednożyłowych (od kilkunastu do kilkudziesięciu
milimetrów długości), z izolacją zdjętą na obu końcach na długości do 2-3 mm.
Przydać się mogą także zestawy tzw. jumperów (zwartych w pary lub większe układy
pinów) oraz krótkie kable zakończone klemami, tzw. krokodylki. Nieocenione
11
w precyzyjnym montażu okażą się małe kombinerki oraz pinceta, a do przycinania
kabli – obcążki.
Narzędzia oraz elementy montażowe a także miernik uniwersalny
Do testowania układu lub poszczególnych jego połączeń najlepiej użyć
uniwersalnego miernika prądu. Idealnie, jeśli taki miernik posiadać będzie
co najmniej funkcję pomiaru oporu w zakresie od 0 do 100 kOhm oraz napięcia
prądu stałego w zakresie od 0 do +12V.
Na tym etapie nie jest konieczne użycie lutownicy, gdyż większość elementów da się
zainstalować w płytce prototypowej bez lutowania. Nierzadko jednak po stworzeniu
i przetestowaniu prototypu będziemy chcieli umieścić go w zdecydowanie bardziej
stabilnym otoczeniu, tak by był przenośny, a zwykłe pociągnięcie za kabel nie
dekonstruowało całej instalacji. W takiej sytuacji najskuteczniejszym rozwiązaniem
będzie przeniesienie prototypu na miedzianą płytkę montażową, gdzie każdy
z elementów musi zostać wlutowany. W tym skrypcie zatrzmamy się jednak na etapie
budowania istalacji prototypowych, zatem kurs lutowania nie będzie przedmiotem
kolejnych jego rozdziałów.
Tworząc system interaktywny na bazie Arduino; obojętnie czy prototypowy
czy lutowany, należy pamiętać, iż płytka z kontrolerem nie jest w żaden sposób
izolowana ani zabezpieczona. Należy pamiętać, iż napięcie elektrostatyczne, które
często zbiera się na powierzchni naszych ubrań oraz skóry może być bardzo
niebezpieczne dla elementów elektronicznych. W związku z tym, w miarę możliwości
należy unikać dotykania gołymi rękami zarówno elementów nalutowanych na płytkę
Arduino, samej płytki, jak i połączonych ze znajdującymi się na niej wyprowadzeniami
innych elementów tworzonego przez nas systemu. Ponadto płytki z kontrolerem nie
wolno kłaść na powierzchni przewodzącej (na przykład na metalowym lub mokrym
blacie). Zwarcie znajdujących się na spodniej stronie płytki lutowań może
doprowadzić do zniszczenia kontrolera.
Z logicznego punktu widzenia komputer znajduje się poza „obowiązkowym zestawem
podstawowym“, jako urządzenie potrzebne do przygotowania kodu programu dla
Arduino. Komputer z pewnością nie jest konieczny by stworzony na bazie Arduino
system interaktywny działał i był w pełni funkcjonalny, jednak byłoby niezmiernie
trudno „zasilić“ odpowiednim kodem programu znajdujący się na płytce Arduino
mikroprocesor inaczej, jak przygotowawszy go w specjalnym edytorze na ekranie
komputera, by następnie załadować go poprzez złącze USB do Arduino. W takim
kontekście komputer spełnia przede wszystkim rolę GUI (graphic user interface),
choć należy to podkreślić, iż wiele, jeśli nie większość istniejących projektów
12
interaktywnych zbudowanych na bazie Arduino wykorzystuje komputer jako aktywny
składnik systemu.
4.2. Tzw. software
Jeśli nie wynika to jednoznacznie z prezentacji Arduino znajdującej się na początku
tego skryptu, najwyższa pora powiedzieć to jasno i wyraźnie: Arduino bez
oprogramowania jest jedynie kawałkiem elektronicznego złomu. Przyniesione prosto
ze sklepu i podłączone czy to do komputera czy czujników nie będzie ani grało ani
świeciło. Arduino nie jest wyspecjalizowanym urządzeniem typu SensorBox czy
Eobody, które posiada określony zestaw funkcji działających natychmiast
po podłączeniu urządzenia do prądu. Arduino to uniwersalny kontroler, a jego
uniwersalność jest zarówno jego zaletą (bo możemy go zaprząc do dowolnej niemal
cyber-roboty) jak i jego zmorą (bo, żeby go do czegokolwiek zmusić, trzeba mu
to bardzo dokładnie wytłumaczyć w jego własnym języku.
4.2.1 Kontekst
Podstawowym językiem programowania Arduino jest... Arduino, będący derywatem
zestawu poleceń języka Wiring (http://wiring.org.co/), mających zastosowanie
w specyficznym środowisku kontrolera. Bazą dla języka Wiring było C/C++, stąd
powinowactwo między tym ostatnim, a językiem programowania Arduino jest
niezwykle duże. Innym środowiskiem programistycznym, do którego odwołuje się
Wiring jest Processing, mający znacznie szersze zastosowanie w przypadku
tworzenia interaktywnych systemów graficznych. Kod języka Processing, bez
zastosowania specjalnych bibliotek (np. Firmata) nie jest zrozumiały dla kompilatora
Arduino, programowanie kontrolera bezpośrednio w tym języku nie jest zatem
możliwe. Rozbudowane funkcje dotyczące przetwarzania grafiki, w jakie wyposażony
jest Processing nie pozostają jednak poza zasięgiem Arduino. Istnieje co najmniej
kilka sposobów na sprzęgnięcie tych dwóch systemów; co najmniej jeden z tych
sposobów omówiony zostanie w dalszej części skryptu.
4.2.2. Oprogramowanie dla Arduino
Wracając jednak do podstaw, programem który z całą pewnością należy pobrać
z internetu i zainstalować na komputerze, z którego chcielibyśmy ładować
przygotowane aplikacje dla Arduino powinien być edytor Arduino dostępny
pod adresem: http://arduino.cc/en/Main/Software
Instalacja i uruchamianie tego programu jest niezwykle prosta a wyjaśnienie
wszystkich związanych z tym zagadnieniem problemów omówione zostało na
w/w stronie. Dlatego też w dalszej części skryptu przyjmujemy założenie, że program
ów został pomyślnie zainstalowany i poprawnie działa na danym komputerze.
Wyjaśnienia może wymagać jedynie sposób, w jaki należy skomunikować edytor
Arduino z samym kontrolerem, w celu transmisji doń przygotowanego w edytorze
programu. Aby tego dokonać, należy sprawdzić czy w menu Tools/Serial Port
edytora Arduino wybrany został port, do którego podłączony jest kontroler, następnie
z menu Tools/Board wybrać właściwy typ kontrolera, by w końcu z menu File wybrać
funkcję Upload to I/O Board, która spowoduje wysłanie kodu programu do kontrolera.
13
Jeśli Arduino podłączone zostało prawidłowo, wszystkie w/w opcje wybrane wg stanu
faktycznego, a kod nie zawiera błędów, transmisja kodu powinna zakończyć
się wyświetleniem komunikatu Done Uploading w dolnej części okna edytora. Od tej
pory Arduino automatycznie zaczyna wykonywać wysłany kod. Niektóre starsze
wersje Arduino wymagały wciśnięcia przycisku „reset“ na płytce Arduino tuż przed
transmisją kodu programu z komputera oraz tuż po niej, w celu uruchomienia
programu. W obecnych wersjach kontrolera załadowany program automatycznie
jest uruchamiany natychmiast po zakończeniu procesu ładowania go do pamięci
kontrolera oraz automatycznie uruchomi się za każdym razem, kiedy podłączymy
Arduino do zasilania. Ponieważ Arduino wyposażone jest w pamięć RAM typu
FLASH, kod programu przechowywany jest w Arduino nawet po odłączeniu napięcia.
Nie jest więc konieczne ładowanie programu za każdym razem, kiedy podłączymy
Arduino do raz stworzonego systemu interaktywnego. Pewnym organiczeniem jest
natomiast to, że Arduino może w danym momencie przechowywać wyłącznie jeden
kod programu. Nie ma możliwości składowania w nim kilku różnych niezależnie
działających programów i uruchamiania ich osobno czy po kolei. Za każdym razem
zmiana funkcjonowania Arduino musi być poprzedzona załadowaniem nowego kodu.
Oczywiście ze względu na istnienie w języku Arduino konstrukcji warunkowych,
można tak napisać program dla kontrolera, by w zależności od zaistnienia różnych
czynników zewnętrznych (np. wciśnięcia podłączonego do wejścia cyfrowego
Arduino włącznika typu switch) wykonywana była jedynie dana część kodu.
Wracając na chwilę do procedury ładowania kodu z edytora do Arduino, należy
dodać, iż nieprawidłowy z punktu widzenia składni kod zostanie zdyskwalifikowany
już podczas ładowania. Arduino zamiast komunikatu Done uploading wyświetli
nazwę błędu, a w czarnym polu na samym dole okna jego bardziej szczegółowy opis.
Ponadto nieprawidłowa linia kodu programu, zostanie podświetlona na żółto.
14
4.2.3. Oprogramowanie dla komputera
Jeśli projekt, nad którym pracujemy zakłada interakcję pomiędzy Arduino
a komputerem, winniśmy rozważyć wybór odpowiedniego oprogramowania, które
uruchomione w komputerze, odbierać będzie płynące z Arduino dane, przetwarzać
lub na ich podstawie wykonywać określone działania. Być może zaistnieje także
sytuacja, w której będziemy chcieli skomunikować komputer z Arduino w kierunku
przeciwnym, tzn. wysyłać za pośrednictwem wybranego przez nas programu
komputerowego, dane do Arduino. W obu tych przypadkach posłużyć się musimy
programem, który potrafi komunikować się z urządzeniami zewnętrznymi za
pośrednictwem portów szeregowych komputera, a dodatkowo komunkacja ta może
odbywać się na zupełnie podstawowym poziomie, z pominięciem jakichkolwiek
sterowników (innymi słowy, powinniśmy mieć możliwość odbioru danych w postaci
szeregu bajtów bezpośrednio z bufora pamięci portu szeregowego, względnie
możliwość zapisywania bajtów danych bezpośrednio do bufora wyjściowego tego
portu). Należy przy tym pamiętać, że połączenie bezprzewodowe za pośrednictwem
Bluetooth odbywa się także na zasadzie zapisu/odczytu do portu szeregowego,
w przypadku zatem pary urządzeń komputer-ArduinoBT zasada działania będzie
taka sama. Wyjątkiem od powyższego może być współpraca komputera z Arduino
wyposażonym w Ethernet Shield i podłączonym kablem internetowym z komputerem.
Tu z kolei powinniśmy posłużyć się oprogramowaniem, które pozwala na
komunikację komputera z urządzeniami zewnętrznymi za pośrednictwem protokołu
TCP lub UDP.
4.2.3.1. MaxMSP
Wykładając od razu karty na stół, powiemy, iż będzie to główny program do
realizowania zadań komputera w projektach interaktywnych opisywanych w tym
skrypcie. Posiada wszystkie wymagane właściwości, dzięki którym współpraca
z Arduino może przebiegać na wszystkich platformach i w bardzo szerokim zakresie.
Podstawowym obiektem obsługującym komunikację poprzez port szeregowy jest
w MaxMSP obiekt [serial]. Z kolei w przypadku komunikacji za pośrednictwem
internetu, transmisję pakietów danych zapewnia para obiektów [udpsend]
i [udpreceive]. Ze względu na to, iż w dalszych rozdziałach większość przykładów
realizowanych będzie właśnie w MaxMSP, na tym zakończymy prezentację tego
programu w tej części skryptu.
4.2.3.2. PureData
Jest to środowisko pod wieloma względami podobne do MaxMSP, toteż wiele
przykładów zrealizowanych w tym pierwszym będzie się dało „przepisać“ i bez
żadnych modyfikacji uruchomić w PureData. Jedną z ważniejszych różnic pomiędzy
zastosowaniem PureData i MaxMSP w pracy z Arduino będzie nazewnictwo
niektórych istotnych dla projektu obiektów. Już na samym początku napotykamy ten
problem, gdyż podstawowy obiekt służący do komunikacji poprzez port szeregowy
nazywa się w PureData [comport]. Parametry i składnia tego obiektu są natomiast
dosyć zbieżne z tymi, które akceptuje obiekt [serial] w MaxMSP. Natomiast
komunikację przez internet uzyskujemy za pomocą pary obiektów [netsend 1]
i [netreceive 1], przy czym parametr „1“ otwiera komunikację UDP (brak parametru =
komunikacja TCP).
15
4.2.3.4 Processing
Zgodnie z tym, co zostało napisane we wstępie do tego rozdziału, istnieje wiele
zbieżności pomiędzy językiem programowania Processing, a językiem jakim
posługujemy się programując Arduino. Najważniejszą wspólną cechą jest
z pewnością to, iż oba te środowiska specjalizują się w tym samym – projektowaniu
systemów interaktywnych. Istnieje relatywnie łatwy sposób komunikacji pomiędzy
programem uruchomionym w kontrolerze Arduino, a programem napisanym w języku
Processing, działającym na komputerze sprzęgniętym poprzez port szeregowy
z Arduino. Bardzo prosty przykład takiej interakcji zamieszczamy poniżej. Składa się
on z:
1) programu napisanego w języku Arduino, odczytującego wartość podawaną przez
czujnik (w tym wypadku fotorezystor) wpięty w wejście analogowe A0 Arduino:
void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.println(analogRead(A0));
delay(10);
}
2) programu napisanego w języku Processing i uruchomionego na komputerze,
pobierającego wartości przychodzące na port szeregowy komputera
i wyświetlającego w oknie monitora słupki o wysokości równej pobieranym
wartościom:
import processing.serial.*;
Serial myPort;
int xPos = 1;
void setup ()
{
size(400, 300);
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil('\n');
background(0);
}
void draw () {}
void serialEvent (Serial myPort)
{
String inString = myPort.readStringUntil('\n');
if (inString != null)
{
inString = trim(inString);
float inByte = float(inString);
inByte = map(inByte, 0, 1023, 0, height);
stroke(127,34,255);
line(xPos, height, xPos, height - inByte);
if (xPos >= width) { xPos = 0; background(0); }
else { xPos++; }
}
}
16
3) układu elektrycznego składającego się z połączenia fotorezystora z wejściem
analogowym A0 Arduino przy zastosowaniu właściwego opornika (w tym przypadku
3 kOhm) korygującego napięcie w układzie:
Rezultat działania tego prostego projektu zobaczyć można na poniższej ilustracji
będącej zrzutem okna monitora programu Processing:
Język Processing w połączeniu z możliwościami Arduino jako wielofuncyjnego
kontrolera analogowo-cyfrowego daje nieskończoną wręcz ilość możliwości
tworzenia systemów interaktywnych, w szczególności w dziedzinie sztuk wizualnych.
W dalszej części skryptu skupimy się jednak przede wszystkim na podstawach
interakcji w sztuce ze szczególnym uwzględnieniem działań muzycznych. Do języka
Processing wrócimy jeszcze na końcu skryptu. Tam też znaleźć będzie można
bardziej wyczerpujące omówienie powyższego przykładu.
_______________
Jest jeszcze wiele innych programów, które w różnym stopniu nadawać by się mogły
do stworzenia systemu interaktywnego na bazie tandemu komputer–Arduino. Trudno
ocenić, który z nich najlepiej do tego się nadaje. Najważniejsze jest to, czy program,
który wybierzemy pozwala na bezstratną i obustronną transmisję danych pomiędzy
Arduino a komputerem oraz czy posiada wszystkie funkcje pozwalające na pełną
i bezkompromisową realizację założonych w projekcie interakcji.
17
II. Oswajanie Arduino
1. „Hello, World!“ dla Arduino
Tak, jak pierwszym programem, jaki młodzi adepci programowania piszą w języku C,
Basic czy Pascal jest prosta procedura wyświetlająca na ekranie monitora tekst
„Hello, World!“, tak w przypadku Arduino pierwszym krokiem w stronę
programowania jest procedura powodująca miganie diody „L“ na płytce kontrolera.
Program ten znajduje się wśród przykładów dostarczanych wraz z edytorem Arduino
i można go wywołać z menu File/Examples/1.Basics/Blink. Zanim jednak zajmiemy
się nim w sposób równie naukowy, co kreatywny...
1.1. Kilka słów na temat języka, zanim zaczniemy się nim posługiwać
Co zostało już w niniejszym skrypcie powiedziane, język programowania Arduino
ma wiele cech wspólnych z językiem C/C++. Większość poleceń języka Arduino
pochodzi wprost z języka C/C++ i ma podobną składnie oraz znaczenie. Podobnie
jak w języku C, można na początku kodu zadeklarować za pomocą polecenia
#include dołączenie określonych bibliotek, które poszerzają zasób poleceń
o dodatkowe, często wyspecjalizowane procedury. Np. biblioteka <Ethernet.h>
dodaje m.in. polecenie connect() pozwalające na połączenie się ze zdalnym
urządzeniem w sieci o określonym IP oraz porcie. Podobnie, jak w języku C,
na początku kodu programu (lub jego samodzielnej części) powinny znajdować
się definicje stałych i zmiennych, natomiast w dalszej części definiuje się funkcje,
na które składać się będzie cały program. Nieco inaczej niż w języku C, konstrukcja
programu w języku Arduino jest ściśle określona i ogranicza się do dwóch funkcji:
1) setup() – wykonywanej jeden raz na początku programu, zawierającej najczęściej
procedury inicjujące pewne komponenty systemu (na przykład otwarcie portu
szeregowego wraz z ustaleniem szybkości transmisji danych za jego
pośrednictwem);
2) loop() – wykonywanej w cyklu ciągłym procedury głównej. Mimo, iż funkcja loop()
jest z założenia wykonywana w pętli, zestaw poleceń języka Arduino, dzięki
instrukcjom warunkowym oraz poleceniom związanym z czasem, pozwala
na zatrzymanie lub zaburzenie powtarzalności poleceń, na które składa się funkcja
loop().
Ostatnim elementem języka programowania Arduino, na jaki warto zwrócić uwagę,
jest możliwość umieszczania komentarzy w kodzie programu. Komentarze nie
dłuższe niż 1 wiersz tekstu umieszczamy poprzedzając je podwójnym znakiem
ukośnika (//), natomiast komentarze wielowierszowe obejmujemy rodzajem
„nawiasów“, z czego nawias otwierający składa się z ukośnika i gwiazdki (/*),
a zamykający – z tych samych znaków, jednak w odwrotnej kolejności (*/).
Ta bardzo przydatna funkcja pozwala nie tylko na opisanie poszczególnych
fragmentów kodu dla podniesienia ich czytelności, ale ma także doskonałe
zastosowanie w dydaktyce, pomaga bowiem na „żywym organizmie“ programu
18
wskazywać istotne dla jego przebiegu miejsca. W dalszej części skryptu tam,
gdzie będzie to możliwe, kod programu omawiany będzie właśnie za pomocą
umieszczanych w nim komentarzy.
Omawianie wszystkich poleceń języka Arduino nie jest i nie może być przedmiotem
tego skryptu, zakładamy więc domyślnie, w dalszej jego części, iż czytelnik
przestudiował już (lub studiuje równolegle z lekturą niniejszego skryptu) znajdujący
się w internecie pod adresem: http://arduino.cc/en/Reference/HomePage podręcznik
szczegółowo opisujący wszystkie główne polecenia Arduino oraz te, które zawarte są
w oficjalnych bibliotekach Arduino dołączanych za pomocą polecenia #include.
1.2. Migająca dioda
Oryginalny program „Blink“ z zestawu przykładów edytora Arduino wygląda
następująco:
/*
Blink
Turns on an LED on for one second, then off
for one second, repeatedly.
This example code is in the public domain.
*/
void setup() {
// initialize the digital pin as an output.
// Pin 13 has an LED connected on most Arduino
boards:
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
//
//
//
//
set the LED on
wait for a second
set the LED off
wait for a second
Zanim przejdziemy do jej analizy – mała uwaga techniczna dotycząca edytora
Arduino. Na załączonym powyżej zrzucie ekranu łatwo można dostrzec, iż
poszczególne elementy kodu programu mają różny kolor. To także bardzo przydatna
cecha, pozwalająca już na pierwszy rzut oka odróżnić nazwy funkcji języka Arduino
(wyświetlane w kolorze pomarańczowym), nazwy predefiniowanych stałych (kolor
niebieski), pozostały tekst kodu programu, taki jak nawiasy, liczby, operatory czy
zmienne (w kolorze czarnym) i w końcu komentarze, wyświetlane zawsze na szaro.
Tego typu konwencji nie będziemy stosować w listingach programu (drukowanych
czcionką Courier w szarych ramkach), jednak dla polepszenia czytelności
komentarze w listingach będą podawane czcionką pochyłą i po polsku.
19
A oto zwięzła analiza kodu programu „Blink“:
/* funkcja setup() wykonywana jednokrotnie na początku.
W tym przypadku funkcja ustawia cyfrowe wyprowadzenie nr 13 jako wyjście
*/
void setup() {
pinMode(13, OUTPUT);
}
/* funkcja loop() powtarzana tak długo, jak długo program znajduje się w pamięci Arduino a
samo Arduino podłączone jest do zasilania
*/
void loop() {
digitalWrite(13, HIGH);
//
wyprowadzeniu pojawia się napięcie
delay(1000);
//
digitalWrite(13, LOW);
//
wyprowadzeniu pojawia się napięcie
delay(1000);
//
ustawia cyfrowe wyprowadzenie nr 13 w stan „wysoki“ (na
dodatnie, co powoduje zaświecenie się diody „L“)
linia opóźniająca. Proces czeka 1000 ms czyli 1 sekundę
ustawia cyfrowe wyprowadzenie nr 13 w stan „niski“ (na
zerowe, co powoduje zgaszenie się diody „L“)
linia opóźniająca. Proces czeka 1000 ms czyli 1 sekundę
}
Powyższy program wprowadza, oprócz znanych już elementów – funkcji setup()
i loop() dwa typowe polecenia języka Arduino: digitalWrite(x,y[LOW,HIGH])
ustawiającej stan niski lub wysoki y na cyfrowym wyjściu (wyprowadzeniu) x, oraz
delay(t) zatrzymującym wykonywanie jakichkolwiek procesów do upłynięcia czasu t,
podanego w milisekundach. Ponadto możemy tu znaleźć funkcję
pinMode(x,y[INPUT,OUTPUT]), definiującą na czas działania programu, czy dany
cyfrowy pin Arduino będzie działał jako wejście czy wyjście. Jak to już wcześniej
zostało powiedziane, wszystkie cyfrowe wyprowadzenia Arduino mogą być
niezależnie konfigurowane jako wejścia lub wyjścia cyfrowe. W zależności od
ustawienia dany pin będzie – jako wyjście – pozwalał się ustawiać w stan wysoki
(odpowiednik „1“ w kodzie binarnym) lub niski (binarne „0“) albo też będzie – jako
wejście – oczekiwał pojawienia się na przyłączonym do niego układzie stanu
wysokiego lub niskiego. Ostatnim nowym elementem kodu jest wprowadzenie stałych
predefiniowanych. W powyższym programie takimi stałymi są: OUTPUT i HIGH oraz
LOW. Stałe predefiniowane mają swoje odpowiedniki w postaci wartości liczbowych.
Wpisanie zamiast digitalWrite(13, HIGH) polecenia digitalWrite(13, 1) da dokładnie
taki sam rezultat, jednak w pewnych zastosowaniach stałe predefiniowane znacznie
poprawiają czytelność kodu i wprowadzają pewną, jakże potrzebną logikę.
Przechodząc na chwilę do kwestii sprzętowych, warto podkreślić, iż powyższy
program nie tylko zapala i gasi diodę „L“ na płytce kontrolera, ale rzeczywiście podaje
i zeruje naprzemian napięcie na cyfrowym wyprowadzniu nr 13. Żeby to sprawdzić
najłatwiej jest użyć małej zwykłej diody LED, wsuwając jej dłuższą nóżkę w cyfrowe
wyprowadzenie nr 13, a krótszą w znajdujące się obok gniazdo GND:
20
Ćwiczenie 1
Spróbujmy teraz popracować nad kodem programu wprowadzając kilka drobnych
modyfikacji. Zacznijmy od bardzo prostego ćwiczenia, polegającego na dodaniu funkcji
zapalającej diodę wpiętą na przykład w wyprowadzenie nr 11. Uwaga: do prawidłowego
zamontowania drugiej diody w Arduino konieczne może się okazać zastosowanie płytki
prototypowej.
1.3. Podłączanie prostego sensora
Wiemy już jak w prosty sposób oprogramować wyjście Arduino. Spróbujmy zatem
zrealizować pierwszy projekt, którego zadaniem będzie pobieranie wartości z wejścia
analogowego. Polecenie języka Arduino, które zczytuje poziom napięcia na
wyprowadzeniu analogowym zwracając jego wartość w postaci liczby z zakresu 0–
1023 to analogRead(). Oczywiście byłoby wskazane, by wartości zczytywane
z wejścia analogowego Arduino wyświetlane były na przykład na ekranie komputera.
Aby to umożliwić, powinniśmy do naszego programu wprowadzić jeszcze dwa
polecenia: wywoływane jednorazowo (zatem umieszczane wewnątrz funkcji setup()
polecenie Serial.begin(x), gdzie x jest prędkością transmisji danych portu
szeregowego wyrażoną w baudach (bitach na sekundę, inaczej bps). Polecenie
Serial.begin() otwiera port szeregowy, tzn. tworzy specjalny bufor w pamięci Arduino,
na który trafiać będą dane z portu szeregowego oraz inny, w którym zapisywane
będą dane do wysłania przez port szeregowy. Ponadto ustala dla danej transmisji
prędkość przesyłu danych. Prędkość ta nie jest wartością przypadkową. Złącza
szeregowe pracują jednej z kilkunastu predefiniowanych prędkości transmisji.
Prędkości poniżej 9600 baudów są już w zasadzie nieużywane. Powoli także
standardem minimum staje się prędkość jeszcze niedawno uznawana za
maksymalną, czyli 57600 (56 kbps). Pomiędzy tymi dwiema wartościami do wyboru
mamy jeszcze 14400, 19200, 28800 oraz 38400. Maksymalną prędkość transmisji,
jaką możemy zadeklarować dla Arduino Uno jest 115200 baudów.
Deklarując prędkość transmisji musimy pamiętać o kilku czynnikach. Pierwszym jest
przewidywana ilość danych, jakie w określonym czasie napisany przez nas program
będzie chciał wysłać przez port szeregowy. Należy pamiętać, iż prędkość transmisji
wyrażona w baudach odnosi się do ilości bitów przesyłanych na sekundę, podczas
gdy jedna, pojedyncza liczba reprezentowana może być przez kilka bajtów.
Przykładowo wartości liczbowe w zakresie 0-1023 wysyłane na port szeregowy
w postaci znaków ASCII reprezentujących poszczególne cyfry danej liczby, mogą
potrzebować, w górnej strefie skali, 4 bajtów na każdą wartość (np. liczba 1019 to
znaki ASCII: „1“, „0“, 1“, „9“ reprezentowane odpowiednio przez ośmiobitowe liczby
o wartościach: #049, #048, #049 #057). Do tego należy dodać bajt piąty będący
separatorem, tj. znakiem niebędącym cyfrą (dlaczego potrzebny jest separator,
wyjaśnimy dalej, analizując kod przygotowywanego właśnie programu). W sumie
więc dla transmisji pojedynczej liczby czterocyfrowej potrzeba 5*8=40 bitów. Tak
naprawdę potrzeba ich jednak nieco więcej, gdyż transmisja szeregowa
charakteryzuje się pewną redundancją potrzebną dla zachowania synchronizacji.
Jeśli nawet założymy, że liczba czterocyfrowa zamienia się w czasie transmisji
szeregowej na strumień 48 bitów, to przy prędkości 9600 baudów będziemy mogli
w ciągu jednej sekundy wysłać 200 takich wartości, a więc jedną liczbę co 5 ms. Dla
potrzeb poniższego przykładu jest to prędkość w zupełności wystarczająca.
21
Innym ważnym czynnikiem, o którym należy pamiętać, jest zgodność prędkości
transmisji pomiędzy nadajnikiem a odbiornikiem. Ponieważ zarówno Arduino jak
i komputer nie są w stanie automatycznie wykryć i ustawić się na prędkość
nadającego, toteż zadanie ustawienia i sprawdzenia czy prędkość transmisji
zadeklarowana w programie Arduino jest tożsama z prędkością odbioru danych
w komputerze spada na nas. Przejdźmy jednak do kolejnego zagadnienia.
Żeby wysłać z Arduino dane na port szeregowy nie wystarczy otworzyć go
poleceniem Serial.begin(). Sama transmisja odbywa się dzięki wprowadzeniu
polecenia Serial.print(s) lub Serial.println(s), które zapisuje do bufora wyjściowego
portu szeregowego ciąg bajtów odpowiadających kodom ASCII kolejnych znaków
symbolu s, będącego parametrem polecenia Serial.print(s). W przypadku polecenia
Serial.println(s) dodatkowo na końcu ciągu wysyłany jest tzw. znak końca linii (w
zależności od systemu jest to jeden lub dwa bajty o wartościach <CR> = #013 i <LF>
= #010).
Wiemy już wszystko o czytaniu wartości z wejścia analogowego Arduino, potrafimy je
także wysłać na port szeregowy. Czas zatem na kod programu:
void setup() {
// otworzenie portu szeregowego i ustawienie prędkości transmisji na 9600 baud
Serial.begin(9600);
}
void loop() {
Serial.println(analogRead(A0));
/* wartość zwracana przez polecenie analogRead(A0) staje się parametrem polecenia
Serial.println(), co w praktyce oznacza wysłanie liczby określającej wartość
napięcia na wejściu analogowym A0 na port szeregowy, a więc do komputera */
delay(10);
/* 10 ms opóźnienia zanim nowa wartość napięcia zostanie wysłana na port
szeregowy jest tu bardzo potrzebna. Po pierwsze dla stabilizacji układu
konwertera analogowo-cyfrowego na wejściu analogowym, po drugie zaś, by
zredukować ilość danych na sekundę wysyłaną przez port szeregowy */
}
Program już mamy. Potrzebny jeszcze układ z czujnikiem. Do tego eksperymentu
użyjmy bardzo prostego elementu – fotorezystora. Charakteryzuje się on zmienną
rezystancją (opornością) odwrotnie proporcjonalną do natężenia światła padającego
na element światłoczuły. Fotorezystor łączymy z Arduino w taki sposób, iż jedną jego
nóżkę wpinamy w wyprowadzenie GND, drugą zaś umieszczamy w płytce
prototypowej pomiędzy wyprowadzeniem +5V a wejściem analogowym A0. Zasada
działania jest tu następująca: nieoświetlony fotorezystor charakteryzuje się wysoką
opornością. W związku z tym cały prąd z wyprowadzenia +5V płynie do wejścia A0,
ustawiając na tym wejściu wartość maksymalną (1023). Jeśli na element światłoczuły
fotorezystora padnie strumień światła, to rezystancja tego elementu zmaleje,
powodując iż prąd płynący z wyprowadzenia +5V, proporcjonalnie do natężenia
światła, popłynie przez fotorezystor. Im większe natężenie światła tym mniejsze
napięcie prądu płynącego poza fotorezystorem, a więc na wejście A0. Przy
odpowiednio silnym oświetleniu fotorezystora osiągniemy bardzo małe wartości
dekodowane na wejściu A0. I tu ważna uwaga: większość fotorezystorów
charakteryzuje się wysoką rezystancją własną. Innymi słowy – nawet bardzo silnie
oświetlone, nie będą w stanie odprowadzić całego napięcia z układu, co spowoduje
22
znaczne zmniejszenie skali, w szczególności jej dolnego zakresu. Aby temu
zapobiec, należy połączenie wyprowadzenia +5V i wejścia A0 przedzielić dobranym
na drodze eksperymentalnej opornikiem. Typowo stosuje się oporniki o rezystancji 2-3 kOhm. W poniższym przykładzie jest to opornik 3 kOhm:
Zanim to wszystko uruchomimy pozostaje jeszcze jedna kwestia: w jaki sposób
zobaczyć na ekranie komputera wartości wysyłane na port szeregowy przez
Arduino? Otóż rozwiązanie jest bardzo proste, a przynosi je sam edytor Arduino,
który posiada funkcję skanowania portu szeregowego i wyświetlania wszystkich
pojawiających się na nim danych w specjalnym oknie. Aby to okno otworzyć, z menu
Tools edytora Arduino powinniśmy wybrać opcję Serial Monitor. Okno to w prawym
dolnym rogu posiada menu, za pomocą którego możemy wybrać prędkość, na jakiej
„nasłuchiwanie“ portu szeregowego prowadzić będzie monitor. Pamiętajmy, że
prędkość ta musi być tożsama z ustawioną przez nasz program prędkością transmisji
danych z Arduino.
Jeśli wszystko połączyliśmy prawidłowo, to chwilę po wysłaniu do Arduino kodu
programu w oknie Serial Monitora w komputerze powinny zacząć pojawiać się liczby
o wartościach odwrotnie proporcjonalnych do natężenia światła padającego na
fotorezystor:
23
Ćwiczenie 2
Zmodyfikuj program tak, by brak oświetlenia fotorezystora generował na wyjściu wartości jak
najmniejsze, rosnące wprost proporcjonalnie do natężenia światła.
Ćwiczenie 3
Poprzez dobieranie oporników o różnej wartości oraz łączenie ich sprawdź jak zmienia
się zakres generowanych na wyjściu wartości.
1.4. Łączenie wejścia z wyjściem, czyli pierwszy projekt interaktywny
Dzięki programowi „Blink“ skłoniliśmy Arduino do podejmowania określonych działań,
dzięki programowi drugiemu, kontroler stał się czuły na natężenie światła. Pora
zatem połączyć te dwa algorytmy uzyskująć w ten sposób pierwszy projekt
interaktywny. Niech założeniem będzie, iż częstotliwość migania diody na cyfrowym
wyprowadzeniu nr 13 będzie wprost proporcjonalna do natężenia światła padającego
na fotorezystor. Odwróćmy tym razem rolę. Oto kod programu, bez żadnych
komentarzy czy wyjaśnień:
int
int
int
int
luminance = 0;
counter = 0;
blinktime = 0;
ledState = 0;
void setup()
{
pinMode(13, OUTPUT);
}
void loop() {
luminance=analogRead(A0);
blinktime=luminance/5;
if (counter++ >= blinktime) {
ledState= !ledState;
digitalWrite(13, ledState);
counter = 0;
};
delay(2);
}
Ćwiczenie 4
Proszę objaśnić zasadę działania powyższego algorytmu.
Ćwiczenie 5
Proszę wyjaśnić, dlaczego nie jest dobrym rozwiązaniem powyższego zagadnienia poniższy,
znacznie prostszy algorytm:
int blinktime = 0;
void setup()
{
pinMode(13, OUTPUT);
}
void loop() {
blinktime=analogRead(A0)/2;
digitalWrite(13, 1);
delay(blinktime);
digitalWrite(13, 0);
24
delay(blinktime);
}
Ćwiczenie 6
Wykonaj rodzaj miernika natężenia światła za pomocą fotorezystora oraz układu kilku diod
LED podłączonych jedna obok drugiej do kolejnych wyprowadzeń cyfrowych Arduino.
Miernik powinien działać w taki sposób, że im większe natężenie światła, tym więcej diod
powinno się świecić.
Ćwiczenie 7
Z połączenia dostępnej ilości fotorezystorów i diod LED wykonaj inny oryginalny projekt
interaktywny wg własnego pomysłu.
__________________________
NB. Czy wiesz, że wszystkie ćwiczenia i przykłady opisane w rozdziale 1.4. będą
działać także na Arduino niepodłączonym do komputera? Możesz to sprawdzić
odłączając Arduino od komputera, należy jednak wtedy doprowadzić do Arduino prąd
ze standardowego zasilacza 5V podłączonego do gniazdka zasilania na płytce
kontrolera.
2. Kilka przykładów udanej współpracy między Arduino a MaxMSP
2.1. Jak połączyć?
Najważniejsze już wiemy. Wiemy mianowicie jak wysłać dane z Arduino przez port
szeregowy do komputera. Wiemy także (z rozdziału 4.2.3) jak odbierać dane
napływające przez port szeregowy w takich programach jak MaxMSP czy PureData.
Teraz wystarczy tylko połączyć jedno z drugim. Załadujmy najpierw do Arduino
program ze strony 22 skryptu i wyjdźmy z edytora Arduino. Wystartujmy MaxMSP
i utwórzmy w nim obiekt [serial].
O obiekcie [serial] należy wiedzieć tyle, że odczytuje on lub wysyła dane przez ten
port szeregowy, który podaliśmy jako pierwszy argument. Drugim argumentem jest
prędkość transmisji. Skąd wiedzieć na którym porcie nadaje nasz Arduino? Najlepiej
zapytać o to wprost obiekt [serial] wysyłając do niego komunikat {print}. Spowoduje
to wypisanie w oknie MaxWindow nazw wszystkich dostępnych portów szeregowych
w naszym komputerze. Nie należy specjalnie liczyć na to, że port, do którego
podłączyliśmy Arduino będzie nazywał się „Arduino“ lub podobnie. Jego nazwa
będzie jednakowoż zbieżna z tą, którą znaleźć możemy w edytorze Arduino w menu
Tools/SerialPort. Nazwy własne portów dziedziczone po nazwach podłączonych
do nich urządzeń są zazwyczaj dosyć długie i trudne do przepisania. W oknie
MaxWindow jednak każda nazwa własna poprzedzona jest jednoliterowym
deskryptorem. Użycie tej litery jako parametru nazwy portu w obiekcie [serial]
powinno w zupełności wystarczyć. Arduino stara się zazwyczaj „wymusić
pierwszeństwo“. Z dużym prawdopodobieństwem portem na którym będzie przesyłać
dane będzie port „a“.
25
Co, oprócz obiektu [serial], powinien zawierać najbardziej podstawowy patch w
MaxMSP, pozwalający na odczytywanie danych z portu szeregowego? Przede
wszystkim, obiekt ów sprawdza bufor portu szeregowego wyłącznie „na żądanie“.
Żądaniem tym jest komunikat {bang} wysłany na wejście obiektu [serial]. Jeśli w tym
czasie w buforze portu szeregowego znajdują się jakieś dane, zostaną one
wyrzucone przez lewe wyjście obiektu [serial]. Ażeby pobierać dane z portu
szeregowego w trybie ciągłym, musimy zamiast prostego obiektu [bang] połączyć
[serial] z obiektem [metro], który ma tę właściwość, że po uruchomieniu (wysłaniu „1“
na lewe wejście) generuje w sposób nieprzerwany komunikaty {bang} w odstępie
czasowym podanym jako argument 1, oczywiście w milisekundach. Jak często
powinien być zczytywany port szeregowy? Zdecydowanie częściej niż przychodzą
tam dane. W przeciwnym razie ryzykujemy ich utratę (port po przepełnieniu
nieopróżnianego na czas bufora traci wcześniej zapisane dane; w konsekwencji
dojść może nawet do zawieszenia się programu MaxMSP). Zbyt częste skanowanie
portu szeregowego z kolei nie grozi żadnymi konsekwencjami; dopóki bufor portu jest
pusty, obiekt [serial] i tak nie wygeneruje na wyjściu żadnej wartości. Przy prędkości
transmisji 9600 baudów, interwał 5 ms odczytu danych ustawiony jako argument
obiektu [metro] powinien być w zupełności wystarczający. Przy szybszych
prędkościach transmisji lepsze będzie zastosowanie interwału 2 a nawet 1 ms dla
obiektu [metro].
Mamy więc podstawowy algorytm – połączenie obiektu skanującego port szeregowy
z mechanizmem, który wymuszać będzie szybkie i cykliczne skanowanie tego portu.
Teraz warto spowodować, by dane pobierane przez obiekt [serial] pojawiły się w na
ekranie komputera. Sprobujmy najpierw najprostszej metody – po prostu wpinając
lewe wyjście obiektu [serial] do obiektu [print] i obserwujmy co się dzieje w oknie
MaxWindow:
Dzieje się sporo, ale chyba nie to, czego oczekiwaliśmy. Zamiast znanych już z okna
SerialMonitora w edytorze Arduino wartości w zakresie od 0 do 1023, otrzymujemy
jakieś dziwne dwucyfrowe liczby generalnie w okolicach piątej dziesiątki, z dosyc
regularnie pojawiającą się kombinacją liczb 13 i 10. Jak to interpretować? Otóż
bardzo prosto. MaxMSP nie wie jakiego typu wartości przychodzą na port szeregowy
i choć Arduino wysyła kodowane za pomocą ASCII poszczególne cyfry przedzielone
separatorem <CR/LF> (to właśnie ta tajemnicza kombinacja 13 i 10), to na ekranie
MaxWindow pojawiają się kody ASCII zamiast odpowiadających im cyfr.
Potrzebujemy zatem konwertera, który wyglądać mógłby tak:
26
Lepiej, choć to jeszcze nie to. Przede wszystkim zamiast liczb otrzymujemy ciągi
składających się na nie cyfr. Po drugie kody <CR/LF> co prawda nie są wyświetlane
w oknie MaxWindow, ale nie oznacza to, że znikły – o ich obecności świadczą puste
linie. Spróbujmy poradzić sobie z oboma problemami na raz. Przede wszystkim
należy pogrupować cyfry w liczby. Pomoże nam w tym właśnie kombinacja <CR/LF>,
która pełni rolę separatora. aby „odłowić“ separatory z ciągu danych zastosujemy
obiekt [match], który generuje {bang} za każdym razem, kiedy na jego lewym wejściu
pojawi się sekwencja liczb tożsama z sekwencją zdefiniowaną jako parametry tego
obiektu. W tym wypadku będzie to oczywiście [match 13 10]. Równolegle kody ASCII
cyfr grupować będziemy w listy, by następnie utworzyć z nich liczby. Grupowanie
odbywa się w obiekcie [zl group 127]. Argument (127) jest maksymalną wielkością
listy i jest oczywiście mocno na wyrost. Tak naprawde lista jest „zamykana“ i
wysyłana przez lewe wyjście obiektu [zl group] za każdym razem, kiedy [match 13
10] wyśle komunikat {bang}, czyli... wiadomo kiedy. Jednocześnie z wysłaniem do
dalszej obróbki listy kodów ASCII cyfr składających się na jedną liczbę wysłaną
niegdyś „szeregowo“ przez Arduino, obiekt [zl group] jest „czyszczony“, może więc
od nowa grupować kolejne nadchodzące kody ASCII w listę. Tymczasem lista trafia
do obiektu [zl filter 13 10], gdzie usuwane są wystąpienia kodów <CR/LF>. Tak
naprawdę, kodu <LF> w liście nie powinno być już dawno, z całą pewnością znajdzie
się tam jeszcze kod <CR>, który trzeba usunąć zanim tak przygotowana lista kodów
ASCII poszczególnych cyfr trafi do obiektu [itoa]. Obiekt ten posiada tę właściwość,
że nie tylko zamienia kody ASCII na odpowiadające im znaki, ale także integruje listy
kodów w ciągi znaków. W tym wypadku ciągiem znaku będzie... liczba, a dokładniej
wartość w zakresie od 0 do 1023, jaką wygenerowało Arduino. Jeszcze dla zasady
(oraz na potrzeby niektórych obiektów) zamienimy tę liczbę reprezentowaną jako
ciąg znaków (po ludzku: napis) w typ danej, który będzie dla nas znacznie bardziej
przydatny (integer) i wszystko to możemy wreszcie posłać do obiektu [print], żeby
obejrzeć sobie rezultat naszych przekształceń w oknie MaxWindow:
27
2.2. Sterujemy głośnością za pomocą... latarki
To jeden z prostszych pomysłów na interakcję, ale jakże efektowny. Więcej światła =
więcej dźwięku. Pełny synkretyzm, oczywista interakcja. Spróbujmy. Włączenie do
stworzonego w poprzednim podrozdziale patcha obiektów [sfplay~] (odtwarzanie
plików audio z dysku komputera) z obiektem [*~] (mnożnik sygnału, umożliwiający
m.in. sterowanie amplitudą sygnału) oraz dodanie do tego kilku istotnych drobiazgów,
jak na przykład obiekt [zmap] pozwalający na zamianę wartości z zakresu 0–1023 na
wartości z zakresu 0.–1. (idealnego do sterowania amplitudą), pozwoli na stworzenie
takiego właśnie interaktywnego systemu odtwarzania dźwięku:
Dosyć podobne rozwiązanie w oparciu o 7 fotorezystorów sterujących głośnością
odtwarzania 7 zsynchronizowanych ścieżek dźwiękowych zastosowałem niedawno
podczas wernisażu prac pewnego luksemburskiego abstrakcjonisty. Zarówno same
dzieła, jak i zaproponowana przez malarza nazwa wystawy – Scapes: Escapes,
Landscapes, Soundscapes prowokowała do użycia podobnych środków. Wernisaż
polegał na tym, iż publiczność wpuszczano do całkowicie wyciemnionej sali, gdzie
28
wisiały obrazy. Każdy, kto wchodził otrzymywał latarke, ale nie dostawał żadnych
instrukcji co do tego jak powinien się zachowywać we wnętrzu sali wystawowej.
Ludzie, chcąc obejrzeć obrazy kierowali na nie w sposób naturalny strumień światła
latarki. Snop światła padając na obraz wywoływał muzykę. Im bliżej obrazu był
oglądający i im jaśniej go oświetlał, tym głośniejsza była muzyka tego konkretnego
obrazu. Na koniec zaprosiłem siedem wybranych osób do wspólnego wykonania
utworu na światła i obrazy. Osoby z latarkami ustawiły się przy obrazach, w których
były ukryte czujniki. Na mój znak wskazane osoby oświetlały poszczególne obrazy.
Z pojedynczych struktur melodycznych powstawało powoli tutti, kiedy wszystkie
obrazy zostały oświetlone latarkami. A oto niewielka dokumentacja techniczna z tej
instalacji:
Cwiczenie 8
Na bazie powyższego przykładu zbuduj mikser pozwalający modyfikować amplitudę kilku
odtwarzanych na raz plików dźwiękowych. Wymagana będzie oczywiście odpowiednio
większa ilość fotorezystorów, a co za tym idzie, odpowiednie zmiany także w programie
dla Arduino.
Ćwiczenie 9
Spróbuj zrealizować podobny projekt za pomocą PureData.
29
2.3. Event triggering
Czasem najprostsze rozwiązania dają najlepsze efekty. Wszystko zależy od
pomysłowości, no i oczywiście od sprawnego i interesującego wykorzystania
stworzonego systemu interaktywnego. Spróbujmy teraz stworzyć bardzo prosty
system, w którym określona informacja płynąca z Arduino będzie nie tyle sterowała
parametrami wykonania, ile wyzwalała pewne określone akcje. Mając gotowy patch,
w którym światło sterowało głośnością odtwarzania dźwięku, spróbujmy go nieco
zmodyfikować:
Ćwiczenie 10
Czy potrafisz odpowiedzieć na pytanie, jaka dokładnie interakcja zachodzi w tym przypadku?
Ćwiczenie 11
Wykonaj projekt polegający na uruchamianiu odtwarzania kilku plików dźwiękowych,
w zależności od wartości parametru przesyłanego przez Arduino.
2.4. Precyzja pomiaru czujników analogowych a filtrowanie szumu
Czujniki analogowe są z reguły elementami dosyć czułymi. Oczywiście
w zastosowaniach laboratoryjnych nie sprawdziłyby się, ale w działaniach
interaktywnych ich parametry są najczęściej absolutnie wystarczające, a niekiedy
nawet zbyt wyśrubowane. Typowym problemem związanym ze sterowaniem
interakcją są szumy i krótkie wahania wartości mierzonych z czujników nawet przy
wydawałoby się niezmiennej wartości mierzonego bodźca. Artefakty te są z reguły
sumą kilku czynników, z czego najpoważniejszym wydaje się być „niesterylność“
środowiska w jakim dokonujemy pomiaru (przykładowo, rzadko kiedy instalacje i
performance bazujące na czujnikach fotoelektrycznych odbywają się w doskonałej
ciemności). Sytuacja koncertowa/wykonawcza jest niezwykle daleka od sytuacji
30
laboratoryjnej, a nawet nierzadko odbiega od warunków studyjnych czy domowych
w jakich testowaliśmy nasz projekt. Pewną część winy za „poszarpany“ sygnał
można zrzucić także na nieprezycyjne i mało profesjonalne instrumenty generujące
mierzony przez czujnik bodziec. Czy bowiem od zwykłej latarki lub światła odbitego
od reflektora na scenie możemy oczekiwać stabilności i takiego samego przez cały
czas trwania performance’u natężenia? Koniec końców niebagatelną rolę
w powstawaniu zniekształceń gra także sama technologia. Konwersja analogowocyfrowa jakiej dokonuje serce Arduino – układ ATmega – z całą pewnością nie jest
pozbawiona typowych dla tanich rozwiązań problemów, takich jak np. szumy
kwantyzacji. Dlatego ważnym elementem oprogramowania powinny być filtry
wygładzające i uśredniające w dziedzinie czasu dane jakich w wyniku konwersji
dostarcza komputerowi Arduino.
W większości własnych projektów stosuje prosty filtr II stopnia sumujący
i uśredniający podaną jako parametr ilość kolejnych wartości wejściowych. Oto patch
realizujący ten algorytm oraz rezultat jego działania na sygnale pochodzącym
z czujnika w stanie spoczynku:
31
2.5. Inne czujniki
W dużej rodzinie czujników analogowych poczesne miejsce znajdują
czujniki zgięcia (flex) oraz wychylenia (tilt). Wszyte w kostium,
czy zamocowane w łatwy sposób na ciele performera nadają się one
świetnie do w miarę precyzyjnego dekodowania ruchu rąk i nóg.
W wielu zastosowaniach mogą śmiało konkurować ze sporo droższymi
i wymagającymi znacznie większego nakładu pracy programistycznej
systemami do renderingu ruchu w obrazie z kamery (np. EyesWeb).
Oczywiście co do zasady działania są to kompletnie odmienne od
systemów bazujących na obrazie video rozwiązania, ale jedno nie ulega
wątpliwości – przekazują dosyć precyzyjnie dane na temat ruchu
poszczególnych kończyn. Połączone w jeden układ z akcelerometrami
(sensorami przyspieszenia w przestrzeni trójwymiarowej) oraz czujnikami
nacisku (pressure) mogą stworzyć system rejestrujący ruch, gest
i zachowanie tancerza czy performera na scenie.
Na bazie takich właśnie czujników oraz kontrolera LilyPad powstał
kostium, który posłużył do zrealizowania projektu Evasion autorstwa
grupy OxO-Factory z moim udziałem jako twórcy systemu
inteaktywnego. Kostium składał się z 8 czujników typu flex wszytych
rękawy i nogawki na wysokości łokci, barków, bioder i kolan, dwóch
czujników typu accelerometer wszytych w mankiety rękawów,
4 czujników typu pressure umieszczonych po dwa w podeszwach butów
oraz na specjalnych naszywkach trzymanych umocowanych w dłoniach
tancerki. Dzięki tak żłożonemu systemowi czujników podłączonemu do
LilyPad, informacja za pośrednictwem XBee docierała bezprzewodowo
do komputera, gdzie zamieniana była na szereg zdarzeń dźwiękowych.
Tancerka ruchem ciała wyzwalała odtwarzanie plików dźwiękowych,
innym razem przetwarzała te odtwarzane dźwięki, a jeszcze kiedy indziej
przetwarzała dźwięk pochodzący z perkusji – jedynego instrumentu
akustycznego towarzyszącego wykonaniu. Ruchy rękami w przestrzeni
32
trójwymiarowej, dekodowane za pomocą akcelerometrów dokonywały
dyspozycji przestrzennej (spacjalizacji) tak dźwięków elektronicznych,
jak dźwięków perkusji.
Oto kilka zdjęć z wykonania Evasion w Paryżu oraz w Sewilli,
w Konserwatorium Tańca:
33