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

Mint azt a soros kommunikációról szóló fejezetben már érintettük, a char olyanadattípus, amely 1 byte memóriát foglal és az ASCII táblázatnak megfelelően egy karakter értékét tárolja. Mivel a karakterek mindig számként tárolódnak, ezért műveleteket is végrehajthatunk rajtuk, például „A” + 1 = 66 – mert az A értéke a táblázatban 65.

Az egyszerű karakterláncokat, vagyis a karaktereket tartalmazó tömböket is (kisbetűvel) stringeknek nevezzük, és a string osztály példányait is (nagybetűvel) stringeknek hívjuk. Tehát karakterláncot kétféleképpen tudunk definiálni, string adattípusként – amin a string osztály függvényeivel komplexebb műveleteket is végezhetünk –, vagy egyszerű karaktertömbként.

Karaktertömbök

Fontos megjegyeznünk, hogy a fordítóprogram a karakterlánc végét egy ASCII 0  (null)  karakterről ismeri meg, így például serial.print() függvény a string nyomtatásakor nem szalad tovább oda nem illő memóriaterületekre. Ez azt is jelenti, hogy mindig egy karakterrel hosszabbnak kell lennie a tömbnek, mint a tárolni kívánt szöveg. A karaktereket tartalmazó tömböket az alábbi példák szerint tudjuk deklarálni:

• Iniciáló értékek megadása nélkül, csak az elemek számával – a fordító lezárja null karakterrel:
  char Str1[15];   

• Karakterenként aposztrófokkal – az utolsó üres helyet a fordító feltölti null karakterrel, de mi is megadhatjuk a sort lezáró karaktert:
  char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};  
  char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};  

• Szövegként idézőjelekben – ha nem adjuk meg az elemek számát, a fordító megszámolja a karaktereket és hozzáadja a végéhez a lezáró null karaktert, ahogy az üres helyet is feltölti:
  char Str4[ ] = "arduino";  
  char Str5[8] = "arduino";  
  char Str6[15] = "arduino";

Bár lehetséges karaktertömb definiálása sorzáró null karakter nélkül – hacsak nem ez a célunk –, kerüljük el, mivel a legtöbb függvény, amit karakterláncokon alkalmazunk, nincs erre felkészítve. Ha a programunk futása közben furcsa, oda nem illő karakterek jelennek meg, akkor valószínűleg ezt a hibát vétettük. 

Hosszú szövegeket így is megadhatunk:

char myString[] = "ez az első sor"
" ez a második sor"
" stb…";

Amikor sokféle szöveggel dolgozunk, például LCD kijelző vagy soros terminál menüjének szövegeit tároljuk, sokkal kézenfekvőbb a stringeket is egy tömbbe gyűjteni. Mivel a stringek önmagukban is tömbök, ezért kétdimenziós tömböt hozunk létre:

char* myStrings[]={"This is string 1", "This is string 2", "This is string 3", "This is string 4", "This is string 5","This is string 6"};

Az adattípus után a csillag (char*) azt jelöli, hogy ez egy mutatókból (pointer) álló tömb. Valójában minden tömb neve pointer, ezért szükséges a megkülönböztető csillag jelölés a tömböket tartalmazó tömbök létrehozásakor.

 Arduino kód: 43string01

A string osztály példányai

A string osztály kifejezetten szöveg alapú adattípusok manipulálására jött létre. Az egyszerű karaktertömböktől eltérően az osztály példányain olyan függvényekkel is végezhetünk műveleteket, mint a vágás, az összefűzés, szövegrészletek keresése és cseréje. Ugyan a string adattípus használata ebből kifolyólag több memóriát igényel, mint a karakterláncé használatuk mégis sokszor megtérül.

String osztály példányait a következő módokon hozhatjuk létre:

• Konstansként idézőjelek közé zárva: 
  String stringOne = "Hello String";
• String() függvény hívásával konstans karaktert átkonvertálva:  
  String stringOne =  String('a');        
• Konstansból objektummá alakítva: 
  String stringOne =  String("This is a string");  
• Több stringből létrehozva: 
  StringstringOne =  String(stringTwo + "with more");  
• Szám típusú változóból: 
  String stringOne =  String(13);  
• Szám típusú változóból, megadva a számrendszer alapját:
  String stringOne =  String(analogRead(0), DEC);
  String stringOne =  String(45, HEX);
  String stringOne =  String(255, BIN);
  String stringOne =  String(millis(), DEC);         
  
  

