Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg. Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

Az Arduino mikrovezérlőjén (AVR ATmega) van két olyan I/O csatorna (D0 és D1), amelyeknek megkülönböztetett funkciójuk van – a két kivezetést együtt soros portnak nevezzük, amin keresztül adatokat cserélhetünk a környezet és a mikrovezérlő között. Az egyik csatorna az adatok fogadásáért (Rx – receiver), a másik pedig küldéséért felel (Tx – transmitter). A soros átvitel szekvenciálisan zajlik, vagyis egy időben egyetlen bit halad át a csatornán. Ennek megfelelően a kommunikáció sebességét a másodpercenként átvitt bitek számával mérjük és BPS-sel (Bits Per Second = Bit per másodperc) jelöljük. Az Arduino maximális átviteli sebessége 115200 bit másodpercenként.

A soros átvitelt jelző LED-ek és az USB átalakító

Ahhoz, hogy számítógépünk könnyedén kapcsolódhasson a mikrovezérlőhöz, az Arduino tartalmaz egy soros USB átalakítót (FTDI), mely a fent említett csatornákhoz kapcsolódik és létrehozza a kapcsolatot az univerzális soros busszal (USB). Az adatok ugyan bitenként, de egymástól jól elhatárolható csomagokban közlekednek. Ezek a blokkok START jelből, 8 bit adatból (1 byte) és két STOP jelből állnak.

Az ASCII, vagyis az American Standard Code for Information Interchange 1963 óta szabványa a szöveg típusú adatok digitális tárolásának és átvitelének. Az általános kódtáblázat 128 karakterből áll, melynek alapját az angol ABC kis- és nagybetűi, írásjelek, számok és matematikai kifejezések képezik. Ezeken felül 33 grafikusan nem megjeleníthető, úgynevezett vezérlőkarakter is helyet kapott, mint a „soremelés”, „fájl vége”, „fejléc kezdete”, melyek egy része ma már nem használatos. A kódtáblát legegyszerűbben egy számozott sorozatként képzelhetjük el, ahol a nulladik helytől a 31-ig a vezérlőkarakterek, 32-től 126-ig a megjeleníthető karakterek találhatók, a sort pedig a „törlés” nevű vezérlőkarakter zárja. Soros kommunikáció esetén az adat értéke egyszerűen a táblázat egyik elemének sorszámát jelöli.

Az ASCII kódtábla 

Példánkon keresztül megérthetjük, hogyan értelmezi mindezt az Arduino, és megismerjük a kiterjesztett soros nyomtatási funkciókat. Nyomtassuk ki a soros terminálunkra az ASCII táblázat grafikus elemeit és a hozzájuk tartozó értékeket decimális, hexadecimális, oktális és bináris formátumokban!

A soros terminált a keretprogram jobb oldalán található ikonra kattintva érhetjük el.

Arduino kód: 20ASCII

Csak egy számítógéphez kötött Arduinora lesz szükségünk.

ASCII Table ~ Character Map:

!, dec: 33, hex: 21, oct: 41, bin: 100001
", dec: 34, hex: 22, oct: 42, bin: 100010
#, dec: 35, hex: 23, oct: 43, bin: 100011
$, dec: 36, hex: 24, oct: 44, bin: 100100
%, dec: 37, hex: 25, oct: 45, bin: 100101
&, dec: 38, hex: 26, oct: 46, bin: 100110
', dec: 39, hex: 27, oct: 47, bin: 100111
(, dec: 40, hex: 28, oct: 50, bin: 101000
), dec: 41, hex: 29, oct: 51, bin: 101001
*, dec: 42, hex: 2A, oct: 52, bin: 101010
+, dec: 43, hex: 2B, oct: 53, bin: 101011
,, dec: 44, hex: 2C, oct: 54, bin: 101100
-, dec: 45, hex: 2D, oct: 55, bin: 101101
., dec: 46, hex: 2E, oct: 56, bin: 101110
/, dec: 47, hex: 2F, oct: 57, bin: 101111
0, dec: 48, hex: 30, oct: 60, bin: 110000
1, dec: 49, hex: 31, oct: 61, bin: 110001
2, dec: 50, hex: 32, oct: 62, bin: 110010
3, dec: 51, hex: 33, oct: 63, bin: 110011

stb....

A program kimenete (ezt látjuk a soros terminálban)

Adatátvitel PC-ről Arduinora

Azon túl, hogy a soros terminálban képesek vagyunk adatok megjelenítésére – ami nagyon hasznos lehet az Arduino programjának írása közben hibák felderítésénél (debug), a hozzákapcsolt szenzorok érzékenységének beállításakor, a kiváltani kívánt hatások ellenőrzésekor –, használhatjuk az adatkapcsolatot arra is, hogy a számítógépünkön megírt komplex programok a fizikai környezetet az Arduinon, mint periférián keresztül érjék el.

      A következő példában egy Arduinohoz kapcsolt LED fényerejét fogjuk változtatni számítógépről küldött adatokkal. Ahogy a fentiekben, most is byte-okat fogunk küldeni, melyek értéke 0-tól 255-ig változhat. Ezeket beolvassuk az Arduinoval és hozzárendeljük a LED fényerejét meghatározó értékhez.

Bármilyen programot használhatunk a kommunikációhoz, ami képes gépünk soros portját megnyitni. Nézzük meg, hogyan lehetséges ez Processing és Max/MSP5 környezetekből!

Amire szükségünk lesz:

• Arduino,
• LED,
• 220 – 1 kiloohmos ellenállás,
• Processing vagy,
• Max/MSP v. 5.

LED polaritása és bekötése az Arduinoba

Kössük a LED-ünk (10.4. ábrán) negatívval jelölt lábát az Arduino földjéhez (GND), a pozitívval jelölt lábát pedig egy soros ellenálláson keresztül a 9-es I/O csatornájához – amit most impulzusmodulációra (PWM) képes kimenetként fogunk használni.

Arduino kód: 21LEDsoros

Soros adat küldése Processing segítségével

Hozzunk létre egy 256 pixel széles képernyőt, amin az egér aktuális vízszintes koordinátája jelenti majd az Arduinohoz kötött LED fényerejét (0–255). Vizualizáljuk az elvárt kimenetet függőleges vonalakból álló, feketéből fehérbe változó gradienssel. Küldjük ki az egér pozícióját sorosan byte-onként!

Processing kód: 22Processing

Processing kód futásának eredménye

Soros adat küldése Max/MSP segítségével

Byte küldése Max/MSP-vel

Vezérlés karakterekkel

Nézzünk az előző kapcsolással még egy példát! Az Arduinohoz csatlakoztatott LED-et fogjuk ki- és bekapcsolni általunk meghatározott karakterekkel. Bármely soros kommunikációra alkalmas programból elküldhetjük a karaktereket, az Arduino fejlesztőkörnyezetének saját soros termináljából is.

Arduino kód: 23Karakter

Karakterek küldése Processing segítségével

Az alábbi kód egyszerre példa meghatározott karakterek soros küldésére és egy egyszerű egérre reagáló gombra. Amikor egerünket a gombként működő négyzet fölé visszük, az Arduinohoz kapcsolt LED bekapcsolódik.

Processing kód: 24KarakterProc

A processing kódunk kimenete

