Bevezetés

A www.hobbielektronika.hu weboldalon már írtam néhány cikket, amelyekben az AVR mikrovezérlők használatának az alapjait mutattam be néhány egyeszerű kis robot építésén keresztül. A robotokat vezerlő mikrokontroller programjának a megírása AVR-GCC-ben, az ingyenes WinAVR+AVR Studio4 fejlesztőkörnyezet használatával történt. Felvetődhet a kérdés, hogy akkor most miért is váltottam az Arduino-ra?

A válasz nagyon egyszerű: Úgy alakult, hogy a robotjaim filmekben szereplő robotokra hasonlítottak (WALL-E-ra és JOHNNY 5-ra a Rövidzárlat c. filmből). A mostani robotom is egy filmbeli híres robotra hasonlít (gondolom senkinek sem okoz nehézséget kitalálni hogy kire…). Ebből már nyilvánvalóan következett a névválasztás is (Ar-Du), és az is hogy ez esetben a robot irányítását egy Arduino panel látja majd el.

Ar-Du a hagyományos értelemben nem is igazán nevezhető robotnak, mert nem hoz önálló döntéseket. Ar-Du "csak" egy távirányított eszköz. A robot irányítása a PC-n futó Processing-re írt programmal törtenik.

Mechanika:
A mechanika megalkotásához egy R2-D2-es papírmodell tervrajza szolgált kiindulási alapként. Ezt A3-as papírra nyomtattam ki, amiből néhány helyen később a robot borítását is készítettem:

A helyi barkácsáruházban addig keresgéltem, amíg sikerült megegyező átmérőjű hengeres, gömb és félgömb alakú műanyag alkatrészeket találnom. Ezekből és sík PVC lapokból készítettem el a robot alkotó vázat. 

A robot meghajtásához a törzs alá helyezett bolygókereket és a lábakba szerelt áttételes DC motorokat, a “robotfej” forgatásához pedig egy RC mikroszervót használtam fel.

Elektronika:
A robot elektronikáját az alábbi modulok alkotják:

• Robotvezérlő panel
• Hangulatjelző LED-ek
• Fejmozgató szervómotor
• Motorvezérlő panel
• Hangmodul
• Bluetooth modul
• Ultrahangos távolságmérő szenzor
• JPEG soros kamera

Az alábbi ábrának megfelelően csatlakoztattam az alkatrészeket az Arduino-hoz:

Az Arduino lábkiosztása a következő:

Digitális I/O láb:                                                                    

• Pin0 (Rx) : BT modul Tx láb                                              
• Pin1 (Tx) : BT modul Rx láb                                               
• Pin2 : NewSoftSerial Rx – JPEG kamera Tx                    
• Pin3 : NewSoftSerial Tx – JPEG kamera Rx                     
• Pin4 : Motor1 irány                                                          
• Pin5 : Motor1 sebésseg (PWM)                                        
• Pin6 : Motor2 sebésseg (PWM)
• Pin7 : Motor2 irány
• Pin8 : Hangmodul
• Pin9 : fejmozgató szervó
• Pin10 : Kék LED
• Pin11 : Piros LED
• Pin12 : Ultrahang modul – Trigger láb
• Pin13 : Ultrahang modul – Echo láb

Robotvezérlő panel
Egy normál Arduino túl nagy, nem fért volna el a robotban. Ezért a robot vezérlését egy Arduino kompatibilis RBBB panellal valósítottam meg, amely sokkal kisebb helyet igényel.

Hangulatjelző LED-ek
Ar-Du hangulatának jelzésére egy kék és egy piros LED-et használtam, amit áramkorlátozó ellenállásokkal együtt az Arduino 10-es és 11-es digitális I/O lábára kötöttem.

Fejmozgató szervómotor
A robot “fejének” a forgatását egy RC mikroszervóval oldottam meg, amit az Arduino digitális 9-es bementére kötöttem A szervó vezérlését a servo.h könyvtár használatával oldottam meg. (Az Arduino panel 9-es lába alkalmas szervóvezérlésre ).