String osztály további függvényei

charAt()

Visszaadja a string típusú változó n-edik karakterét.

Szintaxisa

string.charAt(n).

Paraméterei

string: az a string típusú változó, amiben;

n: az n-edik karaktert szeretnénk elérni.

setCharAt()

Lecserél egy adott karaktert a string változón belül. Csak a string hosszán belül érvényes.

Szintaxisa

setCharAt(index,c).

Paraméterei

string: string típusú változó neve;

index: a lecserélendő karakter sorszáma;

c: a lecserélendő karakter – char típusú változó.

compareTo()

Két stringet hasonlít össze, az egyenlőségüket vizsgálja, egyenlőtlenség esetén pedig az ABC sorrendben betöltött sorrendjüket.

Szintaxisa

string.compareTo(string2).

Paraméterei

string: az egyik összehasonlítandó string;

string2: a másik összehasonlítandó string.

Kimenete

negatív érték: string előrébb való string2-nél;

0: a két string megegyezik;

pozitív érték: string2 előrébb való string-nél.

Arduino kód: 44string02

Stringek egybevetésekor használhatunk összehasonlító műveleti jeleket is, mint az egyenlő == , nem egyenlő != , kisebb/nagyobb < > , nagyobb egyenlő >= , kisebb egyenlő <= , az equals() és equalsIgnoreCase() függvényeket is. A két függvény közül az előbbi megegyezik a == jellel, az utóbbi csak abban tér el, hogy figyelmen kívül hagyja a kis- és nagybetűk közötti különbségeket. Számokat is tartalmazó szövegek összehasonlításakor vegyük figyelembe, hogy a fenti függvények a stringeket karakterenként vetik egybe, így például könnyen 999 > 1000 eredményre jutnak, mivel a 9 később következik a számok sorában, mint az 1.

concat()

Összekapcsol két stringet úgy, hogy a másodikat folytatólagosan az elsőhöz ragasztja és a produktumot egy új stringbe tölti. Szám típusú változókat is hozzáadhatunk vele egy szöveghez.

Szintaxisa

string.concat(string,string2);

string.concat(string2);

string += string2.

Paraméterei

string: első változó;

string2: második változó.

Arduino kód: 45string03

startsWith()

Megvizsgálja, hogy egy string azzal a karakterlánccal kezdődik-e, mint amit egy másik tartalmaz, és igaz/hamis választ ad vissza.

Szintaxisa

string.startsWith(string2).

Paraméterei

string: string, aminek az elején keresünk;

string2: string, amit keresünk.

Arduino kód: 46string04 

endsWith()

Megvizsgálja, hogy egy string azzal a karakterlánccal végződik-e, mint amit egy másik tartalmaz, és igaz/hamis választ ad vissza.

Szintaxisa

string.endsWith(string2). 

Paraméterei

string: string, aminek az elején keresünk;

string2: string, amit keresünk.

Arduino kód: 47string05

indexOf() és lastIndexOf()

Szövegen belüli keresést hajthatunk végre a segítségükkel, mely során a keresendő minta lehet karakter (char) vagy string típusú is. Alapértelmezésként az indexOf() a string elejétől kezdi a keresést, de megadhatunk kezdő pozíciót is. A lastIndexOf() abban különbözik, hogy képes a string végéről visszafelé keresni. Mindkét függvény a találat tömbön belüli indexét adja vissza és –1-et, ha nem talál egyezést.

Szintaxisuk

string.indexOf(val);

string.indexOf(val, from);

string.lastIndexOf(val);

string.lastIndexOf(val, from).

Paramétereik

string: amiben keresünk;

val: amit keresünk, lehet char vagy string;

from: a karakter pozíciója a tömbben, ahonnan a keresés indul.

Arduino kód: 48string06

length()

Visszaadja a string karaktereinek számát a lezáró null karakter nélkül.

Szintaxisa

string.length(). 

Paramétere

string: aminek a hosszára kíváncsiak vagyunk.

trim()

Levágja a szöveget megelőző vagy követő üres helyeket és az eredményt visszatölti az eredeti változóba. Az szünetnek látszó üres karakterek például: SPACE (ASCII 32), tab (ASCII 9), függőleges tab (ASCII 11), sor elejére ugrás (ASCII 13), új sor (ASCII 11).   