Karakterek küldése Max/MSP segítségével

Vezérlés karakterekkel Max/MSP-vel

Switch feltétel használata soros kommunikációban

Itt még érdemes kitérnünk az Arduino nyelv egy funkciójára, amelynek segítségével diszkrét értékekhez rendelhetünk végrehajtandó kódrészeket. Ahogy az if esetében két – a feltételnek megfelelő és az annak nem megfelelő – állapot közül választhatunk, addig a Switch (case) feltétel esetében egy változó minden értékével különálló feltételt tudunk megvalósítani.

Amire szükségünk lesz:

• Arduino,
• 5 db LED,
• 5 db 220 – 1 kiloohmos ellenállás,
• próbapanel,
• vezetékek,
• Processing vagy,
• Max/MSP v. 5. 

Kapcsolás a switch() feltétel megértéséhez

Csatlakoztassunk az Arduino 2, 3, 4, 5, 6-os csatornáihoz egy-egy LED-et soros ellenállással, az eddigi példáknak megfelelően. Az, hogy melyik LED fog világítani, az a sorosan beolvasott karaktertől függ, ami az alábbi kód szerint a, b, c, d vagy e lehet.

Arduino kód: 25switch

A processing kódot és a MAX patchet az előzőek alapján át tudjuk alakítani. A fent meghatározott L és H karaktereket felválthatjuk a, b, c, d, e bármelyikére és kibővíthetjük a programunkat többgombosra is, az Arduino program kipróbálásához azonban elegendő a soros terminál is.

Adatátvitel Arduinoról PC-re

Fordítsuk meg az eddig taglalt folyamatot, és nézzük meg, hogyan lehet az Arduino által gyűjtött fizikai jeleket a számítógépbe eljuttatni. Legyen a szenzorunk az egyik analóg (ADC) bemenetre kötött potenciométer, amivel a tápfeszültséget leosztjuk annál kisebb feszültségekre, hogy a beolvasott 1024 lehetséges állapot közül a potméter elfordításával tudjunk választani. A beolvasott értéket aztán átadjuk a soros porton keresztül a számítógépnek, ahol grafikusan feldolgozzuk.

Amire szükségünk lesz:

• Arduino
• 10–100 kiloohmos potenciométer (3 db)
• Processing vagy
• Max/MSP v. 5

Potenciométer, mint analóg szenzor bekötése

Kössük a potméterünk egyik szélső lábát az Arduino föld- (GND), a másikat az 5 V-os tápcsatlakozójába. Ha feszültségmérővel a föld és a potméter középső lába között mérünk, azt fogjuk látni, hogy a potméter elforgatásával a feszültség 0–5 V között változik. Ezzel a módszerrel bármikor lemodellezhetjük az összes analóg módon működő szenzort. Az ilyen típusú érzékelők a mért fizikai paramétereket az általuk kibocsátott feszültség szintjével állítják valamilyen arányú összefüggésbe. Kössük a potméter középső lábát az Arduino A0 analóg bemenetére, a digitalizált érték 0–1023 között fog változni.

Arduino kód: 26PotiSoros

Adatok grafikus ábrázolása Processing segítségével

Az alábbi példakód beolvassa az Arduino által sorosan elküldött adatokat, és minden új adatot egy olyan grafikonon ábrázol, amelyen a függőleges vonalak hossza arányos a potméterünkkel beállított feszültséggel.

Processing kód: 27GraphProc

Processinggel vizualizált grafikon

Adatok grafikus ábrázolása Max/MSP segítségével

Max/MSP patch Arduinoból sorosan olvasott adatok vizualizációjára

Több független adat átvitele

Bővítsük ki az előző példát, és nézzük meg, hogyan lehet egyszerre több bemenet értékét eljuttatni a számítógépbe. A kapcsolás lényegében lehet ugyanaz, mint eddig, azzal a különbséggel, hogy 3 db potenciométer kapcsolódik három különálló analóg bemenethez, A0-hoz, A1-hez és A2-höz. Ha rendelkezünk más jellegű érzékelőkkel, például fényérzékeny ellenállásokkal, akkor az alábbi feszültségosztó kapcsolást is használhatjuk.

Több analóg érzékelő bekötése Arduinoba

Arduino kód: 28analog3

Az analóg bemenetek értékeit továbbra is decimális kódolású ASCII karakterekként küldjük el, vagyis egy háromjegyű szám átvitelekor három egymást követő byte-ot továbbítunk. ASCII-ben az 1-es számértéke 49, a 2-es számértéke 50 és így tovább. (Lásd ASCII tábla.) A három szenzor értékét a számítógépes példakódokban három színcsatorna (piros, zöld, kék) intenzitásának változtatására fogjuk felhasználni.

Virtuális színkeverő Processingben

Processing kód: 29szinkeveroProc

A potméterek elforgatásával virtuálisan színeket keverhetünk.

Virtuális színkeverő Max/MSP-ben 

A potméterek elforgatásával virtuálisan színeket keverhetünk.

Kétirányú kapcsolat – meghívás és válasz

Előfordulhat, hogy a szenzorértékek beolvasása vagy a kimenetek kapcsolása önmagában nem elegendő, és kétirányú kapcsolatot kell létrehozni az Arduino és a számítógép között. Erre léteznek különféle protokollok, melyek közül a legismertebb a Firmata – aminek működésére később kitérünk. Azonban most nézzünk egy jóval egyszerűbb megoldást, az úgynevezett Handshaking módszert. A példában az Arduino indulásakor egy A karaktert küld a számítógépnek, ezt követően a hozzá kapcsolt három szenzor értékét is továbbítja. Ha a számítógép készen áll és megkapta a „Start jelet” (A), beolvassa a szenzorok értékét és visszaküld egy A karaktert az Arduinonak, hogy folytassa az adatok küldését.

Amire szükségünk lesz:

• Arduino,
• 2 db analóg szenzor,
• 1 db nyomógomb,
• 3 db 10 kiloohmos ellenállás,
• próbapanel,
• vezetékek,
• Processing, vagy
• Max/MSP v. 5.

Két érzékelő és egy gomb bekötése

Kössünk be két analóg érzékelőt az A0 és A1 analóg bemenetekre, illetve egy nyomógombot a 2-es digitális csatornára. A két analóg érzékelő működését modellezhetjük potméterekkel, lásd a virtuális színkeveréskor használt kapcsolást.

Arduino kód: 30ketiranyu

Handshaking módszer Processing oldalról 

Az analóg szenzorokkal egy körlapot mozgatunk a képernyőn, a nyomógombbal a körlap színét változtatjuk feketére.

Processing kód: 31ketiranyuProc

Körlap mozgatása két analóg szenzorral

Handshaking módszer Max/MSP oldalról

Max/MSP handshaking patch

forrás: http://arduino.cc/en/Tutorial/HomePage

Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg. Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

Analóg bemenet kiolvasása

A potméter egy változtatható ellenállású gomb, amit most analóg szenzorként értelmezünk, így analóg pinbe kötve ki tudjuk olvasni az értékeit. A kódban ezzel a kiolvasott értékkel a beépített LED-ünk villogási sebességét változtatjuk.