Motorvezérlő panel 
A robotot meghajtó DC motorokat egy L293D H-híd IC-vel és egy CD4069-es hex inverterrel vezéreltem. Az L293D 2db H-hidat tartalmaz, ezért egy IC-vel 2db motort tudunk vezérelni. Az EN1 és EN2 lábakra adott PWM jel kitöltési tényezőjét változtatva tudjuk a motorok sebességét változtatni. Az L293D IC-n a motorok forgásirányát motoronként két-két lábbal tudjuk vezérelni (INPUT1+INPUT2 és INPUT3+INPUT4). Az adott motor forgásirányát szabályozó két vezérlőjelnek mindig egymás ellentettjének kell lennie, ezért az alábbi kapcsolási rajznak megfelelően egy inverter IC-t tettem az L293D bemeneti lábpárja elé. Így az Arduino egyetlen lába megadhatja egy motor forgásirányát. Ezzel a megoldással ráadásul megspóroltam két I/O lábat az Arduino panelen.

A motorvezérlő panel kapcsolási rajza:

És igy néz ki próbanyákon megépítve (az 5V-ot előállító 7805-os stabkockával, a fordított tápfesz ellen védő diódával és kapcsolóval kiegészítve):

Hangmodul 
A hangmodulhoz egy ISD1730-as hangrögzítő IC-t használtam. Az IC 20. lábára kötött Rosc értékével lehet beállítani a mintavételi frekvenciát (és ennek függvényében a felvehető hangminta maximális hosszát) az alábbi táblázatnak megfelelően.:

Mivel Ar-Du esetén csak egy rövid hangmintát használok, ezért egy 80k-s ellenállást használtam. A hangrögzítő IC-be írandó hangmintát az alábbi weboldalon generáltam: http://www.r2d2translator.com/

A robot kis mérete miatt a helykihasználás kritikus. Az egyes panelek méretét megpróbáltam a lehető legkisebbre összezsugorítani. Az IC adatlapjában szereplő, felvételre és lejátszásra is alkalmas kapcsolást először dugdosós próbapanelen raktam össze.

A hangminta IC-be történő felvétele után, az IC-t az alábbi leegyszerűsített, csak lejátszásra alkalmas, egy próbanyákra összeállított kapcsolásba raktam be. Az IC 23. lábát (PLAY) az Arduino modul 8-as digitális I/O lábára kötöttem.

Bluetooth modul
A PC-n futó robotirányító program és a Robot közötti vezetéknélküli összeköttetést egy BlueSMiRF Bluetooth-UART modullal valósítottam meg. Ez egy a Roving Networks RN 41-es chip-jére épülő, Class 1-es osztályba tartozó modul (a hatótávolsága kb. 100 méter). A modulnál a hardveres flow control alapból engedélyezve van, ezért a CTS és RTS lábakat egy vezetékkel össze kell kötni hogy a modul megfelelően működjön.

Egy USB-TTL átalakítóval és egy terminálprogrammal a soros porton keresztül az AT parancsok segítségével beállíthatjuk a BT modul tulajdonságait (a soros kommunikáció sebességét, a modul nevét, PIN kódját stb… ).

A modult 115200baud-os soros komunikacios sebessegre allitottam be.

Ultrahangos távolságmérő szenzor 
Az SRF-04 ultrahangos távolságmérő szenzor az emberi fül számára nem hallható tartományba eső ultrahangokkal, a szonár elv alapján méri a tárgyak távolságát. Ezek a modulok lényegében egy rövid ultrahang hullámcsomagot kibocsátó hangszóróból (adó-Tx) és a céltárgyról visszaverődött ultrahang érzékelésére szolgáló mikrofonból (vevő-Rx) állnak.

A magasabb frekvenciájú hangok kevesebb energiát disszipálnak, ezért az ultrahangok koncentráltabb, szűkebb nyalábban terjednek mint a hagyományos hanghullámok. Ez a tulajdonság segít a szenzornak abban, hogy csak az előtte lévő viszonylag szűk szögtartományban elhelyezkedő tárgyakat észlelje.

Az SFR04-es szenzor közvetlenül nem a tárgyak távolságát méri. A tápellátásért felelős VCC és GND lábak mellett rendelkezik egy un. Trigger és egy Echo lábbal is. Amikor a Trigger lábat legalább 10us-ig magas állapotra kapcsolják, akkor a szenzor egy 8 impulzusból álló ultrahang hullámcsomagot generál. Ekkor az Echo láb magas logikai állapotra vált, és mindaddig magas állapotban is marad amig a céltárgyról visszavert hang visza nem érkezik a detektorba. Az Echo lábon megjelenő jel hossza lényegében azt az időintervallumot mutatja ami alatt az ultrahang impulzus elér a céltárgyig és onnan vissza.

Az ultrahang kibocsátása és a visszaverődött hang érzékelése között eltelt idő mérésével, a hang terjedési sebességének ismeretében, a céltárgy távolsága egyszerű számolással meghatározható. A tárgyak távolsága az ultrahang által megtett út fele.

A hang terjedési sebessége szobahőmérsékleten, tengerszinten 340m/s. Egy mikroszekundum alatt 0.34mm-nyi utat tesz meg. Ez 0.17mm-es céltárgy távolságnak felel meg. Ez jó közelítéssel 10/58-al egyezik meg. Ezért ha az időt mikroszekundum-ban mérjük, akkor a távolság az alábbi egyszerű képlettel számolható:

Távolság (mm-ben) = visszhangig eltelt idő (us-ban)*10/58

Az Arduino kódban a pulseIn() utasítással megmérhető az Echo lábon megjelenő visszhangimpulzus jel hossza. Ez az utasítás egy I/O láb megadott állapotban (magas v. alacsony) eltöltött idejét méri meg mikroszekundumokban.

Soros JPEG kamera
Ar-Du a külvilág érzékelésére az ultrahangos érzékelő mellett rendelkezik egy fedélzeti kamerával is. Erre a célra egy Linksprite JPEG soros kamerát használtam:

Kamera kommunikációs protokol
A soros porton keresztül a kamerának küldött parancsokkal állíthatjuk be a kamera működési paramétereit, képet készíthetünk, és a kameráról letölthetjuk a készített képet. A kamera minden fogadott és végrehajtott parancs után egy meghatározott választ küld. A parancsok és az azokra adott kameraválaszok a következők:

A kamera által készített kép mérete függ a beállított felbontástól és a jpeg tömörítés mértékétől. Az általam használt 320x420-as felbontásnál a képek mérete 20-25kbyte körül van. Az Arduino ATMega328-as memóriája nem eleg nagy, hogy egy ekkora képet egyben tudjon kezelni. Ezért a kép kiolvasása és PC-re történő továbbküldése blokkokban történik. A kamera által készített kép kiolvasásához a 56 00 32 0C 00 0A 00 00 MH ML 00 00 KH KL 00 0A képkiolvasó parancsot többször kell kiadni. Az MH és ML azt a memóriacímet adja meg ahonnan a kiolvasás kezdődik. A KH és KL pedig a kiovasandó bolkk nagyságát adja meg. Minden egyes parancs után a kiolvasás kezdő memóriacímét (MH ML) a kiolvasott blokk méretével (KH KL) növelni kell, amig az egész képet ki nem olvastuk

Ez kétféleképpen tehető meg:

• A kép méretét először lekérdezzük a megfelelő paranccsal, majd a kép kiolvasása parancsot egy while cikulsba ágyazva addig ismételjük amíg a kiolvasandó memóriablokk kezdő memóriacíme nagyobb nem lesz mint a kép mérete.
• A kép kiolvasása parancsot addig ismételjük, amíg a JPEG kép végét jelző FF-D9 bájtpár meg nem érkezik.

A gyakorlatban ez így valósítható meg:

Az adatlapban szereplő kép kiolvasása parancs a következő:

56 00 32 0C 00 0A 00 00 MH ML 00 00 KH KL 00 0A

Amikor először küldjük el a kép kiolvasása parancsot, a kamera képmemóriájának a legelejétől kell kezdeni a kiolvasást. Az MH-t és ML-t 00 00-ra kell állítani, KL-t és KH-t pedig 00 20-ra (ezzel egy 32 bájtos blokkot olvasunk ki):

56 00 32 0C 00 0A 00 00 00 00 00 00 00 20 00 0A

Erre a parancsra a kamera egy 42 bájt hosszú választ küld (5 fejléc bájt, 32 adatbájt és 5 lábléc bájt). Ezután folytathatjuk a JPEG kép kiolvasását a következő memóriablokkal. A kép kiolvasása parancsban a memória kiolvasás kezdőcímét megnöveljük a kiolvasott blokk méretével (MH és ML értékét megnöveljük 00 20-al), KH és KL értékét nem változtatjuk, mert a kiolvasás blokkméretét nem akarjuk változtatni. A következő parancs ezért így fog kinézni:

56 00 32 0C 00 0A 00 00 00 20 00 00 00 20 00 0A

És ehhez hasonlóan kell folytatni tovább a memória kiolvasás kezdőcímének a növelését minden parancsnál amíg az egész képet ki nem olvastuk.

Az Arduino kódban viszonylag kis, 32 bájtos kiolvasási blokkméretet használtam, mert nagyobb méret esetén könnyen túlcsordulhat az Arduino NewSoftSerial szoftveres soros port puffere (lásd később hogy miért használtam szoftveres soros kommunikációt).

Ar-Du vezérlőprogramjai:

Processing kód:
A Processing programban, gombokra kattintva irányíthatjuk a robotot, vezérelhetjük a mozgását, forgathatjuk a fejét, csipogtathatjuk, és képet készíthetünk a fedélzeti kamerával. A program megjeleníti az Arduino panel által a soros porton keresztül küldött JPEG képet. A Processing program fogadja majd feldolgozza az Arduino-ról érkező 32 bájtos blokkokat. A teljes kép megérkezése után az adatokat bináris formátumban (byte-ként) elmenti egy JPEG fajlba, majd beolvassa és megjeleníti a képet. Az általam használt beállításokkal kb. 4-5 másodpercbe telik egy kép frissítése. Ez a kép felbontásának, a beállított JPEG tömörítésnek, a kamera-Arduino és az Arduino-Processing (PC) közötti soros kommunikációs sebességeknek a függvénye.

A Processing alapú robotirányító program kezelőfelülete:

Arduino kód:
Az Arduino kód a PC-n futó robotirányító program által küldött karakterektől függően irányítja a robotot, vezérli a motorokat, képet készít a fedélzeti kamerával és kérés esetén a soros porton keresztül a PC-nek elküldi a kamera által készített képet. Ha az ultrahangos távolságmérő közvetlenül a robot előtt akadályt érzékel (a távolság kisebb mint 10cm), akkor a program az előrehaladást blokkolja, a robotot csak fordulni és hátrafelé menni engedi.

A PC és a robot közötti kommunikációt megvalósító Bluetooth modul a soros porton keresztül kommunikál az Arduino panellal. A JPEG kamera a kommunikációhoz ugyancsak a soros portot használja. Az Arduino panelnak azonban csak egyetlen hardveres soros portja van. Ezért az egyik eszköz esetén szoftveres soros kommunikációt kellett használnom. A NewSoftSerial könyvtár felhasználásával létrehoztam egy szoftveres soros portot az Arduino 2-es és 3-as lábára definiálva, és a JPEG kamerát erre kötöttem. A program a kamera által készített képet 32 bájtos blokkokban olvassa ki a kamera memóriájából amíg a kép végére nem ér (amíg a JPEG képet lezáró FF D9 bájtpár meg nem érkezik). Majd a kapott adatokat a hardveres soros porton keresztül a PC-re küldi tovább.