Szintaxisa

string.trim().

 Paramétere

string: amit szeretnénk megváltoztatni.

Arduino kód: 49string07 

substring()

Egy string tetszőleges részletét adja vissza, amit a tömb indexeivel határolhatunk. A kezdőpozíción található karakter még bele fog esni a kimásolt karakterláncba, míg a végpozíción található karakter már nem. Ha nem adunk meg végpozíciót, akkor az automatikusan a karakterlánc vége lesz.

Szintaxisa

string.substring(from);

string.substring(from, to). 

Paraméterei

string: amiből karakterláncot másolunk;

from: a tömb indexe, ami a kezdőpozíciót jelöli;

to: a tömb indexe, ami a végpozíciót jelöli.

Arduino kód: 50string08

replace()

Kicserél két karakterláncot egy stringen belül, de csak akkor, ha amire cserélünk, nem hosszabb, mint az egész string. Máskülönben a fordító hiba nélkül továbblép és az eredeti string változatlan marad.

Szintaxisa

string.replace(substring1, substring2).

Paraméterei

string: a karakterlánc, aminek egy részét cseréljük;

substring1: amit ki szeretnénk cserélni;

substring2: amire ki szeretnénk cserélni.

Arduino kód: 51string09

toLowerCase()

Átalakítja egy stringben a nagybetűket kisbetűkké és visszatölti az eredményt az eredeti változóba. Ezzel szemben a toUppercase() a kisbetűket alakítja nagybetűkké.

Szintaxisa

string.toLowerCase();

string.toUpperCase().

Paramétere

string: amin a változtatást végrehajtjuk.

getBytes()

Előfordulhat, hogy szeretnénk a string típusát átalakítani. Ha byte-okat tartalmazó tömbként szeretnénk a karakterláncot kezelni, akkor ez a függvény kimásolja a string tartalmát byte-onként egy tömbbe.

Szintaxisa

string.getBytes(buf, len).

Paraméterei

string: string változónk, aminek a tartalmát másoljuk;

buf: byte[] (byte tömb) típusú változónk, ahová másolunk;

len: a byte tömbünk hossza (unsigned int típusú).

toCharArray()

Hasonlóan az előzőhöz, kimásolja a string tartalmát és egyszerű karaktereket tartalmazó tömbbe tölti.

Szintaxisa

string.toCharArray(buf, len). 

Paraméterei

string: string változónk, aminek a tartalmát másoljuk;

buf: char[] (karakter tömb) típusú változónk, ahová másolunk;

len: a karakterlánc hossza (unsigned int típusú).

- - - - - - - - - -  

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

Az elektromágneses mező

Az elektromágneses teret az elektromos mező változása, azaz az elektronok áramlása idézi elő. Az elektromos mező a töltéssel rendelkező részecskékből származik, a mágneses mező pedig ezek mozgásából, a kettő együtt eredményezi az elektromágneses teret. Általában a mágneses mező irányát és nagyságát az úgynevezett erővonalakkal jelezzük, ezek a mágnes északi sarkától a déli felé haladnak. Szemléltetni úgy lehet, hogy vasreszelék fölé helyezett mágnes hatására a reszelék összefüggő vonalakká rendeződik.

Mágneses tér iránytűkkel (© Nevit Dilmen found at Wikimedia commons)

Minden vezetőnek, amiben áram folyik, van mágneses tere, melynek erővonalai koncentrikus körök formájában körülveszik a vezetőt

Az elektromágnes esetén egy tekercsbe helyezett lágyvas hozza létre a mágneses teret addig, amíg a tekercsen áramot vezetünk át. Formájukat tekintve lehetnek rúd, patkó vagy gyűrű alakúak, ezeknek eltérő a mágneses áramlásuk. A legjobb a teljesen zárt vasmaggal rendelkező elektromágnesé.

Az elektromágneses indukció

Mágneses térben mozgó vezetőben elektromos feszültség keletkezik. Ez teszi lehetővé a dinamók, a villanymotorok és a transzformátorok működését. Két csoportra lehet osztani ezt a jelenséget, a nyugalmi és a mozgási indukciókra. Nyugalmiba pl. a transzformátorok, a mozgásiba pl. a motorok tartoznak. Nyugalmi esetén a fluxus (egy erőtérnek egy adott felületen való áthatolását jellemző mennyiség) hozza létre az indukciót, mivel sem a vezető, sem a mágneses mező nem mozog.

Számunkra a mozgási indukció megértése fontos, mivel villanymotorokat fogunk használni. Ebben az esetben vagy a vezető, vagy a mágneses mező, vagy mindkettő elmozdul egymáshoz viszonyítva. Legelterjedtebb formája a forgómozgás. A villanymotorok az elektromos energiából nyerik mechanikus energiájukat. 

Három motortípusra térünk ki – mivel ezekből létezik kisfeszültséggel működő változatban is –, ezek a villanymotorok, a léptetőmotorok és a szervomotorok.

Egyenáramú villanymotor

Angolul DC motor. Az elektromágneses indukció elvén működik, az elektromos áramból nyert energiát alakítja át mechanikus energiává, konkrétabban forgó mozgássá.

„Kommutátor: áramfordító, egyenáramú dinamók és motorok, valamint bizonyos fajtájú váltóáramú motorok tengelyére szerelt, vele együtt forgó, egymástól elszigetelt vörösréz-szegmensekből álló henger. Minden szegmenshez egy-egy tekercsvég kivezetés van forrasztva. A kommutátorra rugók szorítják rá a réz- vagy szénkeféket, melyek az áramot be, illetve elvezetik. A forgórész valamely vezetőjében az állórész két pólusa között való elhaladásakor az indukált áram iránya megváltozik, azonban a keféken keresztül csak egyirányú áram folyik, mert a tekercsvéghez forrasztott kommutátor szegmens addigra már elhaladt a kefe alatt és a következő tekercs szegmensével nyer érintkezést, melyben még nem változott meg az áramirány.” (hu.metapedia.org)

 „Mágneses fluxusnak hívjuk, ami szemléletesen a felületet metsző mágneses indukcióvonalak száma” (hu.wikipedia.org/fluxus)

„Armatúra:elektromos gépeknek az az alkatrésze, amelyben a feszültség indukálódik.” (kislexikon.hu)

Az egyenáramú motor működése a mágneses pólusok vonzásán és taszításán alapul. A motor két kivezetésére rákapcsoljuk az áramforrás pozítív és negatív kivezetését. Egy mágneses térben elhelyezett tekercsbe ha áramot vezetünk, akkor az indukálódott elektromágneses mező kölcsönhatásba lép az állandó mágnesek erőterével. Ezért az amatúra (a tekercs, ami a motor forgó része) a pólusok vonzó, illetve taszító hatása következtébenelmozdul. Ha az álló és forgórész pólusa azonos akkor vonzzák, ha ellentétes akkor taszítják egymást. Az áramváltást, azaz a pólusok felcserélését a kommutátor biztosítja, abban a pillanatban amikor a forgó és állórész pólusa megegyezik, átkapcsolja ellentétesre, így ismét taszítják egymást ezek az alkatrészek, ezért folytatódik a forgás. Az erőtér és az armatúra különféle összekapcsolása különböző belső fordulatszámot eredményez. A villanymotor sebességét befolyásolhatjuk az armatúra feszültségének vagy a gerjesztő áramnak a változtatásával. Villanymotor meghajtó mikrochippel is vezérelhetjük őket, úgynevezett H-híddal, melyre később térünk ki. A villanymotor jellemző adatai a feszültség és az áramerősség.

Villanymotorok

Villanymotor szerkezete

Villanymotor álló- és forgórésze

Nagyon kis méretben is léteznek, általában játékokban használják őket.

Egyenáramú villanymotor vezérlése H-híddal

Mivel a villanymotorok – ha szimplán rákötjük őket az áramra – egy irányba és adott sebességgel forognak, ezért ha irányítani akarjuk, egy motorvezérlő áramkörre, úgynevezett H-hídra van szükségünk. Ez egy elektromos áramkör, amit házilag is megépíthetünk, de mikrochip formájában meg is vásárolhatunk. A megfelelő lábakra bekötve a motorunkat, programozással vezérelhetjük a forgás irányát és sebességét. Arduinoval 3 voltos DC motorokat fogunk meghajtani L293N integrált áramkör használatával.

A H-híd két alapállapotának kapcsolási rajza

L293NE H-híd