Az analogRead() parancs a beérkező 0–5 V közötti feszültségértéket átalakítja egy 0–1023 közötti digitális értékké. Ezt az Arduino egyik belső áramköre végzi el, amit ADC-nek hívunk (Analog-to-Digital Converter).

Bekötése: Ha a potméter (pl. 1 kiloohmos lineáris) mindhárom lába előre mutat, akkor a bal szélsőt kössük az 5 V pinbe, a jobb szélsőt a földelésbe, a középsőt pedig az analóg 0-ba. Az alaplapba épített LED-et használjuk, ami a 13 pinre ki van vezetve így opcionálisan beköthető ide egy 5mm-es LED is.

Potméter bekötése

 Arduino kód: 15potmeter

Analóg bemenettel vezérelt PWM

Ezúttal kiolvasunk egy analóg pint és a kapott értéket 0–255 közötti digitális értékké alakítjuk, skálázzuk map() utasítással és ráküldjük egy PWM pinre, amivel egy LED fényerejét fogjuk vezérelni. Ehhez szükségünk lesz egy potméterre (mondjuk 1 kiloohmos lineáris fajtára), egy 220 ohmos ellenállásra és egy hagyományos piros LED-re.

LED és potméter bekötése

Bekötése: Ha a potméter mindhárom lába előre mutat, akkor a bal szélsőt kössük az 5 V pinbe, a jobb szélsőt a földelésbe, a középsőt pedig az analóg 0-ba. A LED rövidebb,  negatív lába a szokásos módon a földelésbe, a hosszabb, pozitív a 220 ohmos ellenálláson át a digitális 9 pinbe kerül.

A kódban először megjelöljük, melyik pint miként akarjuk használni. Ezután létrehozunk két változót, az egyikbe az analóg pinből analogRead()-del kiolvasott érték kerül, a másikba ennek az értéknek az arányosított megfelelője, amit majd a LED-hez fogunk kiküldeni analogWrite()-tal. Mivel a feladathoz PWM pint használunk, az impulzusszélesség modulációval különböző erősséggel tud világítani a LED-ünk. A PWM pinre 0–255 körötti értéket küldünk, ehhez az analóg szenzorból kiolvasott 0–1023 közötti értéket map() paranccsal szétosztjuk.

Arduino kód: 16potmeterLED

Analóg szenzor kalibrálása

A következőkben megvizsgáljuk a szenzorok kalibrálásának menetét. A folyamat során az Arduino 5 másodpercig megszakítás nélkül olvassa ki az értéket. A program végrehajtása közben a szenzorból kiolvasott adatok meghatározzák a minimum és maximum értékeket.

Az analóg 0 pinbe bármilyen szenzort beköthetünk, potmétert vagy fotóellenállást is; a példában az utóbbit használjuk.

 Bekötése: A LED-ünk negatív lábát a szokásos 220 ohmos ellenálláson keresztül bekötjük a földelésbe, pozitív oldalát pedig a 9 pinbe (bármelyik lábához kerülhet az ellenállás, eddig a pozitívhoz tettük), a fotóellenállás (LDR) bármilyen irányban állhat, egyik lába az 5 V-ba, a másik lába az analóg nulla (A0) pinbe és egy 10 kiloohmos ellenálláson át a földelésbe is be van kötve.

LED és fotóellenállás bekötése

A kód legelején inicializálnunk kell a két változót, amelyben a minimum és maximum értéket fogjuk eltárolni. Analóg pinről lévén szó, a minimum 1023 és a maximum 0 legyen – most kivételesen fordítva használjuk. A legelején meghatároztuk a maximum értéket (0) és ha a kiolvasott érték a felett van, akkor ezt mentjük majd el, mint új maximum értéket. Ugyanígy, ha a kiolvasott érték az elején beállított minimum érték (1023) alatt van, akkor az lesz az új minimum érték. Ezután ezt a két értéket skálázzuk 0–255 közé, ez fogja vezérelni a PWM-re kötött LED-ünk fényerejét.

Megjegyzés: Ha potmétert használunk, ne tekerjük el a kalibrálás alatt teljesen ütközésig, így köztes értéket tudunk használni, hogy megértsük a kód működését.

Arduino kód: 17kalibralas

Előfordulhat, hogy a kalibráció alatt nem jelennek meg a szélsőértékek, így a map()nem valós értéket állíthat elő (pl. a maximumot felveszi 800-nak az elején, később pedig beolvas 820-at, akkor a map() eredménye már 256), ezért a constrain()-nel beszorítja a kilengéseket a megadott intervallumba.

LED fényerejének szabályozása PWM-mel

PWM = Pulse Width Modulation, azaz impulzusszélesség moduláció. Egy olyan digitális jel, ami rendkívül gyorsan kapcsolja ki-be a digitális jelet egy meghatározott ütemben, ezáltal felruházva a digitális pinünket analóg-szerű viselkedéssel.

Bekötése: 220 ohmos ellenálláson át bekötjük a LED pozitív lábát a digitális 9 pinbe, a negatívat pedig a földelésbe.

LED bekötése digitális 9 pinbe

Arduino kód: 18LEDpwm

Simítás

Ez a kód folyamatosan olvassa ki az analóg bemenetet és az értékek átlagát írja ki a számítógépre. Hasznos lehet egyenetlen szenzorok kiolvasásánál, mivel elsimítja az értékek ingadozását. Egyúttal azt is megnézzük, hogyan lehet tömböt használni adattárolásra.

Bekötése: Potmétert használunk, középső lábát analóg nullába kötjük, a két oldalsót pedig az 5 V feszültségbe és a földelésbe.

Potméter bekötése A0-ba

A kód egymást követő 10 kiolvasást tárol el egy tömbben, egyesével. Ezeket összeadja, majd elosztja, így egy átlagértéket ad. Mivel a beérkező értékekkel folyamatosan kalkulál, és nem várja meg mind a 10 értéket, ezért nincs késési idő. A numReadings nevű változó értékének lecserélésével tudunk kísérletezni.

Arduino kód: 19simitas

forrás: http://arduino.cc/en/Tutorial/HomePage

Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg. Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

A következő alfejezetekben különböző eszközöket fogunk digitális pinekre kötni: LED-et, nyomógombot, kis hangszórót, miközben újabb típusú változókkal és – többek között – az if kondícióval, a for ciklussal, a tone és a millis függvényekkel ismerkedünk meg, valamint az Arduino belső felhúzó-ellenállását is használni fogjuk.

LED villogtatása delay() nélkül

Néha azt szeretnénk, hogy párhuzamosan történjenek dolgok, pl. miközben villog a LED egy nyomógomb állapotát is vizsgálni szeretnénk. Ilyenkor a delay()-t nem tudjuk használni, hiszen az az egész kód lefutását késlelteti, és lehet hogy pont akkor nyomjuk meg a gombot, amikor a kód áll, így elmumlasztjuk a kiolvasását. Ezért az alábbi kódban változók segítségével hozzuk létre a villogást úgy, hogy az eltelt idő mértékét vizsgáljuk.

A következő példában a LED mindig az ellenkező állapotába kerül, mint amilyenben épp van, tehát ha be van kapcsolva, akkor kikapcsol, és fordítva. Mivel a loop() folyamatosan fut, minden alkalommal megvizsgálja, hogy az if feltétel igaz-e, és ahhoz képest lép tovább a kódban. Használhatjuk az Arduino beépített LED-jét vagy beköthetünk egyet a szokásos módon – a pozitív lábát 220 ohmos ellenállásom keresztül a 13 pinbe, a negatív lábát pedig a földelésbe (Gnd).

LED bekötése 13 pinbe

Arduino kód: 06LEDmillis

Nyomógomb LED-del

Ismét a beépített, 13 digitális pinre kivezetett LED-ünket fogjuk használni, valamint egy nyomógombot, amit a 7.2.1. számú ábra szerint kötünk be a digitális 2 pinbe, a feszültségbe (5 V) és egy 10 kiloohmos ellenálláson keresztül a földbe (Gnd).

Nyomógomb bekötése

Amikor a nyomógomb nyitva van (tehát nincs lenyomva), akkor a lábak között nincs összeköttetés, így – mivel a gombon át a földeléshez vagyunk kötve – a pinünkből LOW jelet tudunk kiolvasni. Ha a gomb lenyomásával zárjuk az áramkört, akkor a jelünk az 5 V pinből érkezik, azaz HIGH lesz.

Ha fordítva kötjük az áramkört, azaz az ellenállással a HIGH jelet tartjuk meg, akkor gombnyomásra LOW-t kapunk, így a LED akkor alszik el, ha nyomjuk a gombot.

Arduino kód: 07nyomogomb

Késleltetés (debounce)

Ehhez a feladathoz az előző példa alkatrészeit és bekötési ábráját használjuk. A nyomógombot kapcsolóként használjuk, mely először bekapcsolja, majd második megnyomásnál kikapcsolja a LED-et. Késlelteti a bemeneti jelet, mely azt jelenti, hogy nagyon rövid időn belül kétszer is leellenőrzi, meg van-e nyomva a gomb. Késleltetés használata nélkül előfordulhat, hogy az egyszeri gombnyomást a kód többszörinek veszi. Millis() függvény segítségével követhetjük a gombnyomás időtartamát. Ugyanúgy HIGH jelet kap a bemeneti pinünk, ha lenyomjuk a gombot, mit az előző példában, és LOW jelet, ha nincs. Amikor a 2 bemeneti pin állapota LOW-ról HIGH-ra változik, átkapcsolja a kimeneti pint LOW-ról HIGH-ra, és a következő alkalommal vissza.

Arduino kód: 08kesleltetes

Nyomógombos számláló

Ebben a példában egy nyomógombbal működő számlálót készítünk. Ahhoz, hogy a megnyomások számát követni tudjuk, ugyanúgy a bemeneti pin állapotát (HIGH, LOW) kell figyelnünk, és azt kell számolnunk, hogy ez a változás hányszor történt meg. Ezt „állapotváltozás érzékelés”-nek vagy „szélsőérték érzékelés”-nek hívjuk.

A következő kód folyamatosan kiolvassa a gomb állapotát és összehasonlítja az előzőleg kiolvasott értékkel. Amennyiben a két állapot különböző és az aktuális állapota HIGH, akkor a gomb be van nyomva, így a kódban eggyel nő a nyomógomb számlálóértéke. Ezt szintén megvizsgáljuk, és ha az a négy többszöröse, akkor bekapcsolja a beépített (13 pin) LED-ünk, egyéb esetekben kikapcsolja. Továbbra is a második példa alkatrészeit és bekötési ábráját alkalmazzuk.

Arduino kód: 09szelsoertek

Pinek beépített felhúzó ellenállása

Minden pin rendelkezik egy beépített, programozható felhúzó ellenállással. Ez a példa azt mutatja meg, hogyan használjuk az INPUT_PULLUP parancsot a pinMode() függvény segítségével. A kapcsoló állapotát figyeli azáltal, hogy soros kommunikációt létesít az USB porton keresztül az Arduino és a számítógép között. A kommunikáció a (belső) soros porton (más néven: COM) történik, általában ki kell választani, hogy melyiket használjuk. 

Ezen felül a kódban, ha a bemenet HIGH, akkor az Arduino boardba beépített LED bekapcsol, és LOW állapot esetén a LED kikapcsol. 

Kössünk be egy nyomógombot a 7.5.1.számú ábra szerint, az egyik lábát a földbe (GND),  a másikat pedig a digitális 2 pinbe.

Nyomógomb bekötése INPUT_PULLUP példához

A nyomógombok vagy a kapcsolók alapállapotban nyitva vannak (amennyiben ilyen típust használunk, hiszen több fajta létezik), ami azt jelenti, hogy a két lába között nincs kapcsolat. Mivel a belső ellenállás a digitális 2 pinen aktív és 5 V-ra van csatlakoztatva (mivel ennyi feszültséget kap az USB-ből az Arduino, tehát ennyi jön a digitális pinből is), ezért ekkor HIGH jelet olvasunk ki. Ha a gombot lenyomjuk vagy bekapcsoljuk a kapcsolót, azzal zárjuk az áramkört, így – mivel közvetlen lesz a kapcsolat a földeléssel – LOW jelet kapunk.

 A kódban először létrehozzuk a soros kommunikációt 9600 bit/sec-on, majd engedélyezzük a 20 kiloohmos belső felhúzó ellenállást, illetve beállítjuk kimenetként a 13 LED-pint. Utána egy változó segítségével kiolvassuk a gomb állapotát, amelynek decimális értékét kiíratjuk serial monitoron – jelen esetben ez 0 vagy 1 lesz (0 = benyomva, 1 = alapállapotban).

Arduino kód: 10felhuzo

Dallam lejátszása tone() függvénnyel

Bekötése: A 8 ohmos kis hangszóró (0,25 wattos elég) pozitív oldala a 100 ohmos ellenálláson keresztül a digitális 8 pinbe, a negatív szára a földelésbe (GND) megy.

Hangszóró bekötése

Szükségünk van a „pitches.h” file-ra, melyhez a következő kódot egy alap szövegszerkesztőbe be kell illeszteni és elmenteni a file-t ezen a néven. A .h a header file kiterjesztése, ez tartalmazza a függvény meghatározásokat és definíciókat a library számára.

Az arduino mappa libraries mappájában hozzuk létre a Melody nevű mappát és tegyük bele a most készített pitches.h file-t – csak így fog működni. Az Arduino program újraindítása után bekerül a Sketch/Import Library legördülő menübe a Melody, innen fogjuk használni. Nyissunk egy új sketch-t, és másoljuk be az Arduino kódot (lejjebb található). Az #include „pitches.h” sort kitörölhetjük, majd vegyük elő az előbb említett legördülő menüből a melody-t, így megjelenik a következő sor: #include <pitches.h>. Most már működik a kód.

A pitches.h file kód letöltése.

Arduino kód: 11dallam

Írjuk át a kódot tetszőleges dallamra!

Amennyiben standard library-ket akarunk használni a hivatalos oldalról, akkor letöltés után előbb telepíteni kell azokat. Kicsomagolás után egy .h és egy .cpp kiterjesztésű file-t találunk. Az arduino mappában lévő libraries mappába kell elmenteni, bár az már alapból tartalmazza őket. Esetleg itt létrehozhatunk egy saját library-t is. Az Arduino program újraindítása után a Sketch/Import Library menüből elérhetőek és használhatóak.

