Interakcje wizualno - muzyczne

Marcin Wierzbicki

Arduino – Twój mały interaktywny przyjaciel

4 – 6 marca 2011

2

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

3

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

4

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 oprogramo-wania 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.

5

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 4-pinowym 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

6

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.

7

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ł.

8

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 10-bitowej, 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

9

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

10

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

11

standardowych kontrolerów lub A-miniB w przypadku kontrolerów zminiaturyzo-wanych. 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

12

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

13

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.

14

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.

15

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

16

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

17

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.

18

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

19

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); // set the LED on delay(1000); // wait for a second digitalWrite(13, LOW); // set the LED off delay(1000); // 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.

20

A oto zwięzła analiza kodu programu „Blink“:

/* funkcja setup() wykonywana jednokrotnie na pocz ątku. W tym przypadku funkcja ustawia cyfrowe wyprowadzen ie nr 13 jako wyj ście */ void setup() { pinMode(13, OUTPUT); } /* funkcja loop() powtarzana tak długo, jak długo p rogram znajduje si ę w pami ęci Arduino a samo Arduino podł ączone jest do zasilania */ void loop() { digitalWrite(13, HIGH); // ustawia cyfrowe wyprowadzenie nr 13 w stan „wyso ki“ (na wyprowadzeniu pojawia si ę napi ęcie dodatnie, co powoduje za świecenie si ę diody „L“) delay(1000); // linia opó źniaj ąca. Proces czeka 1000 ms czyli 1 sekund ę digitalWrite(13, LOW); // ustawia cyfrowe wyprowadzenie nr 13 w stan „nisk i“ (na wyprowadzeniu pojawia si ę napi ęcie zerowe, co powoduje zgaszenie si ę diody „L“) delay(1000); // 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:

21

Ć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.

22

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 li czby 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

23

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:

24

Ć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 luminance = 0; int counter = 0; int blinktime = 0; int 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);

25

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“.

26

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:

27

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:

28

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

29

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.

30

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

31

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 analogowo-cyfrowa 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:

32

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

33

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: