fizikai számítástechnika, arduino

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

Számítástudományban a könyvtár olyan előre megírt kódrészeket jelent, amik meghatározott komplex funkciók elvégzésére képesek. Osztályaik és függvényeik felhasználásával a független programokban nincs szükség ezen feladatok ismételt megoldására. Általánosságban olyan csomagokként értelmezzük őket, amik szolgáltatásként teszik elérhetővé a konfigurációs adatokat, konstansokat és kódokat. Például egy matematikai könyvtár (Arduino esetében a math.h) a programnyelvből közvetlenül nem elérhető függvényeket írja le, mint a tangens, kotangens, logaritmus, gyökvonás.  A rendkívül hasznos függvényeken túl sok esetben bizonyos típusú hardware elemek használatát könnyítik meg – operációs rendszer hiányában ezeket a könyvtárakat felfoghatjuk úgy is, mint eszközillesztő programokat (device driver). Mivel az Arduino egy nyílt forrású, együttműködő közösség által is fejlesztett rendszer, megkülönböztetünk hivatalos és kontribúciós könyvtárakat. Az előbbieket standardként is szokás nevezni, mivel kiforrottságuk miatt a fejlesztőkörnyezet programcsomagjának részét képezik, és olyan általános funkciókat írnak le, amik végrehajtására minden Arduino-típus képes.

Könyvtárak szerkezete

Amikor a két fő rutin mellett (setup és loop) szubrutinokat szeretnénk létrehozni, az a void szubrutin_neve() összefüggés segítségével tehető meg:

Arduino kód: 52voiddot

Ha a fenti kódból könyvtárat szeretnénk létrehozni, akkor legalább két fájlra lesz szükségünk, az egyik az úgynevezett fejléc vagy header fájl (kiterjesztése .h), a másik pedig a forrás vagy source fájl (kiterjesztése .cpp). A fejléc definiálja a könyvtárat – minden kifejezésnek szerepelnie kell benne, amire hivatkozni szeretnénk –, míg a forrásfájl tartalmazza a kódot.

A fejléc már a fájl nevében tartalmazza a könyvtárunk nevét (Morse.h):
53morseH

A forrásfájlba már betöltjük a fejlécet, hiszen a definiált osztályt és szubrutinjait töltjük meg tartalommal (Morse.cpp):
54morseCpp

Végül a kész könyvtárunkkal a fenti példakódunk lerövidült és univerzálisabbá vált – használata pedig így néz ki:
55morsekonyvtar

A fentiek alapján láthatjuk, hogyan épülnek fel a könyvtárak és hogyan kell őket használni. Akár saját könyvtár készítéséhez is hozzáfoghatunk, azonban mielőtt ezt megtennénk, érdemes kutatómunkát végezni, hiszen mérhetetlenül sokféle funkciót lefed a már létező könyvtárak összessége.

SoftwareSerial könyvtár

Az Arduino egyetlen fizikai soros porttal rendelkezik, ami a beépített UART (Universal Asynchronous Receiver Transmitter) terhére mentesíti a feldolgozóegység erőforrásait, amíg a 64 bájtnyi soros átmeneti tárolóban van elég hely. Az integrált port a 0-ás és 1-es digitális csatornákon kommunikál (lásd 9. fejezet), ahol a számítógéphez USB átalakítóval is csatlakozik.

A SoftwareSerial könyvtárat – ahogy a neve is sugallja – azért fejlesztették ki, hogy a feldolgozóegység terhére a többi digitális csatornán is létre lehessen hozni soros kommunikációs felületeket. Segítségével egyszerre kapcsolódhatunk a számítógéphez és más soros eszközökhöz, kijelzőkhöz, digitális szenzorokhoz, vagy kialakíthatunk soros hálózatot több Arduino között. A szoftveres portok maximális sebessége is 115200 baud lehet, ráadásul megváltoztatható a jel polaritása, ami szélesíti a kompatibilis egységek spektrumát, azonban több port létrehozása esetén az adatok egyidejű fogadása nem lehetséges.

Arduino kód: 56softwareserial

A könyvtár függvényei:

• available()
• begin()
• isListening()
• overflow()
• peek()
• read()
• print()
• println()
• listen()
• write()

SoftwareSerial()

Hívásakor létrehoz egy SoftwareSerial objektumot az általunk megadott névvel. Ahhoz, hogy a kommunikációt engedélyezzük, meg kell hívnunk a SoftwareSerial.begin() parancsot is. 

Szintaxisa:

SoftwareSerial(Rx,Tx). 

Paraméterei:

Rx: a szoftveres soros portunk bejövő csatornája,

Tx: a szoftveres soros portunk kimenő csatornája.

Példakód:

SoftwareSerial mySerial =  SoftwareSerial(rxPin, txPin); 

available()

Visszaadja a szoftveres átmeneti tárolóban elérhető, beérkezett bájtok számát. 

Szintaxisa:

mySerial.available(). 

Példakód:

void loop() {
    if (mySerial.available()>0){ // ha már van valami a tárolóban
    mySerial.read(); // olvassuk ki
   }
}

begin()

Beállítja a soros kommunikáció sebességét (baud rate). A szabvány átviteli sebességek: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 31250, 38400, 57600 és 115200.

Szintaxisa:

mySerial.begin(baudrate).

Paramétere:

baudrate: long típusú változó a fenti szabványértékek valamelyike. 

Példakód:

void setup()  {
  // beállítjuk a vevő és adó csatornákat bemenetnek és kimenetnek
  pinMode(rxPin, INPUT);
  pinMode(txPin, OUTPUT);
  // meghatározzuk az átviteli sebességet és megnyitjuk a portot
  mySerial.begin(9600);
}

isListening()

Megnézhetjük vele, hogy a kiválasztott szoftveres soros port valóban aktív-e. Boole típusú választ ad vissza.

Szintaxisa:

mySerial.isListening(). 

Példakód:

void loop() {
    if (portOne.isListening()) { // ha a port aktív, akkor
       Serial.println("A port aktív!"); 
}

overflow()

A szoftveres soros port átmeneti tárolója 64 bájtot képes elraktározni. Amennyiben ezek nem kerülnek időben kiolvasásra, a tároló túlcsordul – a régi adatok helyét nem veszik át az újak és lemaradunk a közölt információ egy részéről. Ezzel a függvénnyel ellenőrizhetjük, hogy történt-e túlcsordulás. Az ellenőrzést követően a függvény válaszát képező Bool változó hamis állapotba kerül.

Szintaxisa:

mySerial.overflow().

Példakód: 

void loop() {
    if (portOne.overflow()) { // ha túlcsordult a tároló, akkor
       Serial.println("A tároló túlcsordult!"); 
}

read()

Karakterenként kiolvassa a soros tárolót. 

Szintaxisa:

mySerial.read().

Példakód:

void loop() {
  char c = mySerial.read();
}

peek()

Hasonlóan a read()-hez, az utolsó a porton beolvasott karaktert adja vissza, ha nem jött semmi –1-et.

Szintaxisa:

mySerial.peek().

print()

Adatokat küld a szoftveres soros port Tx csatornájára. A kiírt bájtok számát adja vissza. 

Arduino kód: 57softwareserial02

println()

Ahogy az a fenti példából is látszik, a küldendő adatot automatikusan kiegészíti a „soremelés” kódjával – ugyanúgy, mint azt a hardware-es soros portnál már láttuk.

listen()

Több szoftveres soros port használata esetén egyszerre csak egy port kaphatja meg az olvasás jogát. Ezzel a függvénnyel beállíthatjuk, melyik port legyen az, amelyik olvashat. Az összes többi portra érkező adatok elvesznek. 

Szintaxisa:

mySerial.listen().

Arduino kód: 58softwareserial03

write()

Az adatokat nyers bájt formátumban küldi ki a portra és visszaadja a kiírt bájtok számát. 

Példakód:

//elküldi a “hello” karaktersort és visszaadja a kiküldött karakterek számát

int bytesSent = mySerial.write(“hello”);

- - - - - - - - - -

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

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