Tone Library: https://code.google.com/p/rogue-code/wiki/ToneLibraryDocumentation 

Generált hajlítás lejátszása tone() függvénnyel

Következő feladatunknál megtartjuk az előzőleg beszerelt 100 ohmos ellenállást és a 8 ohmos (0,25 wattos) kis hangszórót és bekötünk még egy fotóellenállást is egy 4,7 kiloohmos ellenállással.

Fotóellenállást eddig nem használtunk. Ez egy olyan alkatrész, amelynek vezetőképessége fény hatására – a fényelektromos hatás következtében – megnő, ezért fényérzékelőként használható. (LDR = Light Dependent Resistor) Működését tekintve minél jobban megvilágítjuk a fényérzékeny rétegét, annál kisebb lesz az ellenállása. Legnagyobb érzékenységét egy megadott fényhullámhossznál éri el, így vannak speciális fajtái, amelyek adott színekre érzékenyek, ezt spektrális érzékenységnek hívjuk. Jellemző tulajdonságai a világos-ellenállás értéke, melyet megvilágítással lehet elérni: 1000 luxhoz számolják és 100 ohmtól 2 kiloohmig terjedhet a skála; a másik a sötét-ellenállás érték, ami megvilágítás nélküli állapotában jellemző, ez megaohm nagyságrendű.

Fotóellenállás rajzjele

Fotóellenállás (LDR)

Bekötése: A hangszóró pozitív szára az ellenálláson keresztül a 9 pinbe, negatív oldala a földelésbe kerül bekötésre. A fotóellenállás egyik lábát (mindegy, milyen irányba kötjük be) az 5 V-ba, a másikat az analóg 0 pinbe és a 4,7 kiloohmos ellenálláson át a földelésbe is bekötjük.

Hangszóró bekötése fotóellenállással

Az analóg szenzorból kiolvasott értéket követi le majd a generált hangunk, ezáltal egy hajlítás jön létre. A kód nagyon egyszerű, a kiolvasott analóg értékeket szétosztja a hallható hangok értékéhez arányosítva (ebben az esetben leszűkítjük ezt a tartományt 120–1500 Hz közé). Az analóg szenzor által használt tartományt is beállítjuk 0–1023 helyett most 400–1000 közé, hogy jobban működjön a kód. A map() utasításban lévő paraméterek átállításával kísérletezhetünk.

Arduino kód: 12hajlitas

Analóg billentyűzet tone() függvénnyel

A következő feladathoz szükségünk lesz a 8 ohmos hangszórónkra a 100 ohmos ellenállással és három erőkifejtés-érzékelő ellenállásra, valamint hozzájuk három 10 kiloohmos ellenállásra. 

Az FSR = Forse Sensitive Resistor, azaz erőkifejtés-érzékelő ellenállás olyan alkatrész, amelyben összenyomás hatására megváltozik az ellenállás: minél erősebben nyomjuk össze, annál kisebb lesz, tehát annál több áram jut át rajta.

Elektronok útja az FSR-ben.
Bal oldalon az alap, jobb oldalon az összenyomott állapot látható.

Több méretben, formában kapható

Bekötése: A hangszóró negatív lába a földelésbe, a pozitív a 100 ohmos ellenálláson keresztül a 8 pinbe kerül bekötésre. A nyomásérzékeny ellenállásokat párhuzamosan bekötjük az 5 V-ba, másik lábukat pedig az analóg 0, 1, 2 pinbe, valamint a 10 kiloohmos ellenállásokon át a földelésbe is a 7.8.3 számú ábra szerint.

Analóg billentyűzet bekötése

Arduino kód: 13analoghang

A kód kiolvassa a szenzorok értékeit – mindegyik egy hangnak felel meg a hangértékeket tároló tömbben. Ha a szenzorok értékének bármelyike a megadott küszöbérték felett van, akkor a hozzárendelt hang megszólal.

Ugyanazt a pitches.h fájlt használjuk, mint a dallam lejátszáskor. (Létrehozása a 7.6 alfejezetben található.) Ez tartalmazza a szokásos hangjegyek Hz-ben definiált generált hangját, pl. NOTE_C4 a közepes C hang.

Hang lejátszása több kimeneten tone() függvénnyel

Ez a példa megmutatja, hogyan játsszunk le különböző hangokat három hangszórón, több digitális kimenet használatával. A tone() utasítás az Atmega egyik belső időzítőjét használja, beállítja azt az általunk megadott frekvenciára és az időzítővel rezegteti a kimeneti pint. Mivel egy időzítőt használ, csak egyesével tudjuk lejátszani a hangokat, azonban több pinen egymást követően több hangot is lejátszhatunk. Ehhez ki kell kapcsolni az időzítőt az adott pinen, mielőtt a következő pinnel használni kezdjük.

A kód sorban minden egyes hangszórón egy hangot játszik le, úgy, hogy ez előző hangszórót előbb kikapcsolja – a hangok hosszát ebben az esetben a késleltetés idejével szabályozzuk.

 Alkatrészek bekötése: A 100 ohmos ellenállásokon át a digitális 6, 7, 8 pinbe kötjük a hangszórók pozitív oldalát, a negatívokat pedig a földelésbe.

Több hangszóró bekötése 

Arduino kód: 14tobbhangszoro

TONE library letöltése: https://code.google.com/p/rogue-code/downloads/detail?name=Arduino-Library-Tone.zip&can=2&q= 

forrás: http://arduino.cc/en/Tutorial/HomePage, http://en.wikipedia.org/wiki/Photoresistor, http://en.wikipedia.org/wiki/Force-sensing_resistor, http://www.openmusiclabs.com/learning/sensors/fsr/

Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg.

Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

LED villogtatása, kiolvasás digitális pinből

1 db 220 ohmos ellenállásra és 1 db 5 mm-es LED diódára lesz szükségünk. A LED negatív lába megy a földbe (rövidebb szára), a pozitív (hosszabb) pedig az ellenálláson keresztül a 13 digitális pinbe (ami a beépített LED kivezetése). Az ellenállásra a LED-hez jutó feszültség csökkentése miatt van szükségünk. Az átlagos 5 mm-es LED-ek kb. 20 mA-t fogyasztanak és 2,2–3,4 V-tal működnek. Az adott LED paramétereit a gyártó adatlapja tartalmazza. Az ellenállások színkódolása mutatja meg az értéküket. De használhatjuk az online kalkulátorokat is.

LED bekötése

Az alább található kódban először kimenetként beállítjuk a LEDhez kötött pint: pinMode(13, OUTPUT); Majd a loop ciklusban bekapcsoljuk a LED fényét a digitalWrite(13, HIGH); paranccsal. Ennek hatására az arduino 5V feszültséggel látja el a LED-et (ez túl sok lenne, de már ellenállás bekötésével lecsökkentettük az értékét). Ez után kikapcsoljuk a fényét a digitalWrite (13, LOW); sorral, ilyenkor a pin állapota 0V-os. Hogy a két állapot közötti változást a szemünk is le tudja követni, lelassítjuk a villogást, úgy hogy delay()-jel várakoztatjuk a program lefutását, azaz a megadott idő alatt nem történik változás, tehát ha ég a LED akkor úgy is marad adott ideig az állapota. A delay() időtartamát mikiszekundumban adjuk meg, 1000 ms = 1 másodperc.

Arduino kódja: 01LEDvillogás

Nyomógomb használata, kiírás digitális pinre

Szükségünk lesz 1 db nyák mikro nyomógombra, 1 db 10 kiloohmos ellenállásra, illetve dugaszolós próbapanelre. Az ábrán látható módon kössük össze őket. A nyomógomb azért van középen, hogy a lábai ne legyenek egymáshoz bekötve, mivel a próbapanel közepén nincs átvezetés.

A dugaszolós próbapanel összeköttetései

Nyomógomb bekötése

Amikor a nyomógomb nyitott állapotban van (nincs megnyomva), akkor nincs összeköttetés az 5V pinbe és a digitális pinbe bekötött lábai között, ezért a digitális pinből kiolvasott jel értéke LOW azaz 0V. Ilyenkor a földeléssel (Gnd pin) áll összeköttetésben (az ellenálláson keresztül) az 5V pin. Amikor a nyomógomb zárt állapotba kerül (le van nyomva), akkor záródik az áramkör az 5V pin és a digitális pin között, ekkor a beérkező jel értéke HIGH azaz 5V.  Az alábbi kóddal ez a példa úgy működik, hogy ha lenyomjuk a gombot, világít a LED.

Fordított módon is beköthetjük a nyomógombot, úgy hogy az ellenállást úgy hogy a gombhoz érkező poyitív és negatí oldalakat felcseréljük. Tehát az ellenálláson keresztül HIGH jel érkezik a digitális pinbe, amikor a gomb alap állapotban van (nincs megnyomva). LOW jel érkezik amikor lenyomjuk. Ebben az esetben az alábbi kódot használva, akkor alszik ki a LED fénye, ha a gombot lenyomjuk, azaz a földeléssel zárjuk össze a digitális pint.

Arduino kódja: 02Nyomogomb

A jobb felső sarokban lévő gombbal tudjuk megnyitni a serial monitort. Vagy 0-t vagy 1-t ír ki, attól függően, hogy meg van-e nyomva a gomb.

Potméter használata, kiolvasás analóg pinből

A potméter egy változtatható feszültségű ellenállás, egy 10 kiloohmos szükséges a páldához. A belőle nyert változó adatokat fogjuk kiolvasni, de ugyanezen elven bármilyen analóg szenzor beköthető.

A potméter tengelyének elfordításával az ellenállás értékét változtathatjuk a középső és minkét szélső kivezetése között, ilyenkor a középső kivezetés feszültség értéke változik. Amikor az 5V pinhez futó és a középső pin közötti ellenállás megközelítőleg nulla (ilyenkor a másik szélső lábon megközelítőleg 10KOhm az ellenállás ebben a példában), akkor a középső pin feszültsége megközelítőleg 5V. Ha teljesen elfordítjuk a tengelyt, azaz megnöveljük az ellenállást, a feszültség 0V lesz. Ezt a feszültség érték változást fogjuk kiolvasni az Arduino analog bemmentén.

Az Arduino egy olyan belső áramkörrel rendelkezik, ami az analóg jelet digitálissá alakítja (analog-to-digital converter). Az analóg bement kiolvasáshoz az analogRead() funkciót fogjuk használni, ami egy számértéket ad vissza 0 és 1023 között (a használt feszültséghez arányosítva, pl. 5V = 1023; 0V = 0). 

Bekötése: Ha a lábai előre mutatnak, akkor balra tekerjük el teljesen a forgógombot, hogy beszerelés közben ne továbbítsa az áramot. Első lába az 5 V pinbe megy, a középső az analóg A0-ba, a harmadikat pedig le kell földelni a GND pinbe.

Potméter bekötése

A kód setup függvényében az egyetlen dolog amit csinálunk, hogy bekapcsoljuk a soros port kommunikációt az Arduino és a számítógépünk között 9600 bit/sec adatsebességgel: Serial.begin(9600); Ez után a loop cikluson belül meghatározunk egy integer (egész számértéket tároló) változót, amiben a potméterből kiolvasott adatot (0-1023) tároljuk el: int sensorValue = analogRead(A0); Majd a soros ablakban (serial monitor) megjelenítjük az adatok decimális értékét, sortördeléssel: Serial.println(sensorValue, DEC). A kezelőfelületen a jobb oldali felső ikonnal tudjuk megnyitni az ablakot. Ahogyan tekerjük a potmétert úgy változik a megjelenített adat.

 Arduino kód: 03AnalogPin

Analóg jel feszültség értékének kiírása serial monitoron

A feladathoz az előző példának megfelelően kötjük be a potméterünket, tehát ismét analóg feszültségváltozást olvasunk ki.

A következő példakód serial monitorra írja ki a beérkező feszültség értékét, amihez – a pontosabb eredmény eléréséhez – egy float változót definiálunk. A kód ugyanúgy kezdődik mint az előző esetben, bekapcsoljuk a soros portot és eltároljuk a potméterből kiolvasott értéket egy integerben. Ez után a feszültség értékhez létrehozunk egy float (tizedes tört értékek tárolására alkalmas) változót, amiben a potméterből jövő adat feszültség értékét eltároljuk: float voltage= sensorValue * (5.0 / 1023.0); Vágül ezt megjelenítjük a soros ablakban: Serial.println(voltage).

Arduino kód: 04AnalogFeszultseg

Impulzus-szélesség moduláció, PWM pinek működése

Ez a jel is 0-t és 1-t tud értékként felvenni, mint minden digitális jel. Amplitúdója állandó, de változó szélességű impulzusokból áll, így befolyásolható a kimeneten létrejövő tényleges feszültség.

PWM jel
(kép: www.cnv.hu/gallery/cikkek/elektronika/ pwm%20magyarazat.jpg)

LED fényerejének szabályozása PWM-mel

Ebben a feladatban azt vizsgáljuk meg, hogyan lehet a digitális jel manipulációjával szabályozni a feszültséget. Az Arduino néhány digitális pinje mellé oda van írva a PWM, ezek közül használjunk egyet.

Bekötése: a LED pozitív lábát az ellenálláson keresztül – ugyanúgy, mint eddig – a 9-PWM digitális pinbe, a negatív lábát a földbe (Gnd) kötjük.

LED bekötése PWM pinbe 

Az analogWrite() funkciót használjuk. A PWM hihetetlenül gyorsan kapcsolja a pin állapotát ki-be, így idézi elő az analóg jelre emlékeztető elhalványuló effektust. 0–255 közötti értéket küldhetünk a PWM pinekre, pl. az analogWrite(127); 50%-ot jelent. Az ábrán a zöld vonalak az időt jelölik, 2 milliszekundumonként.

PWM jel magyarázata LED-hez

Először létrehozunk változókat: a LED a 9 pinbe van kötve. A fényerőnek, és az értéknek amivel változtatjuk majd, szintén létrehozunk integer tárolókat. A setupban kimenetként megadjuk a LED pint. A loop ciklusban analogWrite() segítségével megadjuk melyik pinre (led) és mekkora értéket (brigthness) akarunk küldeni. A PWM pin 0-255 közötti értéket fogad. A fényerő értékét folyammatosan változtatjuk, egy fix értékkel (fadeAmount) növeljük, ilyenkor a LED egyre világosabb. Ez addig zajlik még el nem éri a szélső, 255 értéket: if (brightness == 0 || brightness == 255) {fadeAmount = -fadeAmount ;}Ekkor a folyamat megfordul, mivel negatív előjelűre vált a léptetés mértékét eltároló változó, így az érték 5-ösével csökkenni fog amíg el nem éri a nullát, tehát a LED fénye halványodik. Az if feltételben azt látjuk hogy ha a fényerő értéke eléri a nullát VAGY a 255 csak akkor teljesül a feltétel, azaz csak akkor fut le a kapcsos zárójelen belül található programrész, aminek hatására megfordul a folyamat iránya. Mivel az analogWrite() nagyon gyorsan tudja változtatni a PWM értékeket, a kód végérén található egy késleltetés (delay), hogy lássuk a végbemenő változást.

Arduino kód: 05PWMfade

forrás: http://arduino.cc/en/Tutorial/HomePage 

Lektorált tananyag, ami a BKF Digitális és Kollaboratív Művészet (DIKOM) pályázatnak keretén belül valósult meg.

Szerző: Harsányi Réka, Társszerző: Juhász Márton András, Lektor: Fernezelyi Márton

Mi az Arduino? Egyrészt egy mikrokontroller, másrészt a programozási környezet neve. Több fajtája létezik, mi az órán az Arduino Duemilanove-t használjuk. Az Arduino egy nyílt forrású, gyors prototipizáláshoz ideális mikrokontroller modul. Használata a világos felépítésű elektronikának és jól értelmezhető programnyelvnek köszönhetően könnyen és gyorsan elsajátítható. Hirtelen elterjedése interaktív művészeti alkotásokban, hobbi alkalmazásokban és gyors vezérléstechnikai megoldások kivitelezésében egy jól kiépült nemzetközi tudásbázist hozott létre, hozzáférhetővé téve az elektronika egyszerű használatát minden érdeklődő számára. Sokrétű ki- és bemenetein keresztül fel tudja venni a kapcsolatot bármilyen jellegű szenzorral és programjának megfelelő válaszadásra képes, meghajtva lámpákat, motorokat, kijelzőket. A mikrokontrollert Arduino nyelven lehet programozni, ami a Wiring nyelvén alapszik, felhasználói felületét pedig a Processing alapja nyújtja. Az Arduino egyedülálló áramkörként is működtethető, vagy összekapcsolható számítógéppel, amin Flash, Processing, MaxMSP, GarageBand, illetve egyéb soros kommunikációra képes programokkal képes együttműködni. A modulokat készen és KIT-ben is meg lehet vásárolni, a programok ingyen letölthetők honlapukról. A kapcsolások és a nyomtatott áramköri tervek szintén hozzáférhetők és magáncélra szabadon felhasználhatók. Az Arduino a 2006-os Ars Electronica digitális közösségek szekciójában is elismerésben részesült. A csapat: Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino, és David Mellis.

A tananyag ezen részét a Massimo Banzi és társai által kidolgozott hivatalos leckék adják, amik Creative Common License-szel rendelkeznek:

Arduino Duemilanove részei

A Duemilanove 2009-es modell, ATmega168 típusú vagy ATmega328 típusú mikrokontrollerrel felszerelt verzióban létezik. 14 digitális ki-/bemenete van amiből 6 speciális PWM funkciót is képes ellátni, 6 analóg bemenettel rendelkezik, valamint egy 16 MHz-es osszcillátorral, egy USB, egy hálózati és egy ICSP csatlakozóval rendelkezik. Egy reset (újraindító) gomb is található rajta. Minden alkatrészt tartalmaz, ami a mikrokontroller működéséhez szükséges, így ha csatlakoztatjuk USB kábelünkkel (5V) a számítógéphez, megkezdhetjük használatát, de akár elemet, akkumulátort vagy AC-to-DC adaptert (a nagyfeszültséget átalakítja kisfeszültségű egyenárammá) dughatunk a hálózati csatlakozójába, ezek ajánlott feszültség értéke maximum 12V lehet. A DC a Direct Current rövidítése, ami kisfeszültségű egyenáramot jelent, ezzel fogunk dolgozni.

A Duemilanove adatai:

• mikrokontroller típusa: ATmega 168 vagy ATmega 328
• működtető feszültségérték: 5V
• bementi feszültség – ajánlott értéke: 7-12V
• bemeneti feszültség – határ értéke: 6-20V
• digitális ki-/bemeneti pinek száma: 14, ebből 6 PWM. 5V-on működnek, mindegyik rendelkezik egy belső felhúzó (pull-up) ellenállással, ami egy speciális paranccsal bekapcsolható (alap állapotban ki van kapcsolva), értéke 20-50 kOhm lehet.
• analóg bemeneti pinek száma: 6, ezek 10 bites felbontáson tudnak egy értéket felvenni 0-1023 között.
• az egyes pinekre jutó áramerősség értéke:  40mA
• a 3.3V elnevezésű pinre jutó áramerősség értéke:  50mA
• flashmemória mérete: 16KB (ATmega168), 32KB (ATmega328) amiből 2KB-ot a bootloader foglal el. A flashmemória egy olyan újraprogramozható, adattárolásra alkalmas eszköz, aminek nincs szüksége tápfeszültségre ahhoz, hogy megtartsa a benne tárolandó adatot. A bootloader magyarul rendszer betöltő program, ezzel képes elindulni az eszköz.
• SRAM mérete: 1 KB (ATmega168), 2 KB (ATmega328).Ez egy statikus memória, amiben a tárolt adat a tápfeszültség megszűnéséig marad meg.
• EEPROM mérete: 512 byte (ATmega168), 1 KB (ATmega328).Elektronikusan törölhető és újraírható, azaz programozható tároló memória. Olyan mint a flashmemória.
• Órajel sebessége: 16 MHz. Ez egy olyan jel, amely két vagy több áramkör tevékenységét koordinálja, szinkronizálja. Egy alacsony és egy magas jelszint között osszcillál.

Áramot kezelő pinek: 

• Vin: bemeneti feszültség, ha külső áramforrást használunk az üzemeltetéshez.
• Gnd: földelés.
• 5V: értelemszerűen 5V jön belőle.

3V3: az alaplapra szerelt FTDI chip által termelt 3,3 V feszültség.

Némelyik pin speciális funkciók ellátására is képes, ezeket a későbbiekben használat közben ismerjük meg.

Speciális funkciókkal ellátott pinek:

• digitális 0(RX) és 1(TX): Ezek a pinek össze vannak kötve a FTDI USB-to-TTL nevű soros chip megfelelő részeivel, ezért soros port kommunikációhoz használhatjuk őket. Az RX fogadja, a TX pedig küldi az adatot. 
• digitális 2 és 3 pin külső megszakításhoz: a csatlakozón fellépő fel- vagy lefutó él hatására fellépő megszakításkéréshez használható, ez a mikrovezérlő valamelyik bemenetének értékváltozására generálódik. Az attachInterrupt() funkcióval használjuk.
• digitális PWM pinek: 3, 5, 6, 9, 10, és 11 (pulse width modulation = impulzus-szélesség moduláció). Az analogWrite() paranccsal 8 biten küldhetünk rá adatot.
• SPI pinek:10 (SS), 11 (MOSI), 12 (MISO), 13 (SCK), SPI busz (Serial Peripheral Interface = soros periféria illesztő) kommunikációhoz használhatjuk, az SPI Library meghívásával.
• LED 13 pin: a beépített LED van ide kivezetve ide.
• Analóg A4 (SDA) és A5 (SCL) pinek: I²C (TWI) busz kommunikációra alkalmasak, Wire Library meghívásával.

Egyéb pinek:

• AREF pin: Alapvetően az analóg pinek 0-5V között mérik a bementi adatot. Ennek felső értéke ezzel a pinnel és az analogReference() paranccsal megváltoztaható.
• Reset pin: ha a shieldet használunk és van rajta reset gomb, akkor használjuk ezt a pint. LOW-ra állítva működik.

Mi a különbség az analóg és a digitális jel között?

Az analóg jel idő és amplitúdó szerint folyamatosan változó jel, számtalan értéket képes felvenni. Lehet szabályos időközönként, periodikusan változó vagy szabálytalan, azaz a két szélsőérték között bármekkora lehet a pillanatnyi értéke. Az amplitúdó a jel nagyságát határozza meg, a frekvencia pedig az ismétlődések időtartamát, ami a periódusidő vagy a hullámhossz.

Analóg jel, szinusz hullám, szabályos (periodikus) jel
kép: http://hu.wikipedia.org/wiki/Hullám

A digitális jel két értéket vehet fel, nullát vagy egyet. Arduino esetében ez azt jelenti, hogy ha bemenetére 5 V feszültség érkezik, az érték 1 lesz, ha nem érkezik semmi, akkor 0. Kimenetként használva ugyanez igaz, ha 1 értékkel 5 V feszültséget küldünk. Az Arduinonak vannak speciális PWM pinjei, erről később lesz szó.

Digitális jel, bináris számrendszerben

Az arduino mikrokontrollerben található egy Analog-to-Digital-Converter (ADC), ami a bemeneti analóg feszültségjelet átalakítja egy digitális jellé. Konkrét példán keresztül a későbbiekben ismerjük meg a használatát.

Arduino fejlesztőkörnyezet telepítése

Az Arduino Boardhoz egy Arduino nevű open source fejlesztőkörnyezet tartozik, aminek legfrissebb verziója a hivatalos oldalról letölthető háromféle operációs rendszerhez: Windows-hoz, Mac OS X-hez és Linuxhoz. A letöltött fájlt kicsomagoljuk, ha kell, és máris futtathatjuk az Arduino szoftvert, nem kell külön telepíteni. Letöltés erről a linkről lehetséges: http://arduino.cc/en/Main/Software

A Windows automatikusan telepíti az USB drivert, ha rákötjük az Arduinot. Macintoshon le kell tölteni, majd telepíteni kell. Az interneten FTDI USB Serial Driver néven találjuk meg.

A következők szerint töltsünk fel az Arduino Boardunkra egy minta fájlt, hogy le tudjuk ellenőrizni, megfelelően működik-e:

• Nyissuk meg az Arduino szoftvert!
• Keressük ki a mintapéldák között a Blink fájlt: File/Examples/1. Basics/Blink!

·      Állítsuk be az általunk használt Arduino típusát. Ezt a Tools/Board lenyíló menüben tehetjük meg, úgy hogy klikkeléssel áttesszük a pipát az adott típushoz.

·      Ezután ellenőrizzük a soros port beállítását a Tools/Serial Port menüben! Hogy épp melyiket használjuk (COM1, COM2, COM3, stb.), az Eszközkezelőben (Device Manager) meg tudjuk nézni. Egyszerűbb, ha megpróbáljuk feltölteni a kódot, és ha nem sikerül, akkor átállítjuk a portot egy másikra.

A második gombbal Upload tudjuk feltölteni a kódot a mikrokontrollerünkre. Done Uploading felirat jelzi, ha ez sikerült. Ekkor a beépített sárga LED villogni kezd úgy, hogy 1 másodpercig ég és 1 másodpercig nem, míg ki nem húzzuk az áramból, azaz az USB-ből.

Gombok balról jobbra: Ellenőrzés, Feltöltés, Új ablak, Megnyitás, Mentés és a jobb oldalon a Serial Monitort bekapcsoló gomb.

Az alapokról, a fejlesztőkörnyezetről, hibakeresésről, gyakran ismételt kérdésekről stb. további információkat online, angol nyelven, a Help menüpont alatt találhatunk.

Programozás: szükséges minimum kód

Az Arduino által használ kódok, más néven Sketch-ek kiterjesztése a régebbi verzióknál .pde volt, de az 1.0 verzió óta már .ino kiterjesztést használ.

Arduino sketch írásnál a szükséges minimum a setup() és a loop() függvények meghívása (persze ehhez írhatunk saját függvényeket, de e nélkül nem fog működni a kódunk).  Ezek az úgynevezett dedikált funkciók.

A setup funkció a program futtatásakor csak egyszer fut le az elején. Itt adhatjuk meg, hogy melyik pint hogyan akarjuk használni (bemenetként vagy kimenetként). Ekkor inicializáljuk a pineket (értékadás 0-val), illetve hívjuk meg a soros portot.

A loop funkció, mint a neve is mutatja, többször fut le egymás után. Itt változtathatjuk meg a bemeneti és kimeneti adatokat.

Ezek dedikált funkciók, tehát be vannak építve a fejlesztőkörnyezetbe. Voiddal kell őket meghívni.

Szintaxisok:

Setup: A kód legelején definiáljuk benne a változókat (inicializálás), pin módokat,
könyvtár használatát stb. Csak egyszer fut le.

void setup() {
  // ide tesszük az állandókat
}

Loop: A setup után következik, folyamatosan, azaz többször fut le, lehetővé teszi, hogy
a program változzon és reagáljon.

void loop() {
  // a változók helye  – ismétlődik a lefutás
}

További szintaxisok:

; pontosvessző

Az állítások lezárására használjuk.

int a = 13;

{ } kapcsos zárójel

Az arduino programnyelv legfőbb eleme, különböző konstrukciókban használjuk. 

Ha van egy nyitó kapcsos zárójel, akkor mindig kell, hogy legyen egy hozzá tartozó záró is. Az Arduino fejlesztőkörnyezetébe be van építve, hogy ha az egyik zárójelet kijelöljük, megmutassa, melyik tartozik hozzá. Hasznos tipp, hogy ne felejtsük el bezárni a zárójelet, tegyük ki egyből mind a kettőt, utána írjunk be közé. Függvényeknél, ciklusoknál és feltételeknél használjuk.

// megjegyzés

Két darab perjel mögé beírhatunk magunknak megjegyzéseket a programsorba, melyeket a fordítóprogram figyelmen kívül hagy, így nem tölti fel őket az Atmega chipre.

Ez a kommentelés csak egy sorra vonatkozik. Ha több sort akarunk írni, a csillagos perjeleket használjuk:

/* ide jön

több sor
megjegyzés */

forrás:

https://miau.gau.hu/mediawiki/index.php/Analóg_és_digitális_jel 

http://arduino.cc/en/Guide/Environment, http://arduino.cc/en/Main/arduinoBoardDuemilanove,