Szükségünk van egy 10 kiloohmos ellenállásra, egy kétállású SPDT kapcsolóra (on-on), 1 DC motorra (3 V elég, az Arduino csak 5 V-ot bír meghajtani) és egy H-hídra. A H-hídnak mindkét oldalát be kell kötni a feszültségbe és a földelésbe is, de csak azt az oldalát kell bekapcsolni, amelyiket használjuk. (EN lábra kell HIGH jelet küldeni.)

A H-híd lábainak kiosztása

Összeépítés: próbapanelen, egy motorral, de most a 9 V elemet ne kössük rá, mert az USB kábel is elég ahhoz, hogy forogjon egy 3 V-os motor.

DC motor és L293NE h-híd bekötése próbapanelen 

Arduino kód: 42motorhid

forrás: http://arduino.cc/en/Tutorial/HomePage, http://hu.wikipedia.org/wiki/Villanymotor, http://itp.nyu.edu/physcomp/Labs/DCMotorControl, http://hu.wikipedia.org/wiki/Mágneses_mező, 

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

ADXL3xx gyorsulásmérő

Megnézzük, hogyan lehet adatot kinyerni az ADXL3xx sorozat gyorsulásmérőiből. 1, 2 vagy 3 tengely irányában működnek, a rászerelt tárgy Földhöz viszonyított helyzetét mérik, tehát a sebesség változását. Analóg és digitális kimenettel rendelkezőek egyaránt vannak. Ebben a példában az x, y, z tengelyből kinyert adatokat soros portra küldjük. Egyéb gyorsulásmérőt is használhatunk, a datasheetben keressük vissza, melyik lába miként funkcionál.

ADXL3xx gyorsulásmérő és  az Arduino panelbe kötött ábrája. A lábak kiosztás olyan sorrendű, hogy elég rádugni az analóg pinsorra.

ADXL3xx gyorsulásmérő bekötése, áramköri rajz

Több gyártó létezik, közülük most két szenzornak a bekötését nézzük meg.

Az első a Spurkfun által gyártott:

Spurkfun ADXL335 gyorsulásmérő

Spurkfun gyorsulásmérő bekötése Arduinoba:

Spurkfun gyorsulásmérő Arduinoval

A második az Adafruit által gyártott:

Adafruit ADXL335 gyorsulásmérő

Adafruit gyorsulásmérő bekötése Arduinoba:

Adafruit gyorsulásmérő Arduinoval

Az adafruit.com oldalon megtalálható, hogyan lehet kalibrálni ezt a szenzort: http://learn.adafruit.com/adafruit-analog-accelerometer-breakouts/programming

A kódban az analóg 4 és 5 pin speciális funkcióját használjuk. Az I2C kommunikációra a 13. fejezetben a Wire Könyvtár használata kapcsán részletesen kitérünk.

Arduino kód: 38gyorsulasmero

A kiolvasott érték szenzoronként változó, kb. 300–700 közé esik. Az ADXL322 2g gyorsulásmérőnél a vízszintes (amikor a szenzor párhuzamos a földdel) értéke 512 körüli.

Az alábbi táblázat csak nagyságrendi adatokat mutat, és egy tengelyre vonatkozik.

Gyorsulásmérő dőlésszöge és kiolvasott értéke (minta, szenzoronként eltérő):

Piezo szenzor

A piezo elektromos kristályszerkezetben összenyomás hatására feszültség keletkezik. A piezo hangszórók csak megfelelő polaritással működnek, mely azt jelenti, hogy meghatározott irányban kell, hogy átmenjen rajta az áram, ezért a fekete vagy kék vezetékét a földbe, míg a pirosat az analóg pinbe kell kötni. Ezt az analóg pint szintén le kell földelni úgy, hogy az 1 megaohmos ellenálláson keresztül vezetve átkötjük a GND pinbe, ahogy a 11.2.2. ábrán látható. A példában használt típus: Piezo hangszóró 12 V DC gerjesztő áramkörrel.

Műanyag borítás nélkül is beszerezhető a piezo, ilyenkor fényes lemezeknek látszanak és könnyebb őket szenzorként használni, pl. lehet nyomogatni. Akkor működnek a legjobban, ha az érzékelő felületük erősen neki van támasztva valaminek, vagy fel van ragasztva.

Piezo érzékelő

Piezo érzékelő bekötése 

A lejjebb található kódban a piezóból érkező adatok egy általunk megadott küszöbértékhez vannak viszonyítva. Próbáljuk meg növelni vagy csökkenteni ezt az értéket, hogy kihasználjuk a szenzor teljes érzékenységi tartományát. 

Arduino kód: 39piezo

Ultrahangos távolságszenzor

Ping))) ultrahangos távolságszenzor, gyártó: Parallax

A tőle 2–3 cm-re lévő tárgyakat érzékeli.

Az alábbiak szerint működik: Kiküld egy ultrahang jelet és a visszhangot figyeli, ami akkor keletkezik, ha az ultrahang visszaverődik a tárgyról. Az Arduino egy rövid impulzust küld, hogy előidézze az érzékelést, majd ugyanazon a pinen várja vissza az impulzust (ehhez a pulseIn() függvényt használja). A második impulzus időtartama megegyezik azzal az idővel, amit az ultrahang tett meg a szenzorból a tárgyig, majd arról visszaverődve a szenzorig – ezt számítja át a távolság meghatározásához.

Ping))) ultrahangos távolságszenzor

Bekötése: A földelés pineket és a feszültség pineket összekötjük az Arduinoval, a SIG (signal) pint pedig az Arduinon keresztül a digitális 7 pinbe vezetjük.

Ping))) ultrahangos távolságszenzor bekötése

Arduino kód: 40ping

Sharp infravörös távolságszenzor

A távolságszenzorok analóg vagy digitális kivitelben léteznek. Az egyes típusok különböző távolságokban mérnek. Háromszögeléses módszerrel működik, azaz kibocsát egy infravörös fényt, ami a tárgyakról bizonyos szögben visszaverődve a szenzor optikáján át a CCD-re érkezik (hogy azon belül hova, azt a távolság határozza meg).

A kódban kiolvassuk az értéket és serial monitoron kiírjuk. A példában a GP2D12 Sharp szenzort használjuk. Hogy a szenzornak melyik lába a feszültség (Vcc), a föld (Gnd) és az adatkimenet (Vo), azt a datasheetben megtaláljuk. Értelem szerűen a Vcc pint az Arduino 5V pinjébe, a Vo pint az analóg bementi pinbe, a Gnd-t pedig a földbe kötjük.

Sharp GP2D12 adatlapja és bekötése az Arduinoba

Arduino kód: 41sharp

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

If állítás

Az if() állítás a legalapvetőbb vezérlő struktúra. Lehetővé teszi, hogy valami megtörténjen, vagy ne történjen meg, attól függően, hogy a feltétel igaz vagy hamis. Így néz ki:

if (someCondition) {
   // csinálj dolgokat, ha a feltétel igaz
}

Van egy gyakoribb verziója is, amit if-else-nek neveznek:

if (someCondition) {
   // csinálj dolgokat, ha a feltétel igaz

} else {
   // csinálj dolgokat, ha a feltétel hamis
}

Létezik az else-if verzió is, ebben az esetben, ha az első feltétel hamis, akkor a másodikat is megvizsgálja:

if (someCondition) {
   // csinálj dolgokat, ha a feltétel igaz
} else if (anotherCondition) {
   // csinálj dolgokat, ha a feltétel hamis
   // és a második feltétel igaz
} 

Az alábbi példa bekapcsolja a LED-et, ha az analóg bemeneten kiolvasott érték a küszöbérték alá megy.

Bekötése: A LED pozitív lába elé kössünk be egy 220 ohmos ellenállást is, a potméter középső lábát az A0-ba, a két szélsőt az 5 V-ba és a feszültségbe.

Potméter LED-del

Az analogValue nevű változóban fogjuk eltárolni a potméterből kiolvasott adatokat. Ezeket hasonlítjuk majd össze a küszöbértékkel. Ha a felett van az érték, bekapcsol a LED, ha alatta van, akkor kikapcsol.

Arduino kód: 32if

For ciklus

Néha arra van szükség, hogy ismétlődjön a folyamat, pl. pinek sorozatán ugyanaz a parancs fusson le, vagy növelni, illetve csökkenteni akarunk egy változót és újra elvégezni rajtuk az utasításokat. Ilyenkor a for() ciklus a legmegfelelőbb megoldás.

A következő példában digitális 2–7 pinbe egy-egy LED-et kötünk és egymás utáni sorban be- és kikapcsoljuk őket egyik irányba, majd visszafelé is. A cikluson belül a digitalWrite() és a delay() függvényeket fogjuk használni.

Bekötése: Mindegyik piros 5 mm-es LED-ünk pozitív lába elé bekötünk egy-egy 220 ohmos ellenállást, ezeket a digitális 2, 3, 4, 5, 6, 7 pinekbe kötjük, a negatív lábakat pedig leföldeljük.

6 LED bekötése 

Arduino kód: 33for

A loopban két for() ciklus szerepel, az elsőben a 2. pintől indulva lépkedünk a 7-ig, a másodikban fordítva, a 7-estől indulunk, és mindig eggyel csökkentve az értéket eljutunk a 2-ig. Illetve a pineket is for ciklussal inicializáljuk. A for ciklus addig ismétlődik, amíg a kerek zárójelben lévő feltétel teljesül, utána továbblép.

Tömbök

A for ciklus példáját alakítjuk át úgy, hogy a pinek értékeit tömbben tároljuk el, és innen olvassuk ki őket mind az inicializálásnál, mind a loopban szereplő két for ciklusban.

Bekötése: Mindegyik piros 5 mm-es LED-ünk pozitív lába elé bekötünk egy-egy 220 ohmos ellenállást, ezek kerülnek bekötésre a digitális 2, 3, 4, 5, 6, 7 pinekbe, a negatív lábakat pedig leföldeltük.

 6 LED bekötése

Arduino kód: 34tombok

While ciklus

A while ciklus addig fut, amíg a feltétele teljesül. Ebben az esetben, amikor megnyomjuk a gombot, lefut a fotóellenállás kalibrálására vonatkozó parancssor. Ezután a fotóellenállásból kiolvasott analóg értékeket skálázás után kiküldjük a LED fényerejét vezérlő PWM pinre. Minél nagyobb a beérkező érték, annál erősebben világít a LED.

Bekötése: A LED pozitív lábát a 220 ohmos ellenálláson át a 9 PWM pinbe kötjük, a negatívat a földelésbe. A kapcsolóhoz 10 kiloohmos ellenállást használunk, ezen keresztül a bal alsó lábát bekötjük a földelésbe, a jobb alsót az 5 V pinbe, a bal felsőt pedig a 2 pinbe. A fotóellenállás bármilyen irányban beköthető, egyik oldala az 5 V pinbe, a másik szintén 10 kiloohmos át a földelésbe és az analóg 0 pinbe is megy.

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

Arduino kód: 35while

Switch utasítás szenzor kiolvasással

Az if feltételnek két kimenetele lehet, igaz vagy hamis, ettől függően lefut vagy nem fut le a parancs. A switch kifejezésben egyszerre több feltételt vizsgálhatunk, és az fut le közülük, amelyik épp teljesül. Ebben a példában a fotóellenállásból kiolvasott értékekhez rendelünk a fényre vonatkozó definíciókat: sötét (dark), gyenge (dim), közepes (medium), világos (bright). A szenzor érzékelési tartományát a kód elején adjuk meg, most 0–600 közötti, de ennek megváltoztatásával kísérletezhetünk. A beolvasott értéket a map() utasítással 0–3 közötti értékre skálázzuk, ez összesen négy darab lehetőséget eredményez (0, 1, 2, 3), mindegyikhez tartozik egy switch utasítás.

Bekötése: A fotóellenállás egyik lábát az 5 V pinbe, a másikat az analóg 0-ba és egy 10 kiloohmos ellenálláson át a földelésbe is bekötjük.

Fotóellenállás bekötése

Arduino kód: 36switchSzenzor

Switch utasítás soros bemenettel

Most a switch case-t LED-ek bekapcsolására fogjuk használni. Attól függően kapcsol be egyik vagy másik LED, hogy a soros porton a, b, c, d vagy e érték érkezik be. Ha megnyitjuk a serial monitort, le tudjuk őket követni. ASCII táblázatban meg tudjuk nézni, melyik karakternek mennyi a számértéke, pl. „a” = 97, „b” = 98 stb.

Bekötése: Mindegyik piros 5 mm-es LED-ünk pozitív lába elé bekötünk egy-egy 220 ohmos ellenállást, ezek mennek a digitális 2, 3, 4, 5, 6, 7 pinekbe, a negatív lábakat pedig leföldeljük.

6 LED bekötése

Arduino kód: 37switchSoros

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

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