Képes kockakirakó robot tervezése és megvalósítása SZAKDOLGOZAT. Készítette: Nagy Tünde BGVAP0. Mérnökinformatikus, BSc.

Miskolci Egyetem Gépészmérnöki és Informatikai Kar Általános Informatikai Tanszék Képes kockakirakó robot tervezése és megvalósítása SZAKDOLGOZAT Készítette: Nagy Tünde BGVAP0 Mérnökinformatikus, BSc Témavezető: Dr. Baksáné Dr. Varga Erika egyetemi docens

Tartalomjegyzék 1 Bevezetés A dolgozat témája... 1 2 LEGO MINDSTORMS EV3 robotok általános bemutatása... 3 3 Szoftverkörnyezetek bemutatása... 6 3.1 A LEGO MINDSTORMS Home szoftverváltozat... 6 3.2 A LEJOS Java for LEGO Mindstorms... 10 3.2.1 LEJOS API... 10 4 Referencia robotok áttekintése... 14 4.1 LEGO MINDSTORMS EV3 robotkar (Robot Arm)... 14 4.2 LEGO MINDSTORMS EV3 Rubik kocka kirakó robot (MindCub3r)... 17 5 Referencia robotok átépítése... 20 5.1 LEGO MINDSTORMS EV3 robotkar (Robot Arm)... 20 5.2 LEGO MINDSTORMS EV3 kocka forgató robot... 22 6 A kockakirakó robot feladata és funkciói... 24 6.1 A kockakirakó robot feladatának lépései... 24 6.2 A kockakirakó (cube_puzzle) robot funkciói... 26 7 A programok bemutatása... 27 7.1 A robotkar programja - robotarm.ev3... 27 7.2 A kockaforgató robot programja cuberotator.ev3... 34 8 Teszteredmények... 44 9 Összegzés... 46 10 Summary... 47 11 Irodalomjegyzék... 48 12 Ábrajegyzék... 50 13 1. melléklet: DVD melléklet tartalma... 52 I

1 Bevezetés A dolgozat témája A felsőoktatásba jelentkező diákok megnyeréséért folytatott versenyben a Miskolci Egyetem is aktív résztvevő. Évente több alkalommal szervez beiskolázási rendezvényeket saját campusán. A legnagyobb szabású egyetemet népszerűsítő rendezvény az őszi félévben a Nyílt napok, tavasszal pedig a Lányok napja. Emellett közvetlen kapcsolatot is ápol az észak-magyarországi régió középiskoláival, amely kölcsönös látogatások, tanfolyamok formájában valósul meg. A Miskolci Egyetem Gépészmérnöki és Informatikai Karának képviseletében az informatikus szakok népszerűsítése, ezekre a szakokra hallgatók vonzása az Informatikai Intézet mint a mérnökinformatikus képzésekért felelős intézet feladata. A [1] adatai alapján látható, hogy az elmúlt 10 évben az informatikus szakokra jelentkezők száma évente nagyjából azonos (10 ezer fő körül mozog országos átlagban), ebből államilag finanszírozott képzésre évente átlagosan 5 ezer diák nyer felvételt. Ha figyelembe vesszük Magyarország és az észak-magyarországi régió népességének eloszlását, látható hogy egyre nagyobb százalékban választják a fiatalok ezt a szakmát. A Miskolci Egyetem alapszinten mérnök-, programtervező- és gazdaságinformatikus szakokon körülbelül 200 főt vehetne fel, de a felvi.hu adatai alapján a felvettek száma az elmúlt két évet tekintve 150 fő körül mozog. A tavalyi évtől kezdődően figyelhető meg az informatikus pálya iránti érdeklődés növekedése, melyet az országos sajtóban megjelenő, az informatikus szakemberhiányt bemutató cikkek is erősítenek. [2] A Miskolci Egyetem számára is fontos, hogy kihasználja a terület népszerűségének növekedését és minél több új hallgatót nyerjen meg a miskolci informatikus képzéshez. Ezért a beiskolázás a Miskolci Egyetemen a kiemelt stratégiai célok között szerepel. A beiskolázási és pályaorientációs rendezvényeken és az iskolalátogatások alkalmával az egyetem, a képzési struktúra és azon belül is az informatikus szakok bemutatása mellett a legfőbb cél a diákok érdeklődésének felkeltése az informatikus szakma iránt. Általában jellemző, hogy a műszaki pálya iránt érdeklődők gyakorlatias szemléletmódú diákok, és érdekesebb számukra egy mérnöki szerkezet működés közbeni megfigyelése, vizsgálata mint a tájékoztató előadás meghallgatása. Másik oldalról tekintve, az egyetem, illetve a szakfelelős intézet is jobban meg tudja mutatni szakmai kompetenciáját egy működő modell bemutatásával. 1

Dolgozatom témájának kiválasztásában tehát több szempontot is figyelembe vettem, elsősorban, érdekes, látványos témát szerettem volna választani, amely nem csak a hétköznapi, az informatikában elengedhetetlenül jelen lévő kódolásról szól, hanem valami kézzel foghatót eredményez. Nagy szerencsémre az Általános Informatikai Intézeti Tanszék lehetőséget biztosít ezen elképzelés megvalósítására, hiszen a tanszéken évek óta foglalkoznak LEGO MINDSTORMS EV3 robotok programozásával, továbbfejlesztésével. Azért is választottam ezt a témát, mert ez kicsit eltér a szakon oktatott témáktól, így inkább csak szorgalomból lehet vele foglalkozni. Az interneten már számtalan cikk található a LEGO robotok ismertetéséről, [3] [4], illetve nem egy könyv is foglalkozik annak programozásával, valamint az oktatásban betöltött szerepével. [5] [6] [7] Tavaly nyár elején én is kedvet kaptam a robotok megismeréséhez, kipróbálásához, és a vizsgaidőszakban lehetőségem is nyílt a robotok programozásával foglalkozó tanfolyamon való részvételre. Akkor igazán megtetszett a szerkezetek manipulálására szolgáló programok készítésével való foglalkozás. Ebből kifolyólag döntöttem úgy, hogy ezzel szeretnék foglalkozni szakdolgozatom témájaként, mert így az Informatikai Intézet beiskolázási tevékenységéhez is hozzájárulhatok valamilyen szinten. A LEGO MINDSTORMS EV3 készletekből építhető robotok (programozható elektromechanikai szerkezetek) a figyelemfelkeltés és kedvcsinálás egyik egyszerű, de hatékony eszközei is és nem csak a fiatalabbak számára, de a középkorúak illetve idősebbek számára is érdekes és figyelemfelkeltő lehet. A megvalósított 2 vezérlőegységet magába foglaló kockakirakó robot az alább felsorolt témakörök megbeszélésére nyújt lehetőséget: mechanikai szerkezetek: emelőkar, forgótálca, átbillentőkar; méréstechnika, szenzorok: távolságérzékelés, színérzékelés; hálózatok és kommunikáció: bluetooth hálózat, mester-szolga hálózati kommunikáció; programozás elmélet: algoritmus, vezérlési szerkezetek, többszálú programozás; EV3 szoftver: komponens-alapú programozás, bottom-up programtervezés; lejos EV3 Java API: Java függvénykönyvtár a robotok programozásához. Dolgozatom és projektem célja egy képes kockakirakó robot megtervezése, megépítése és programozása. A terv alapján, egy tálcán 4 darab, a 6 oldalán 6 különböző színnel lefestett kocka helyezkedik el, a robotok feladata pedig, hogy a kockákat azonos színű oldalukkal felfelé helyezzék el a tálcán. 2

2 LEGO MINDSTORMS EV3 robotok általános bemutatása Ahogyan már a bevezetésben is említettem, az elképzelés megvalósításának eszközei LEGO MINDSTORMS EV3 robotok lesznek. Ez a fejezet általánosságban mutatja be a robotokat mind hardver, mind programozás oldalról [8] alapján. A felhasznált 3. generációs robot a MINDSTORMS EV3 fantázianevet kapta és 2013-ban jelent meg. Az előző generációkhoz (MINDSTORMS RCX, MINDSTORMS NXT) képest mindenképpen kijelenthető, hogy mind a hardvert, mind a vezérlő szoftvert tekintve, pozitív átalakuláson esett át. A robot agyát egy intelligens tégla alkotja, ami egy 300 MHz-es, Linux alapú ARM9-es mikrokontroller, a hardver elemek pedig külön egységként vannak jelen az eszköz mellett. A központi memóriája 64 MB RAM-ot, 16 MB Flash memóriát tartalmaz, amely tovább bővíthető SDHC kártyával (a tégla oldalán). A kijelző 178*128 pixel felbontású. Az eszközhöz a tégla felső részén négy motor (kimeneti portok, A-D), a tégla alsó részén négy érzékelő, szenzor (bemeneti portok, 1-4) csatlakoztatható (közepes motor, nagy motor, giroszkópos érzékelő, szín szenzor, ultrahangos szenzor, érintés szenzor, infravörös kereső). A bluetooth kapcsolat mellett, wireless kommunikációra is képes, a memória bővíthetőséget pedig mikro SDHC kártyával valósították meg. A számítógép és a robot közötti kommunikáció nem csak vezeték nélküli módon lehetséges, hanem mikro USB-s kábeles kapcsolaton keresztül is. Számítógépen elkészíthetők a célnak megfelelő programok, amelyek a szenzorok által érzékelt adatok alapján döntéseket hoznak a kívánt tevékenységekről, melyeket később a robot a hozzákapcsolt motorok segítségével kivitelez. A program USB kábelen, bluetooth-on vagy wifi-n keresztül a robotra tölthető, s ezután a robot önállóan a programja utasításainak megfelelően viselkedik. A robotok az egymással való kommunikációra is képesek, és így akár csoportmunka, csoportos tevékenység is elvárható tőlük. 3

1. ábra A MINDSTORMS EV3 robot hardver elemei Forrás: http://robotsquare.com/wp-content/uploads/2013/01/ev3hardware-large.jpg A szenzorok a robot érzékszerveiként funkcionálnak, amelyek által a robot tájékozódhat a környezetében. A következőkben a leggyakrabban használtakat mutatom be röviden. Az ütközésérzékelőt (érintés szenzor) a legtöbbször mozgó robot esetében használjuk, amely kétállású kapcsolóként működik. Az robot aszerint továbbít 0 vagy 1 értéket a szoftveren keresztül a programnak, hogy a gomb benyomott vagy kiengedett állapotában van, valamint a benyomás mértékétől függően 0-1 közötti értéket is továbbíthat. A színérzékelő megkülönbözteti az alapszíneket egymástól, de fényszenzorként is működhet. Fényszenzorként használva a fényintenzitás mérhető vele, tehát nem a felület színét határozza meg, hanem a felületről visszaverődő fényintenzitást, ami a felület fényviszonyaitól is függ. Ez az érték 0-100 közötti lehet, a felülettől függően. Az ultrahangos távolságérzékelő kiszámolja azt az időt, amely alatt a hanghullám a tárgynak verődik és visszatér, mint a visszhang. A távolságot centiméterben és hüvelykben méri, 0-4

250 cm tartományban, +/- 1 cm pontossággal. A kemény felületű tárgyak távolságát pontosabban határozza meg, mint a puha felületűekét. A giroszkópos érzékelő segítségével fokokban mérhető meg a robot elfordulási szöge. Az infravörös szenzor távolságmérésre használható (50-70 cm). Az érzékelő és jeladó két külön elem, amely együtt használható. Az érzékelő akár 200 cm-ről képes érzékelni a jeladó jelét, és azáltal meghatározni a helyzetét. A szenzor infra kommunikációra is alkalmassá teszi a robotot. Az output eszközök közé sorolhatók a szervomotorok, amelyek a robot mozgásáért felelősek. Természetesen a motorok is a robothoz megírt program alapján működtetik a robotot. Az EV3 készlet részét képezi két interaktív szervomotor. Ez nem csak kiviteli eszköz, hanem beépített érzékelőinek segítségével a motor pillanatnyi állapotáról is képes információt visszaadni a keretprogram számára. A motor forgását fokokban vagy teljes fordulatokban méri a beépített forgásérzékelő (+/- a fok pontossággal). Megjelent a készletben az un. közepes motor, amelynek különlegessége, hogy a forgási tengelye párhuzamos a motor tengelyével. A szenzorok és motorok 6 pólusú RJ12-es (RS485 kábel) csatlakozókábelekkel illeszthetők a robot agyához, a téglához, amelyek a készletben különböző hosszméretekben találhatók meg. 5

3 Szoftverkörnyezetek bemutatása 3.1 A LEGO MINDSTORMS Home szoftverváltozat 2. ábra A LEGO MINDSTORMS EV3 Home szoftverváltozat kezdőképernyője Forrás: http://4.bp.blogspot.com/- jaatclsb2aw/vdnh0zxpagi/aaaaaaaaaog/sl0fs5sdmre/s1600/labview%2bev3%2b01.png Ebben az alfejezetben a LEGO MINDSTORMS EV3 készletből építhető robotokhoz gyárilag mellékelt programkörnyezet felépítését és használatát mutatom be. A szoftver a LEGO Group és a National Instruments közös fejlesztése, amely LabVIEW alapokra épül, így különösebb előképzettség nélkül is lehetővé teszi a programozást. Az EV3 robotkészlet nem tartalmazza a szoftvert, de az internetről [9] ingyenesen, könnyen beszerezhető a Home változat, amely ugyanúgy teljes működőképességgel biztosítja a programok elkészítését. Kiegészítésként ugyanígy letölthetők további modulok is, amelyek a szenzorok kezeléséért felelősek. A programozási környezet Education változata is megvásárolható, amely Teacher módban is telepíthető, ezzel egy bővített verziót elérve. A szoftver egyszerű, többnyire egérhasználattal megoldható programírásra készült, amely az ikonok egymás utáni illesztését és a megfelelő paraméterek beállítását jelenti. Az EV3-G programnyelv grafikus kialakítása egyszerű használatot eredményez, és vizualitása miatt szemléletes is. Az egyes hardver elemeket és programozás technikai eszközöket egy-egy ikon (programmodul) testesíti meg. A program ezen objektumok egymás utáni fűzéséből, 6

vagy akár elágazásokat tartalmazó láncaiból épül fel. Segítségükkel nem csak a lineáris programfutás valósítható meg, hanem a többszálú programozás is. A programhoz mellékelt angol nyelvű Help részletes leírást tartalmaz az egyes ikonok felépítéséről és paraméterezési lehetőségeiről. Ez a moduláris programnyelv nagymértékben leegyszerűsíti a programírást, hiszen a szintaktikai hibák könnyebben elkerülhetők. Az egyes modulok paraméterezése különböző elektronikus űrlapokon használt beviteli eszközök segítségével lehetséges (szövegdoboz, legördülő lista, jelölő négyzet, rádiógomb stb.). Mint máshol, itt is vannak adatbeviteli korlátozások, amelyek nem engedik meg az értéktartományon kívüli adat beírását. Az ilyen típusú programírásánál a programozási idő inkább az algoritmus megalkotására szentelődik, nem pedig a gépelésre vagy a szintaktikai hibák javítására. A fejlesztőkörnyezet folyamatosan bővíthető további modulokkal az internetről való letöltésükkel, amelyek lehetővé teszik új hardver elemek, programozási eszközök forráskódba építését. Akár saját modulok is készíthetők, publikálhatók és kódba illeszthetők, növelve az eshetőségek számát. A szoftverkörnyezet a megszokott projekt szemléletet támogatja, tehát a saját programok egy több részből álló komplex projekt keretén belül hozhatók létre. A projektbe tetszőleges számú szöveges magyarázat, leírás, kép, hangfájl, videó, grafikus program forráskód illeszthető. Egy projektben több program is létrehozható, így a logikailag összetartozó programok egy egységbe rendezhetők. A teljes projekt egyetlen fájlba kerül a mentés során (ev3 kiterjesztéssel). Ha egy már létező projekt megnyitása a cél, akkor arra is van lehetőség, illetve a nyitó képernyőről elérhető valamennyi gyári projekt is, amely tartalmazza az építési útmutatót, a program forráskódját és a működésről készült videó animációt. Első lépésként szükséges a rendszerrel megkerestetni a számítógéphez csatlakoztatott robotot. A kapcsolat USB kábelen, bluetooth-on vagy wifi-n keresztül alakítható ki. Amennyiben nincs robot csatlakoztatva a számítógéphez, a program forráskódja akkor is elkészíthető, de a roboton történő tesztelésére nincs lehetőség. A robotra áttölthetők a programok, programrészek, amelyek a tégla belső memóriájába kerülnek, valamint a mérési adatokat, képeket tartalmazó fájlok vissza is tölthetők a számítógépre. A robot és a számítógép közötti adatcserét megvalósító funkciók, valamint a szoftver által felismert, 7

robothoz csatlakoztatott motorok és érzékelők a képernyő jobb alsó részén található kommunikációs blokkban láthatók. A program az egyes utasításokat jelképező ikonok egymás utáni illesztéséből épül fel. A programikonok funkciójuk szerint csoportokba rendezve találhatók meg a szoftverkörnyezetben. Az egyes programcsoportokat különböző színekkel ábrázolták. Az egyes csoportokban helyezkednek el az összetartozó modulok, amelyek közül kiválasztva a megfelelőt, az a programozási területre húzható az egér segítségével. Összesen hat programcsoport található a képernyő alsó részén: cselekvési programelemek (Action), programstruktúrák (Flow Control), szenzorok (Sensor), adatmanipulációs elemek (Data Operations), haladó programelemek (Advanced) és saját blokkok (My Blocks). A keretprogramban alkalmazható hasznos funkciók egyike a szöveges megjegyzések, kommentek elhelyezésének lehetősége. Az utasítások ilye címkékkel való ellátása a későbbi programértelmezést nagyban megkönnyítheti. A programkörnyezetben nagyon hasznos lehet a változók adminisztrációs felülete is, ahol minden olyan változó látszik, amely a projekt valamelyik programjában került létrehozásra. A változók akkor is használhatók, ha közben a program már törlésre került. A programírás tehát az utasítások sorozatának elkészítését jelenti, ez a forráskód, majd ezt az utasítássort fordítja le egy alkalmas program a számítógép nyelvére, végül a lefordított programot futtatva sorban végrehajtódnak a benne található utasítások. Az EV3-as robothoz készült programnyelv ettől annyiban tér el, hogy az utasítások sorozatát ikonok jelölik, ezeket az ikonokat egérrel helyezhetjük a programban a megfelelő helyre. Az ikonok végrehajtási sorrendje balról jobbra haladva történik így irányítva a robot mozgását, érzékelőit. Lehetőség nyílik a párhuzamos blokkvégrehajtásra is, ilyenkor a parancsok egymással párhuzamosan hajtódnak végre. Ha a program elkészült, feltölthető a robotra és elindítható rajta. Ez a lépés nem feltétlenül szükséges a program teszteléséhez, ugyanis az USB kábelen keresztül, ha a robot csatlakoztatva van a számítógéphez, szintén lefuttatható az elkészített program. Amennyiben a robot, nem az elvárt viselkedést produkálja, akkor valószínűleg programtervezési hiba történt vagy a hardver lett tévesen összeállítva, ezek azonban egyszerűen korrigálhatóak a hiba azonosítását követően. 8

3. ábra A MINDSTORMS EV3 Home szoftverváltozat programozási területének képernyője Forrás: http://static1.1.sqspcdn.com/static/f/967780/22949354/1371725243410/screenshot_062013_084717_pm.jpg?token=jdclzfqtqgp2rt92y5pv%2b2%2bxsdu%3d A bemutatott programnyelven kívül sok más programnyelven is lehet irányítani a robotokat. Ezek közül néhány ingyenesen is beszerezhető az internetről: pl. lejos (java alapú), BricxCC (C alapú), RobotC (C alapú) programkörnyezetek. 9

3.2 A LEJOS Java for LEGO Mindstorms A lejos egy firmware, amely a LEGO MINDSTORMS robotok programozásához készült. A szoftver számos változata támogatja az eredeti Robotics Invention rendszert, vagyis az NXT-t és az EV3-at. A lejos tartalmaz egy Java virtuális gépet, amely lehetővé teszi, hogy a LEGO MINDSTORMS robotokat egy objektum orientált programozási nyelven, vagyis Java nyelven is programozhassuk. Ahogyan már korábban is megismerhettük a Java nyelvet, a legfontosabb jellemzője, hogy objektum orientált programozási nyelv, vagyis programozásunkban fontos szerepet játszanak a csomagok és osztályok, amelyek által rendszerezhetjük programunkat. A lejos lényege itt is főként a rendszerezésen van, így az API-ja tanulmányozása során észrevehetjük, hogy számos csomag és osztály áll rendelkezésünkre, hogy programozhassuk a robotjainkat. 3.2.1 LEJOS API A következőkben a fontosabb csomagokat és a hozzájuk tartozó interfészeket valamint osztályokat ismertetem általánosan, amely bővebben a [10] internetes oldalon található meg. Ahogy az már a javaban ismerős, természetesen itt is jelen van a kivételkezelés, több csomagban kivétel osztály is található. Az egyik legalapvetőbb csomag a lejos.hardware csomag, amelyben megtalálhatók elsősorban a hangokkal kapcsolatos interfészek (Audio, Sounds), a kulcsok használatához szükséges interfészek (Key, KeyListener, Keys) illetve az EV3 akkumlátorával és a megadott időben történő használatával kapcsolatos információkat közvetítő interfész (Power). Fontos osztályok tartoznak a csomaghoz, például a Sound, amely a hangeszközhöz való hozzáférést biztosító metódusokat tartalmazza, a Battery, amely metódusai által az akkumlátorról juthatunk ismeretekhez, valamint a Device neveztű osztály is ide tartozik, mely alapvető osztály a szenzor drivereinek a kezeléséhez. Ezen felül megtalálható benne még a Bluetooth, BrickInfo, BrickFinder, Button, és Wifi nevezetű osztály is. 10

A lejos.hardware.ev3 nevű csomag szintén alap csomagnak tekinthető, ha ev3 robotok programozásáról van szó, ugyanis ez biztosít EV3 hardware elérhetőséget. A csomag tartalmát csupán egy interfész, az EV3 interfész és egy LocalEV3 osztály képezi, amely egy EV3 eszköz futó példányát reprezentálja. Szintén használható a különféle rendszer erőforrások (szenzorok, motorok stb.) elérésére is. A lehetőségek bővítésére szolgáló csomag a lejos.harware.device, amelynek alapja a kívülálló EV3 eszközök támogatása, vagyis támogatja például az NXT, a PF Mate valamint az RCX eszközöket is. Ide tartoznak a speciális vezérlést igénylő motorok mozgását biztosító osztályok, mint például: LDCMotor, MSC, NXTCam, PFLink és RCXLink. A lejos.hardware.device.tetrix csomag hozzájárul a HiTechnic Tetrix motor és Servo vezérlés eléréséhez. A csomagban rendhagyó módon nem található sem interfész, sem kivétel osztály, viszont a Tetrix motor irányításához szükséges osztályok természetesen rendelkezésre állnak, mint például a TetrixMotor, a TetrixMotorController, a TetrixServo illetve a TetrixServoController osztályok. Ahhoz, hogy a képernyőüzeneteket láthatóvá tegyük a lejos segítségével, szükséges a lejos.hardware.lcd csomag használata, amely során az EV3 fejlesztőkörnyezetéhez hasonlóan itt is formázhatjuk a tégla képernyőjére kerülő kiírás megjelenését. Természetesen a robot mozgásához szükséges csomag tartalma szintén nagyon fontos a program elkészítése során. A lejos.hardware.motor néven használható csomag hozzáférést biztosít az EV3 által támogatott motorok vezérléséhez. A MotorRegulator és Tachometer interfészek mellett számos osztály is található a csomagban, elsősorban az alap motor mozgásához szükséges BaseRegulatedMotor és a BaicMotor. A közepes és nagy motor operációnak elvégzését az EV3MediumRegulatedMotor és EV3LargeRegulatedMotor osztályok segítségével hajthatjuk végre. A JavaMotorRegulator és JavaMotorRegulator.Controller szintén a motorok szabályozását teszi lehetővé. A Motor osztály pedig három futó példányát tartalmazza a szabályozott motoroknak. Az analóg és digitális szenzorok használatához a lejos.hardware.port csomag járul hozzá, amely csak interfészeket és kivétel osztályt tartalmaz. Az interfészek között ott van a Port, ami a fizikai portok és a különböző szenzorok interfészei között létesít kapcsolatot, valamint a SensorPort, mely alapvető interfész az EV3 szenzorok portjaihoz. 11

Az EV3 által támogatott szenzorok elérését a lejos.hardware.sensor csomag teszi lehetővé. Ezen belül négy interfész és megannyi osztály található, annak érdekében, hogy minden EV3 által támogatott szenzor használható legyen. Ezek közül fontosabb az AnalogSensor, amely alapvető osztály az analog szenzorok kezeléséhez, az EV3ColorSensor osztály, aminek segítségével nyolc színt tudunk megkülönböztetni a robot által. Gyakran használt osztály még az EV3GyroSensor nevű osztály, amely a tájékozódásban és forgásban van a fejlesztő segítségére, valamint a tárgyak pontos detektálására szolgáló EV3TouchSensor osztály. Ezeken kívül természetesen még számos, a szenzorok működtetésére szolgáló osztály található a csomagban, többek között az NXT és RCX szenzorok működtetéséhez szükséges osztályok is. A lejos.remote.ev3, a lejos.remote.nxt és a lejos.remote.rcx csomagok a különböző robotok távoli hozzáféréseit teszik lehetővé akár bluetoothon keresztül. A lejos.hardware.* csomagok mellett a lejos API-ba tartozó csomagok a lejos.robotics.* csomagok. A robotics csomaghoz a hardveres absztrakciós interfészeket a lejos.robotics tartalmazza. Példaként ilyen interfész az Accelerometer interfész a gyorsulással kapcsolatos szenzorokhoz, az alapvető motorokhoz kapcsolódó BaseMotor interfész, valamint a ColorDetector, amely egy általános ColorDetector objektumhoz fűződő metódusokat definiál. A csomagban továbbá megtalálható a Color osztály, amely egy a szín szenzor és szín detektor által használt színt reprezentál, illetve a különleges MirrorMotor osztály is, mely alkalmazásával ellentétesen változtatható meg egy motor mozgása. A lejos.robotic.chassis című csomag a kerekekkel felszerelt robotok, mondhatni járművek modellezését kínálja a Chassis és a Wheel interfészek, illetve a WheeledChassis, a WheeledChassis.HolonomicModeler és a WheeledChassis.Modeler osztályok segítségével. A robotok helyileg történő meghatározását a lejos.robotics.localization csomag támogatja. A különböző navigálások esetén szükséges használni a lejos.robotics.navigation csomagot, amiben a navigáláshoz elengedhetetlen interfészek és osztályok találhatók meg. A Pose osztály például egy robot helyzetét és irányát reprezentálja, illetve olyan metódusokat tartalmaz, amelyekkel frissíteni lehet az osztályt, az alapvető robotmozgásoknak eleget téve. 12

Különleges osztály a MovePilot, mely egy robot pilóta mechanizmusának szoftveres absztrakciója. Ezek mellett a fejlesztők rendelkezésére áll még az objektumok detektálásával foglalkozó lejos.robotics.objectdetection csomag illetve az útvonal kereső és találó lejos.robotics.pathfinding csomag. További csomagok: lejos.robotics.filter, lejos.robotics.geometry, lejos.robotics.mapping, lejos.robotics.subsumption. Végül a lejos.utility nevezetű csomagba kerültek a további hasznos osztályok, egyebek mellett a Delay (időkésleltetésre szolgáló rutinok, amelyek nem megszakíthatók), Matrix (a JAMA projektből származtatott mátrix implementáció), TextMenu (elemek listájának megjelenítése) és Timer (időzítő objektum, néhány a java.swing.timer osztályhoz hasonló funkciókkal) osztályok. 4. ábra lejos Hello World példaprogram Forrás: http://oi63.tinypic.com/rkaquh.jpg 13

4 Referencia robotok áttekintése Ez a fejezet a célkonstrukció megvalósításához felhasznált gyárilag illetve magánszemély által tervezett robotokat mutatja be, amelyek szintén általam lettek felépítve megadott építési útmutató [11] [12] alapján. A robotokhoz az internetről [13] [14] ingyenesen szereztem be a kész programokat, amik a robotokhoz gyárilag mellékelt programkörnyezetben készültek. Természetesen a robotok tesztelése is megtörtént a rájuk töltött programok segítségével, a tapasztalatok a fejezet megfelelő részein kerültek leírásra. Az elképzelés megvalósításához két robotot használtam fel, az egyik az egyszerű és nagyszerű robotkar, a másik pedig a már sokkal trükkösebb és látványosabb Rubik kocka kirakó robot. 4.1 LEGO MINDSTORMS EV3 robotkar (Robot Arm) 5. ábra A MINDSTORMS EV3 robotkar Forrás: http://a.fsdn.com/con/app/proj/lejos/screenshots/lego_robot_arm.jpg A robotkar célja különböző, meghatározott minimális (1x1 cm) és maximális (5x5 cm) méretű tárgyak átpakolása egy kiinduló helyről egy előre definiált célhelyre, úgy, hogy csak a robotkar és markoló mozognak (a konstrukció nem mozdul). 14

A mozgást végző robotrészek egy stabil alapzaton helyezkednek el. A magasított alapzaton kapott helyet a robot működését lehetővé tevő tégla is, amely így ezáltal rögzített, gombjai pedig gond nélkül megközelíthetők. A robot felépítéséhez három motorra és három szenzorra volt szükség. A robotkar képezi a konstrukció fő részét, ezért is az a robot neve. A robotkar az alapzattal párhuzamosan, vagyis vízszintes irányban képes akár 180 -ot is elfordulni. A kezdeti állapotából vizsgálva, 90 -os elfordulásra képes, ami éppen elég, hogy a közvetlenül mellette elhelyezett tárgyakat tudja szállítani. A maximális fordulást a robot alapzatába épített ütközésérzékelő irányítja, hiszen, ha az odahelyezett, forgással egyidejű, azonos mozgást végző apró robotelem hozzáér az ütközésérzékelőhöz, a gomb benyomódik, így a további ugyanolyan irányú mozgás nem engedélyezett. Ezzel korlátolják a robotkar forgását legfeljebb 180 -ra. A robotkar nem csak vízszintes, hanem függőleges, le-fel mozgást is képes elvégezni. A robotkar könyökénél elhelyezett motor, a robotkar függőleges mozgását teszi lehetővé, természetesen itt is a minimum és maximum értékeket figyelembe véve végzi cselekvését. Ehhez párosul a robotkar végén felszerelt markolók mozgása, amelynek segítségével a robot képes megmarkolni egy a markolók méretének megfelelő tárgyat (a markolók nyílásának és zárásának mértéke határozza meg a tárgy méretét), majd azt felemelni a magasba, megtartani ott, végül pedig letenni a kívánt helyre, a talajra, vagy akár más eszköz felületére. A markolók a giroszkópos érzékelő segítségével működnek. A robot mozgása tehát a fent említett három mozgásból tevődik össze. Az elkészített programban nagyjából öt blokkra lehet bontani az utasításokat jelölő ikonok láncolatát. Az első blokk egy saját blokk, amely inicializáló feladatkörrel bír, vagyis felállítja az elkövetkező mozgásokat. A következő blokk a robot várakozását foglalja magába. A robot addig várakozik, amíg a téglán manuálisan valaki meg nem nyomja a fel vagy le gombot, ami azt közvetíti a robot számára, hogy az elérni kívánt tárgy, tőle fentebb (magasabban) vagy lentebb (alacsonyabban) helyezkedik el. A gomb lenyomása után a program egy kettős elágazáshoz ér, ahol aszerint fog tovább haladni, hogy melyik gomb lett lenyomva. Ez a harmadik blokkban található. Ezekről az információkról, utasításokról a tégla kijelzője tájékoztatja a robotot használó személyt. Ezután a negyedik blokkban a robotkar a megfelelő függőleges irányú mozgással eléri a céltárgyat, a markolók segítségével felemeli azt, majd a kívánt helyre helyezi vízszintes irányú karforgással. Az utolsó blokkban a program vizsgálja, hogy a markolók szabadak, a tárgy már nincs a markolók között, így a 15

robot visszatérhet a kiinduló helyzetébe. A kar magasságát a kar tetejére épített szenzor érzékeli. Ha a kar visszatér a kezdeti állapotába, a folyamat kezdődhet elölről. Tapasztalatom tehát a robottal és a hozzá írt programmal kapcsolatban az, hogy a robot a célját teljes mértékben eléri, maradéktalanul a várt működést eredményezi. Értelemszerűen ahhoz, hogy a robot akadás mentesen, folyamatosan működjön, fontos, hogy a programban megadott értékek a megfelelő működést eredményező intervallumban helyezkedjenek el. Ami a robotkarból hiányzó mozgás lehet, az a teleszkópos mozgás, ugyanis néhány esetben lehet, éppen teleszkópos mozgás lenne szükséges, de arra jelen állapotában a robot nem képes. 16

4.2 LEGO MINDSTORMS EV3 Rubik kocka kirakó robot (MindCub3r) A Rubik kocka több évtizede szerepel a játékpolcokon, megoldásának különlegessége pedig a hétköznapi embert is vonzza, nemhogy a tudományos cikkeket írókat. [15] [16] [17] Nem meglepő tehát, hogy már a LEGO MINDSTORMS EV3 készletből is létrehoztak egy Rubik kocka kirakó robotot, amely referencia robotként szolgált a feladatom elkészítése során. [14] A robot célja egyértelműen meghatározható a nevéből is, vagyis a híres Rubik kocka kirakása a forgótálca és robotkar mozgásával. Az alapzat itt is mozdulatlan, fektetett kereken rögzített. 6. ábra A MINDSTORMS EV3 Rubik kocka kirakó robot Forrás: http://mindcuber.com/mindcub3r/mindcub3r-v1p0.pdf Az alapzatra nem fektettek túl nagy hangsúlyt, fő, hogy ne mozogjon a karok és tálca mozgása közben, ezt pedig maradéktalanul elérték. A konstrukció megépítéséhez két motort és három érzékelőt használtak fel. A tégla itt is a robot alapzatán helyezkedik el, elegendő helyet biztosítva a karoknak és tálcának. A robot három főbb részből épül fel, a kocka 17

elforgatásáért felelős forgótálcából, a kocka átbillenését végrehajtó karból, valamint a színérzékelőnek helyt adó karból. A forgótálca a robot közepén helyezkedik el. Méretét tekintve egy általános 3x3-as méretű Rubik kocka tartójaként alakították ki, a kocka élei mellett kis, az átbillentésre elegendő hely marad. A tálca kétirányú vízszintes (360 -os) forgatásra képes az alatta elhelyezett motor által. Az átbillentő kar a robot egyik végén helyezkedik el és szintén egy motorral működik. Kialakítása révén felemelkedése közben teleszkópos mozgást képes véghez vinni, elérve a tálcában lévő kockát azt átbillentheti egy másik oldalára. Az átbillentő kar végét szintén a Rubik kocka mérete alapján alakították ki. A harmadik kar a robot másik végén helyezkedik el, amely a szkennelésért felelős. A karon a színérzékelő helyezkedik el, ami itt a színek megkülönböztetéséért felelős. Ez giroszkópos szenzor segítségével működik és végez vízszintes irányú előre-hátra mozdulatot úgy, hogy a kocka tőle legtávolabb eső szélén lévő színeket is be tudja olvasni. A forgótálca mellett helyezkedik el a harmadik szenzor, az ultrahangos szenzor, amely azt vizsgálja, hogy a kocka a forgótálcában van-e vagy sem. A robot kezdeti állapotában fontos megvizsgálni, hogy a karok a megfelelő pozíciójukban helyezkedjenek el. A karok helyes helyzetéről a program elindításával győződhetünk meg, ugyanis a program első lépései a karok pontos pozícióba állítása. Az alaphelyzetbe állítja a szkennert tartó kart, a forgótálcát, valamint a billentő kart. A program elindítása előtt több lehetőségből is választhatunk a tégla képernyőjén aszerint, hogy mintát szeretnénk kirakni az összekevert Rubik kockából, vagy esetleg összekeverni szeretnénk azt. Miután a megfelelő opció kiválasztásra került, indítható az opciónak megfelelő folyamat. A számunkra szimpatikus lehetőség elindítása után a program megvizsgálja, hogy van-e kocka a forgótálcában. Ezt a vizsgálatot a már fentebb említett ultrahangos szenzor segítségével végzi el. A tégla a képernyőjén jelzi, ha nem érzékelte a kockát. Amennyiben érzékelte a kockát a forgótálcában, utasít arra, hogy távolítsuk el, majd miután nem érzékeli a kockát, a képernyőn megjelenő utasítás szerint vissza kell helyezni a kockát a forgótálcába. Ez a kész program alapján egy ellenőrzés, hogy az ultrahangos szenzor a megfelelő távolságban és módon érzékeli a kockát. Miután észlelte a kockát, indulhat a program. A kocka kirakásának folyamata részfunkciókból áll. Az első rész a szkennelés, amely annyit takar, hogy a színérzékelő kar előre-hátra mozgatásával a színérzékelő megvizsgálja a kocka felső oldalán lévő középső színt, majd körbe forgatva a tálca segítségével ugyanezt megteszi 18

a kocka ugyanazon oldalának többi színkockájával is. Nagyon fontos, hogy a kar apró, rendkívül precíz mozdulatokkal vizsgálja meg az apró kockákat. Ezután eltárolja a beolvasott színeket akár a tégla belső memóriájában, akár SDHC kártyán (beállítástól függően). Majd a kocka többi oldalával is ugyanezt megteszi, természetesen a kockát a forgótálca és átbillentő kar segítségével mindig más és más oldalára forgatva. Ha a színérzékelő hibásan olvasta be a színeket, esetleg probléma adódott az eltárolásuk sorrendjével, akkor az első olvasási folyamatot követően még kétszer ismételheti meg a szkennelést. Ha harmadjára sem sikerült a beolvasás a program scan error-al leáll. A szkennelési problémát több hiba is okozhatja a szkennelés során ilyen például, ha a karok nem megfelelő pozícióban helyezkednek el, vagy éppen a kocka nem forgatható akadálymentesen, illetve a fényviszonyok is gondot okozhatnak több esetben. Ha a beolvasás sikeres volt, helyesen tárolta el az adatokat az RTF fájlban, akkor kezdődhet a megadott minta alapján történő kockakirakás (vagy összekeverés). A robot ilyenkor is a forgótálca és átbillentő kar segítségével forgatja a kockát az előre definiált algoritmus szerint. A kiforgatási lépések számát folyamatosan láthatjuk a tégla képernyőjén. Amikor a kocka adott mintázatának előállításához szükséges forgatási lépések végrehajtásra kerültek, a program leáll. A program többszöri kipróbálása után a tapasztalat, hogy sajnos a tíz esetből háromszor a kocka kívánt állapotába történő kiforgatását nem tudja megoldani a robot. Ennek két oka is van. Az egyik ok, hogy a fényviszonyok nem mindig megfelelőek a színérzékelő számára. A másik ok, hogy a forgótálca vagy az átbillentő kar nem tudja mindig helyesen megforgatni, átbillenteni a kockát, mert megakad a kocka, így onnantól kezdve az eltárolt adatok nem konzisztensek. Ez valószínűleg adódhat abból is, hogy a kocka nem éppen versenykocka, tehát még kézzel történő forgatása közben is lehet elakadás. 19

5 Referencia robotok átépítése 5.1 LEGO MINDSTORMS EV3 robotkar (Robot Arm) Az építési útmutató által felépített robotkar, nem különbözik merően a feladathoz felhasznált, átépített robotkartól. A robotkar módosítása nem függ össze az alapkonstrukció funkciójával, ugyanis a robotkar által végezhető mozgások teljes mértékben azonosak az alapkonstrukció által végezhető mozgásokkal. A konstrukció a feladatomhoz felhasznált fakockákkal elvégzendő mintafeladaton való többszöri tesztelése közben azt figyeltem meg, hogy a markolók nem minden esetben tudták megfelelő módon megmarkolni a kockát, így nem tudta elvégezni a szükséges feladatot. Ennek érdekében, hogy a markolók stabilabban tudják megfogni a kockát, megdupláztam a markoló egyes karjait, így stabilabb a tárgy megmarkolása. A markolók így minden esetben képesek rászorítani a kockákra, és a robotkar motorjai segítségével felemelni és áthelyezni az adott kockákat a megfelelő helyre. Az alapkonstrukcióban a robotkarra egy szín érzékelő is építve volt, ez az én feladatomhoz szükségtelen volt, hiszen a szín érzékeléssel kapcsolatos feladatot úgyis a kockaforgató robot végzi el, így a szín szenzor alapból fel sem került a szerkezetre. További változtatás, amit végrehajtottam, hogy egy az alapzathoz rögzített forgótálcával egészítettem ki az alapkonstrukciót. A forgótálca elsősorban az én feladatomhoz kitalált kiegészítés, de természetesen más feladathoz is segítségül szolgálhat. A forgótálca egy kb. 13,5 cm hosszúságú, négyzet alakú szerkezet, amelyen négy, maximum 5x5 cm nagyságú tárgy tárolására van lehetőség, ugyanis négy külön részre van bontva a tálca. Magasított oldalai megóvják a bennük elhelyezett tárgyakat a kieséstől, illetve az elválasztó részekkel távolabb kerülnek egymástól, így a markolók beférnek közéjük és megfelelően rájuk tudnak markolni. Az elképzelés ugyebár, hogy négy kockát azonos színnel felfelé helyezzen el a robotkar a forgótálcán. A kockák kiindulási pontja tehát a forgótálca, amely megegyezik a kockák célhelyével is. A kockák forgótálcán történő elhelyezése azért lett így kigondolva, mert a robotkar nem képes teleszkópos mozgásra, a motorok előre-hátra nem képesek mozgatni a 20

kart, csak oldalirányban. Megoldásként szolgál a forgótálca, ugyanis így csak jobbra kell fordulnia ahhoz, hogy fel tudja emelni a kockákat a tálcáról, majd kiforgatásuk után, vissza is tudja őket helyezni a kezdeti helyükre. A forgótálca forgatásához egy nagy motor áll rendelkezésre, amely jobbra és balra történő forgatásra képes. Mozgatása által a tálca megadott mértékben tud fordulni a szükséges irányba, jelen esetben 90 -ot fordul ahhoz, hogy a következő kockát megfelelő módon elérje. A közbeiktatott tálcaforgásokkal minden kocka kiválasztására lehetősége van a robotkarnak. A kiegészítésként épített szerkezet magassága a robotkar talapzatának és a kockaforgató robot forgótálcájának magassága között van. Bár a konstrukcióban benne hagytam az ütközés érzékelőt, de ezt a programban nem használom, így csatlakoztatva sincs a téglához, viszont a jövőben, más feladat esetén, ha szükséges, legalább nem kell már beépíteni. 7. ábra A felhasznált, átépített robotkar 21

5.2 LEGO MINDSTORMS EV3 kocka forgató robot Ebben az esetben a Rubik kocka kirakó (MindCub3r) robotot alakítottam át, így már természetesen nem képes kirakni a Rubik kockát. A robot szintén több változtatáson esett át. Az átalakításra elsősorban azért volt szükség, mert a feladathoz szükséges kockák mérete (4x4 cm) kisebb, mint az általános Rubik kocka (5,5x5,5 cm), így a szerkezetben elsősorban azokat a részeket kellett módosítani, amelyek a kocka mozgatásával, vagyis a forgatásával és az átbillentésével kapcsolatos műveleteket végzik el. Az átbillentő kart és a forgótálcát kellett a megadott kocka méretének megfelelően leszűkíteni. A leszűkítésnek egyszerűbb módja volt a szerkezet szükséges részeinek átépítése, így a tálca és az átbillentő kar nagyobb része át lett építve. A forgótálca saját elv alapján lett felépítve, amely a feladathoz szükséges kocka méreteihez igazodik, vagyis a kocka körül megfelelő mértékű hely van szabadon, hogy átbillentéskor a kocka átbillenjen, és ne csak odébb csússzon, ahogy az az eredeti forgótálca esetében történt a mintaprogram kisebb kockával történő tesztelésekor. A kocka forgatásához használt tálcához az alapkonstrukcióban használt motor megmaradt az átalakított szerkezetnél is, illetve a működése is megegyezik az alap működésével, vagyis a motorra rögzített tálcát jobbra-balra képes mozgatni. Az elképzelés megvalósításához használandó kocka megfelelő átbillentéséhez az átbillentő kart is módosítani kellett, a szélességén szűkíteni kellet, a hosszúságának pedig a növelésére volt szükség, hogy az optimális módon billenjen át a kocka a másik oldalára. A kar végén lévő, a kockát áttoló részt is átalakítottam egy gumi legodarabbal, ugyanis így amikor szükséges, jobban hozzátapad a kockához, vagyis az átfordítás kevesebb pontatlansággal működik. A szín szenzornál apróbb változtatásra volt szükség, ugyanis, mivel a kocka kisebb, mint az általános Rubik kocka, így a szín szenzor nem mindig a megfelelő színt érzékelte ugyanakkora távolságból. Ezért aztán a szín szenzort kicsit lejjebb kellett tenni az őt tartó karon, így, amikor a feladat közben a kocka felé mozdul, közelebbről szkennelheti be a színt, s így az eredmény is pontos. 22

Az ultrahangos szenzor felszerelésekor szintén gond volt, ugyanis az érzékelő alapból túl távolra esett a kockától, és így nem tudta a megfelelő értéktartományon belülre helyezni a kockát, akkor sem, ha a kocka a megfelelő helyen volt. Emiatt az érzékelőt közelebb helyeztem el a forgótálcához, illetve lejjebb is tettem, hogy egy magasságban legyen a kisebb kockával. Az átépítésnél még figyelembe kellett vennem azt is, hogy a két robot közel kell, legyen egymáshoz, hogy a megfelelő módon tudja áthelyezni a robotkar a forgótálcába a kockát, ezért a kockaforgató robot lábait átalakítottam, illetve több helyen összekötöttem a robotkar szerkezetével, így szállítás esetén is redukálódik az elmozdulás veszélye. 8. ábra A felhasznált, átépített kockaforgató robot 23

6 A kockakirakó robot feladata és funkciói 6.1 A kockakirakó robot feladatának lépései A kockakirakó robot feladat tehát, hogy a robotkarhoz épített kockatartó forgótálcára előre elhelyezett 4 darab színes kockát, ugyanazon színű oldalával felfelé helyezzen el, ugyanazon a tálcán. A szín meghatározása az első kocka felső oldalának szkennelésével történik, vagyis, amelyik színt szkennelte be az első kocka esetében ugyanis az első kockát nem forgatja, csak beszkenneli az a szín lesz az egységes, keresett szín. A többi kockával a kockaforgató robot feladata, hogy azokat is sorra beszkennelje, átforgassa, hogy az összes oldalát be tudja olvasni, a robotkar pedig a kocka áthelyezésében játszik szerepet, ami azt jelenti, hogy szkennelés előtt a forgótálcába helyezi a kockát, a szkennelés után pedig vissza a kockatartó tálcába. Mivel a feladat végrehajtásához 7 db mechanikai szerkezet és 2 db szenzor szükséges, nem elég egyetlen tégla - amelyhez maximum 4 motor és 4 szenzor csatlakoztatható - a robot működtetéséhez. A megvalósítás során így 2 referencia robotot alakítottam át és ezek kommunikációját valósítottam meg. Ebből kifolyólag, két robot és két program van. A két robot nem csak hardveresen, de szoftveresen is összekapcsolódik. A robotok bekapcsolásának sorrendje mindegy, nincs megadott szabályhoz kötve. A programok indítása azonban fontos, hogy megadott sorrendben történjen, ugyanis először a robotkar programját (robotkar tégláján: cube_puzzle/robotarm) kell indítani, utána a másikét (kockaforgató tégláján: cube_puzzle/cuberotator). Mindez azért lényeges, mert a robotkarhoz tartozó program által épül fel a két robot kapcsolata, ami által képes a kommunikációra a két robot. A kockakirakó robot feladata tehát: 1. A robotkar a szükséges kezdő állásba állítja a karját, majd várakozik a kockaforgató robot által küldött, kész állapotát jelző üzenetre. Azután a robotkar kiemeli a vele egy vonalban, hozzá legközelebb eső kockát a szerkezethez épített kockatartó tálcáról, majd a kockaforgató forgótálcájába helyezi azt. Ezután vár a kockaforgató robot üzenetére. 2. A kockaforgató robot először megvizsgálja a kocka tálcában való létét az ultrahangos szenzor alkalmazásával, majd visszajelzi az érzékelés eredményét. Amennyiben a kocka a helyén van, beszkenneli annak a felső lapján lévő színt a szín szenzor segítségével, ez lesz a 24

keresett szín, ezután jelez a robotkarnak, hogy jöhet a kockáért. Ezután vár a robotkar üzenetére. 3. A robotkar visszahelyezi a kockát a kockatartó tálcára, majd üzenetváltással megvárja, hogy a kockaforgató robot érzékeli-e még a kockát a tálcában, ha nem, akkor a kockatartó tálca fordulása után, végigcsinálja ugyanezt a folyamatot az összes többi kockával. A robotkar várakozik, amíg a kockaforgató dolgozik. 4. Az első kocka kivételével, a többi kocka esetében addig szkenneli az oldalakat, amíg meg nem találja a keresett színt. A kocka különböző oldalainak szkenneléséhez, mármint a kocka forgatásához, az átbillentő kart, illetve a forgótálcáját használja. A kockaforgató robot várakozik, amíg a robotkar dolgozik. 5. A feladat célja, hogy a kockatartó tálcán lévő összes, vagyis mind a négy kocka azonos színű oldalával felfelé legyen elhelyezve. Ez az azonos szín pedig az elsőként beolvasott kocka felső lapján lévő szín kell, hogy legyen, vagyis az első kockát nem fordítja át a kockaforgató. 25

6.2 A kockakirakó (cube_puzzle) robot funkciói A kockakirakó robotot egy összetett robotként kezeljük, hiszen szerkezetileg két robot összekapcsolásával jött létre, és a funkcionalitásának betöltéséhez is szükség van mindkét robot programjának az elindítására. A két különálló szerkezet egymástól függetlenül is működtethető, mint ahogy már ezt korábban ismertettem, azonban az általam írt programok összekapcsolják őket, vagyis ebben az esetben a két robot egymás nélkül a feladat folyamatának csak bizonyos lépéseit képes megtenni. Ezek a bizonyos lépések azok a lépések, amelyek a kommunikáció előtt vannak, hiszen addig önállóan működnek, utána azonban már szükségük van egymásra, hogy tovább dolgozhassanak. A feladat alapkoncepciója tehát a két robot közötti kommunikáción alapul. Jelen állapotban a robotok kapcsolata szoftveresen épül fel, ugyanis a robotkar programjába került beszúrásra a kapcsolat felépítést eredményező utasítás. Ez természetesen a robotkarhoz tartozó program indítása után lefut, így a két robot kapcsolódik egymáshoz. A kapcsolat létrejötte ellenőrizhető a robotokhoz tartozó téglák képernyőjén, a bal felső sarokban megjelenő két kacsacsőr (<>) szimbólummal. Innentől kezdve a két robot képes a kommunikálásra, avagy az üzenetváltásra. Hogyha valamelyik robot nem képes üzenetet küldeni a másik robotnak, vagy valamelyik robot nem képes fogadni a másik robot által küldött üzenetet, úgy a két robot képtelen az együttműködésre, vagyis a feladat teljesítésére. Ebben az esetben a robotok a másik robotra, egyszerre történő várakozásukkal jelzik a problémát, aminek következtében a két robotot le kell állítani, ugyanis a két robot egyszerre történő várakozása esetén hiba történt a programok futása közben. Ilyenkor célszerű meggyőződni, hogy szoftveresen megfelelő paramétereket adtunk-e meg a bluetooth kapcsolatot létrehozó blokkban (pl. az elérendő robot pontos nevét adtuk-e meg). A kockakirakó robot funkciói a következők: Kommunikáció Maximum 5 x 5 cm nagyságú tárgyak átrakása egyik helyről a másikra Szín vagy kép szkennelése Tárgy érzékelése megadott távolságból Tárgy forgatása a forgótálca segítségével Tárgy (elsősorban kocka) átforgatása az átbillentő kar segítségével 26

7 A programok bemutatása 7.1 A robotkar programja - robotarm.ev3 A programok elkészítését, az egyszerűbb robot, azaz a robotkar programozásával kezdtem. A robotkar programja kevésbé bonyolult, hiszen ilyen konstrukcióval főként egyszerűbb mozdulatokat lehet végezni, és ebben az esetben sem volt szükség összetett lépésekre. A nehézséget inkább a kommunikáció és természetesen az értékek pontos megadása okozta. (Az ábrákkal kapcsolatban: minden blokk tartalmaz start blokkot, de az átláthatóság miatt, néhány ábrán azt nem jelenítettem meg.) 9. ábra A robotarm program Az ábrát szemlélve látható, hogy a folyamat a Hello (9. ábra) hangadással kezdődik, majd a bluetooth kapcsolatot felépítő blokkal folytatódik. A bluetooth blokkban (9. ábra) egyszerűen megadható paraméterként, hogy melyik másik robothoz szeretne csatlakozni az adott program futtatását végző robot. Ebben az esetben természetesen a kockaforgató robot nevét (BB) kell megadni, így a program elindításakor a csatlakozás meg is történik. Természetesen a kapcsolat létrehozása akkor sikeres, ha a kockaforgató robot már be van kapcsolva. 27

10. ábra A reset_arm saját blokk A robotkarnál szintén fontos, hogy azonos pozícióból induljon a kar, így a fel-le mozgást végző motorra került beállításra a reset_arm (10. ábra) saját blokk. Itt a robotkar az alappozíciójából a B motor felfelé irányuló mozgatásával éri el a kívánt helyzetet. A blokk alapján a B motor esetén figyeli a fogaskerekek állását, majd elmozdulásuk mértékét, logikai loop (10. ábra) ciklusban és az alapján mozdul el a motor a megadott mértékben. A blokk a Rubik kocka kirakó, MindCub3r-v2p1 letölthető [14] program, scan reset része alapján készült. Ez azt jelenti, hogy a jövőben a program indulásakor a robot első feladatai között lesz, hogy a kívánt pozícióból induljon és ennek következtében minél kevesebb pontatlanság forduljon elő a kar működése közben. Ennek a kiküszöbölése, elsősorban a kar vízszintes forgatása esetén, nyilvánvalóan még így is nehéz, hiszen a kart fogaskerekek segítségével hajtja a motor, a fogaskerekeknek pedig van egy kis holtjátéka, ami itt akár 1-2 -ot, más esetben 0.05 fordulatot jelenthet, így akár már ez is pontatlanságot okozhat a kar fordulásakor. Ezért inkább csak közelíteni lehet a megfelelő értékeket, mind a fokot vagy fordulatszámot, mind pedig a sebességet tekintve. [18] A blokk a markolók nyitott helyzetbe való állításával végződik, aminél azt vettem figyelembe, hogy a kocka bőven beleférjen, vagyis, hogy eléggé szétnyíljanak a markolók ahhoz, hogy ne akadjanak bele a kockába. 28

11. ábra A message_shift_detect saját blokk Miután megtörtént a robotkar megfelelő kiindulási helyzetbe állítása, a message_shift_detect (11. ábra) saját blokkal folytatódik az utasítássorozat. A blokk kezdetén a robotkar a kockaforgató robot ready (11. ábra) jelzésére vár, miközben kockaforgató robot is megkezdi a kívánt pozícióba való átállását. Az üzenet fogadása után megkezdődik a message&shifting (11. ábra) ciklus, amely négyszer fut le. A message szó nyilván az üzenetváltással, míg a shifting szó a kocka átrakásával kapcsolatos utasítások blokkjaira utal. A ciklus a to_rot (12. ábra) nevezetű saját blokk alapján az első kockát, vagyis a vele egy vonalban lévő, hozzá legközelebb eső kockát áthelyezi a kockaforgató robot forgótálcájába. A művelet helyes végrehajtása három motor (A, B, C) mozgatásával érhető el. A folyamat a robotkar lefelé irányuló mozdulatával (B motor), kezdődik. Amikor eléri a kockát, a markolók segítségével rászoríthat. A jelenleg beállított értékekkel a kar megfelelő mértékben mozdul lefelé a kockához, ahhoz, hogy azt megfogja, viszont ehhez fontos, hogy a kezdetben a reset_arm blokk (10. ábra) jól állítsa be a kar távolságát a tálcától. A kocka megmarkolása után értelemszerűen a kar elindul felfelé (B motor), szállítva a kockát, majd vízszintes fordulás (A motor) után, amikor egy vonalba kerül a kockaforgató forgótálcájával, elindul lefelé. Ebben az esetben már kisebb mértékben megy le, mint az előbb, hiszen a kockaforgató forgótálcája magasabban van, mint a kockatartó tálca. Miután elérte a motor mozgásánál megadott értékeket, a markolók kinyílnak, beleejtve a kockát a tálcába, majd a kar az előző mozgásával megegyező mértékű 29

elmozdulást végez, csak ellentétes irányban. A hangsúly itt is a finom és minél lassabb mozdulatokon van, hogy minél kevesebb legyen a pontatlanság. 12. ábra A to_rot saját blokk Az első kocka, forgótálcába helyezése után újabb ciklus indul, mess&shift&detect (11. ábra) néven. A ciklus elején a robotkar elküldi a new_arm (11. ábra) numerikus üzenetet, 1-es értékkel, a kockaforgató robotnak, jelezve azt, hogy a kockát elhelyezte a szükséges helyre, a forgótálcába. Miután ez megtörtént, ismét várakoznia kell a következő üzenetre, amit a cube_detect (11. ábra) várakozó blokk jelez, ezalatt a kockaforgató végzi a dolgát. A cube_detect (11. ábra) logikai üzenet azt közli, hogy a kockaforgató érzékelt-e kockát a forgótálcájában, a mögötte álló switch (11. ábra) szerkezet pedig ez alapján dönti el, hogy az igaz vagy hamis ágat futtatja. Abban az esetben, ha a kockaforgató robot nem érzékelte a kockát, tehát a cube_detect (11. ábra) üzenet hamis értékű, úgy a robotkar ismételten megkísérli a kocka forgótálcába való áthelyezését, az again_to_rot (11. ábra) saját blokk alapján, vagyis a to_rot (12. ábra) illetve a from_rot (13. ábra) blokkokban alkalmazott motormozgatások keverése alapján. Hogyha ez megtörtént, akkor a ciklus újraindul, ahol ismételten figyeli majd a kockaforgató a kocka helyzetét. A ciklus egészen addig fut, amíg a cube_detect (11. ábra) üzenet igaz nem lesz, vagyis amíg a kockaforgató robot nem észleli a kockát. 30

13. ábra A from_rot saját blokk Ellenkező esetben, ha a kockaforgató érzékelte a kockát, az igaz ág fut le, vagyis elkezdi a szkennelést, ezalatt a robotkar a new_rot (11. ábra) üzenetre vár. Miután a kockához vezető szabad utat jelző new_rot (11. ábra) üzenetet megkapta a robotkar, a from_rot (13. ábra) nevezetű saját blokk alapján kiveszi a kockát a forgótálcából, majd visszahelyezi azt a kockatartó tálca megfelelő helyére, vagyis ugyanoda, ahonnan korábban kivette azt. A to_rot-hoz (12. ábra) hasonlóan, a kar lefelé mozgásával eléri a kockát, majd a markolók segítségével megfogja azt, ezután fel-le irányuló mozgásával és vízszintesen történő fordulásával visszahelyezi a kockát a kiindulási helyére, vagyis a kockatartó tálcára. A műveletsor ugyanazon három motornak szóló utasításokból áll, ugyanazon paraméterekkel ellátva. Értelemszerűen ebben az esetben a blokkok sorrendje más, illetve a kar vízszintes irányban történő fordulása az előzővel ellentétes irányban történik. 14. ábra Az arm_cube_back_test saját blokk A kocka kockatartó tálcára történő visszahelyezése után, az arm_cube_back_test (14. ábra) nevű saját blokk következik, amely nevéből kifolyólag a kocka eredeti helyére történő visszajuttatásának teszteléséért felelős. A blokk egy logikai alapon működő, a blokk nevével azonos nevű loop (14. ábra) ciklusból áll. A ciklus elején a robotkar egy test_cube (14. ábra) numerikus üzenetet küld a kockaforgató robotnak, majd, elküldése után, egy már korábban is használt, cube_detect (14. ábra) logikai üzenetre vár. Az üzenet fogadása után, itt is egy switch elágazás dönt a továbbhaladásról. Amennyiben az üzenet értéke igaz, úgy a robotkar elküldi a cube_back (14. ábra) üzenetet a kockaforgató robotnak, hamis értékkel, vagyis, ha a kockaforgató robot érzékelte a kockát a 31

forgótálcában, úgy a cube_back (14. ábra) üzenet hamis lesz, hiszen, a kocka nem került vissza a célhelyére. Ebben az esetben a robotkar ismételten megkísérli a kocka kockatartó tálcára való visszahelyezését, az again_from_rot (14. ábra) saját blokk lefutásával. Ebben a blokkban a már korábban ismert motormozgatásokkal próbálja meg áthelyezni a kockát a célhelyre. Abban az esetben, ha a cube_detect (14. ábra) üzenet hamis értékkel érkezik, vagyis a kocka áthelyezése sikeres volt, akkor a cube_back (14. ábra) üzenetet igaz értékkel küldi el, jelezve, hogy a kocka a megfelelő helyen van, majd a kockatartó tálca 90 -os forgásával a következő kocka válik elérhetővé a robotkar számára. Az üzenetküldések majd utasítások végrehajtása után, újra üzenetre vár, méghozzá az OK_cube_test (14. ábra) üzenetre, ami akkor érkezik, ha a kockaforgató ismételten ellenőrizte a kocka helyét. Hogyha ez az üzenet igaz értékkel érkezik, akkor a program kilép a ciklusból, viszont, ha az üzenet értéke hamis, akkor a ciklus egészen addig ismétlődik, ameddig az adott érték igaz nem lesz. Miután kilép a ciklusból, vagyis a kockát nem érzékelte a kockaforgató robot, visszakerül, a mess&shift&detect (11. ábra) ciklusba, ahonnan szintén kilép, hiszen az igaz át futott le abban a switch (11. ábra) szerkezetben is. Ezután tehát megkezdheti ugyanezen folyamat végrehajtását, minden egyes kocka esetében. Következésképpen, miután a negyedik kockának is megtörtént a vizsgálata, szükség esetén az átforgatása, valamint visszahelyezése a kockatartó tálcába, a message_shift_detect (11. ábra) ciklus befejeződik. A B motor és a markolók visszaállnak a kezdeti állapotukra. Ezután már csak egy kis feladata van a robotkarnak, méghozzá, hogy látványos módon a nézők tudtára adja, hogy végzett a feladatával, így egy hangjelzés és többszörös tálcapörgetés kíséretében, jelzi, hogy a kockák kiforgatása a végéhez ért, jó esetben hiba nélkül, ennek értelmében minden kocka ugyanazon színű oldalával felfelé helyezkedik el a tálcán (15. ábra). Végül a program leáll. A robotarm program áll le utoljára, hiszen amennyiben a kockaforgató robot érzékelné a kockát, úgy neki újra kellene próbálkozni a kocka forgótálcából történő eltávolítását, vagyis a feladatot mindenképpen ő zárja le. 32

15. ábra Egy helyesen elvégzett feladat eredménye 33

7.2 A kockaforgató robot programja cuberotator.ev3 A kockaforgató robot programja a robotkaréval összehasonlítva, összetettebb, már csak abból is kiindulva, hogy itt nem csak a motorok manipulálására, hanem a szenzorok működtetésére is szükség van. Ahogyan a konstrukció esetében, itt is hasznos kiindulási pont volt a Rubik kocka kiforgató robot működése. Néhány mozdulatát tekintve, igazán nagy segítség volt a számomra, hogy megvalósítsam a tervezett projektet. 16. ábra A cuberotator program A program ebben az esetben a Hi (16. ábra) hangjelzéssel kezdődik, amelyet a rot_reset (16. ábra) blokk követ. Az reset_arm-hoz (10. ábra) hasonlóan itt is a már említett Rubik kocka kiforgató robot szkennelő kar reset-jét használtam fel. Ebben az esetben a paraméterek megadása is azonos, ugyanis a szkennelő kart, mozgását tekintve, nem változtattam, így a Rubik kocka kiforgató, MindCub3r-v2p1 nevű programban már megírt scan_cal saját blokk került átemelésre, kiegészítve az átbillentő kar mozgására megírt utasítással, vagyis, hogy kiemelődjön, a forgótálca felöl, szabad utat engedve a később érkező robotkarnak. A rot_reset (16. ábra) tehát ugyanazon elven működik, mint a már korábban ismertetett reset_arm (10. ábra) blokk, csak természetesen itt a C motor manipulálásával történik a kívánt helyzet elérése. 17. ábra A message_scan_detect saját blokk Az átbillentő kar kibillentése azért szükséges, mert az alap helyzetében a robotkar útjában lenne, hiszen a robotkar nem tudna hozzáférni a kockához, ha fölötte van az átbillentő kar. Ezért szükséges, hogy utat engedve, hátrafelé kibillenjen, majd pedig ott álljon, egészen addig, amíg nincs szükség a mozgására. Miután beállította a célpozícióba mind a szín szenzort, mind pedig az átbillentő kart, a message_scan_detect (17. ábra) saját blokkal 34

folytatódik a folyamat, amellyel indulhat az üzenetváltás a robotok között. Az első üzenetet a kockaforgató robot küldi a robotkarnak, miután elérte a kívánt kezdőállapotot. Ez a ready (17. ábra) üzenet, melynek kapcsán egy 1-es értékkel jelez a robotkarnak, hogy hozhatja az első kockát. Az üzenetküldés után a cube_detect_with_message (18. ábra) nevű saját blokk következik, ami egy logikai alapon működő, detect_cube nevű ciklust tartalmaz. A ciklus egy new_arm (18. ábra) üzenetvárással indul, ezzel várva a robotkar jelzésére, hogy a kockát elhelyezte a forgótálcába. Az üzenet a későbbiekben folyamatosan frissítődik, mialatt fut a ciklus. Miután megkapta a jelzést, az ultrahangos szenzor segítségével megbizonyosodik arról, hogy a kocka valóban a forgótálcában helyezkedik-e el. Ezt az ellenőrzést a detect_cube (19. ábra) nevezetű saját blokk hajtja végre, amelyben egy switch (19. ábra) szerkezet által dől el a blokk eredménye. A switch (19. ábra) elágazásnál amennyiben a szenzor érzékeli a kockát a megadott távolságon belül, úgy az igaz ág fut le, vagyis az is_detected (19. ábra) logikai változóban eltárolódik az igaz érték, majd kiírásra kerül a cube detected (19. ábra) szöveg, valamint a robot hangjelzéssel is jelzi, hogy a kocka detektálása sikeres volt. Az megjelenítés a display (19. ábra) nevű gyári blokkal történik, amelynél a megjelenítést lehet befolyásolni a különböző lehetséges paraméterek megadásával. Amennyiben érdekel, hogy hogyan fog kinézni az általunk kiírt szöveg, lehetőségünk van megtekinteni egy, előnézetet a blokk bal felső sarkában lévő szimbólum által. 18. ábra A cube_detect_with_message saját blokk 35

Ellenkező esetben, vagyis, ha a szenzor nem érzékeli a kockát, úgy az is_detected (19. ábra) változóba a hamis érték kerül eltárolásra, a képernyőre a cube not detected (19. ábra) üzenet kerül kiírásra, valamint a negatív hangjelzés is figyelemfelkeltésre szolgál, hogy a folyamat során hiba lépett fel. A detect_cube (19. ábra) saját blokk elhagyása után az is_detected (18. ábra) változó vizsgálata történik. Ebben az esetben is egy switch (18. ábra) által dönti el a program, hogy mit jelez a robotkarnak. Hogyha az is_detected (18. ábra) változó értéke igaz, akkor igaz értékkel kerül elküldésre a cube_detect (18. ábra) nevű logikai üzenet, és kilép a ciklusból, ha pedig hamis az érték, vagyis a szenzor nem érzékelt kockát, akkor hamis értékkel küldi el a cube_detect (18. ábra) üzenetet és elölről indul a ciklus. A ciklus egészen addig fut, amíg az is_detected (18. ábra) érték igaz nem lesz, vagyis amíg az ultrahangos szenzor nem érzékel kockát. A vizsgálat alapján természetesen a robotkar a neki meghatározott utasításokat látja el. (11. ábra) 19. ábra A detect_cube saját blokk Amint sikeresen detektálásra került a kocka, a scan1 (20. ábra) saját blokk-kal elkezdődik a kocka beolvasása. A nevéből kifolyólag ez a blokk felel az első kocka felső oldalának beszkenneléséért. Az első kocka esetében a szenzor csak a kocka egyik oldalát, pontosabban a felső oldalát olvassa be, ami a tárolt szín lesz. A későbbiekben a cél, hogy az összes kocka e tárolt színű oldalával felfelé álljon. A blokk kezdetén fontos, hogy meggyőződjünk a szín szenzor optimális helyzetéről, és az alapján a szükséges mértékű elmozdulást tenni a kocka irányába. A mérték ebben az esetben egy teljes fordulat. Amikor a szenzor a szükséges helyzetben van, vagyis a kocka felett, indulhat a szín szkennelése. Lényeges, hogy ebben az esetben a színeket különböztetjük meg egymástól, nem visszaverődő fényerősség alapján 36

ítéljük meg a színeket. Mindez az jelenti, hogy a színek vizsgálatát és megkülönböztetését egy switch (20. ábra) elágazással teszi lehetővé a szoftver. A szoftverkörnyezetbe előre beégetett értékekkel lehet különbséget tenni a színek között és mindezt ennek megfelelően képes érzékelni a szín szenzor. A szín szenzor összesen hét különböző színt képes felismerni és elkülöníteni egymástól az értékük szerint. Jelen helyzetben csak hat színre volt szükség, hiszen a kockáknak hat oldala van. Ennek ellenére mégis hét különböző érték alapján vizsgálja a színeket, hiszen a 0 is szerepel az értékek között, amit akkor érzékel, amikor számára nem ismert színt észlel. A switch (20. ábra) elágazásban ez szerepel alapértelmezett színnek, vagyis, ha olyan színt észlel, ami nem szerepel a másik hat szín között, akkor automatikusan no color -nak (20. ábra), vagyis 0-nak fogja elkönyvelni. A másik hat szín esetében, minden színhez egy-egy értéket rendel, ami alapján később végzi az összehasonlítást. 20. ábra A scan1 saját blokk A megadott hat szín, amely a kockák oldalán is szerepel illetve a hozzájuk tartozó értékek a következők: fekete (black) 1 kék (blue) 2 zöld (green) 3 sárga (yellow) 4 piros (red) 5 fehér (white) 6 37

A switch (20. ábra) elágazásban a lényeg, hogy miközben a szín szenzor érzékeli és megfelelően felismeri a színeket, el is tárolja azokat egy változóban. A szín szkennelése pillanatok alatt történik, így azt az értéket, amit a szkennelés pillanatában észlelt, beírja egy first_color (20. ábra) nevezetű változóba. Az értékeket numerikus típusként tárolja el. Annak érdekében, hogy a szín beolvasásának helyessége tesztelésre is kerüljön, illetve, hogy a néző is tudja, hogy a robot milyen színeket ismert fel és tárolt el, a switch egyes ágaiban, színek szerint képernyőkiírás és hangjelzés kíséretében történik a szkennelés. Azaz például, amennyiben a szenzor nem észlel számára ismerős színt, úgy a képernyőre kiírásra kerül a no color (20. ábra) szöveg, valamint a hozzá tartozó negatív hangjelzés. A többi esetben nyilvánvalóan a megadott színeket írja ki a képernyőre illetve jelzi hangadással, kimondva az adott színt. Ahhoz, hogy az szkennelés a lehető legpontosabb legyen, egy késleltetés beállításával a kar visszaindulása előtt még meg is áll a kocka fölött, így biztosabb a szkennelés pontossága. A scan1 (20. ábra) saját blokk végén a szín szenzor visszahúzódik, kezdeti pozíciójába, ahol mozdulatlanul várja a következő rá vonatkozó utasítást. 21. ábra A loop_mess_scan saját blokk Az első sikeres szkennelés után a loop_mess_scan_detect (21. ábra) nevű saját blokk fut le, amely a háromszor lefutó mess&scan&detect (21. ábra) nevű loop (21. ábra) ciklust tartalmazza. A ciklus a new_rot (21. ábra) üzenetküldéssel kezdődik, melyet az éppen new_rot (21. ábra) üzenetre várakozó robotkarnak küld a kockaforgató robot. A numerikus, 2-es értékkel ellátott new_rot (21. ábra) üzenettel jelzi a robot, hogy a kocka szkennelése befejeződött, az út szabad a kockához, vagyis elveheti azt a forgótálcából. 38

22. ábra A rot_cube_back_test saját blokk Az üzenetküldés után, a rot_cube_back_test (22. ábra) alapján ismételten egy a kocka helyzetével összefüggő ellenőrzés következik, ugyanis nem csak a kocka érkezésekor, hanem a kocka távozásakor is szükség van hibakezelésre. Itt a rot_cube_back_test (22. ábra) nevű ciklus fut le, amelynek kezdetén a kockaforgató robot a test_cube (22. ábra) üzenetet várja, mialatt a robotkar áthelyezi a kockát a kockatartó tálcára. Miután az üzenet megérkezett, a korábban említett ultrahangos szenzor érzékelésével ismételten megnézi, hogy a kocka a forgótálcában található-e. Ugyanazon módszerrel, azaz a detect_cube (19. ábra) saját blokkal, illetve az is_detected (22. ábra) változó figyelésével, ismét egy switch alapján dönt, hogy milyen üzenetet küld a robotkarnak. Miután elküldte az érzékelésnek meghatározott üzenetet (igaz esetén igazat, hamis esetén hamisat), a cube_back (22. ábra) visszajelzésre vár. Az egész folyamat tehát azon alapul, hogy, ha érzékelt még kockát a forgótálcában, akkor azt jelzi a cube_detect (22. ábra) igaz üzenettel. Ezt a robotkar átkonvertálva meghatározza, hogy akkor a cube_back (22. ábra) üzenet hamis lesz, hiszen a kocka nem került vissza a helyére. Ekkor a cube_back (22. ábra) üzenet alapján az OK_cube_test (22. ábra) üzenetet szintén hamis értékkel küldi el a kockaforgató, vagyis a ciklus elölről kezdődik. A másik esetben, ha a kockforgató robot nem érzékelt kockát a forgótálcában, akkor a cube_detect (22. ábra) üzenet hamis lesz, vagyis a robotkar által küldött cube_back (22. ábra) üzenet igaz lesz, hiszen a kocka visszakerült a kockatartó tálcára, tehát az OK_cube_test-et (22. ábra) immár pozitív értékkel küldheti el a robotkarnak, így a ciklusból kilép a program. A ciklus tehát addig fut, amíg a cube_back (22. ábra) üzenet igaz nem lesz, vagyis, amíg a robotkar nem távolítja el a kockát a forgótálcából. A robotkar ebben az esetben is közben végzi a rá szabott feladatokat. (14. ábra) 39

Miután a kocka sikeresen visszakerült a kockatartó tálcára, vagyis a célhelyére, ismét a cube_detect_with_message (18. ábra) blokkal, újabb kocka érkezésére vár a kockaforgató robot. A már korábban ismertetett blokk itt is ugyanazt az ellenőrzést végzi el, a kocka érkezésekor, mint az első kocka szkennelése előtt, egészen addig, amíg nem érzékeli a kockát a forgótálcában. A blokkal együttműködik a robotkar message_shift_detect (11. ábra) nevű saját blokkja. A mess&scan&detect (21. ábra) nevű cikluson belül, újabb ciklus található, amely a scan&compare (21. ábra) nevet kapta, ennek értelmében tehát az felelős a többi kocka oldalainak szkenneléséért és összehasonlításáért. A ciklus futásának feltétele ebben az esetben is egy logikai érték. A futási feltétel, hogy a ciklus addig fut, ameddig a feltételhez kapcsolt érték igaz nem lesz. A feladat alapján, jelenleg ez az érték az is_the_same (21. ábra) nevű logikai változó, amelyből kiolvasva a benne eltárolt logikai értéket, a ciklus tudja, hogy ameddig a kiolvasott érték hamis, addig a ciklusnak futnia kell, amint pedig a kiolvasott érték igaz, abban az esetben a ciklusból kilép a folyamat. A scan&compare (21. ábra) ciklus lényegét egy switch (21. ábra) elágazás képezi. A switch (21. ábra) feltétele egy numerikus érték, amely pontosan az az érték, amennyi a ciklus indexének az értéke, azaz, a ciklus indexe határozza meg, hogy a switch (21. ábra) hanyadik lépésben, melyik ágat hajtsa, végre. Jelen helyzetben összesen négy ág van, amelyből az első három megegyezik, a negyedik pedig eltér a többitől. A switch (21. ábra) szerkezet első három elágazása, a scan és compare (23. ábra) nevű saját blokkokat tartalmazza. A scan saját blokk majdnem ugyanaz, mint a már leírt scan1 (20. ábra) blokk, egy-két különbséggel. A blokk kezdetén nincs szükség helyzet vizsgálatra, ugyanis a scan1 alapján biztosan lehet tudni, hogy hogyan helyezkedik el a szín szenzor karja. A folyamat következő szakaszában a blokk elnevezése alapján a szkennelést hajtja végre a szín szenzor. Akárcsak a scan1 (20. ábra) blokkban, itt is ugyanolyan struktúrával működik a színbeolvasás, vagyis itt is switch elágazás segítségével határozza meg a színeket és értékeiket a szenzor. A színek és a hozzájuk tartozó értékek természetesen megegyeznek a scan1 (20. ábra) blokkban használt színekkel és értékekkel. A scan blokkban azonban eltér, hogy a switch szerkezetben a színek beolvasásakor a program az other_color nevű, numerikus értéket tároló változóba menti el a színekhez tartozó értékeket. Az other_color 40

változóban, mindig a legutóbb beszkennelt szín van tárolva. A switch ágai ebben az esetben is képernyő kiírással és hangjelzéssel kísérik a szkennelés folyamatát. 23. ábra A compare saját blokk A műveletsor folytatásaként a következő saját blokk, a compare (23. ábra) blokk fut le. A blokk az első kocka felső oldalának a színét tároló, vagyis a first_color (23. ábra) változó értékét, majd rögtön utána a legutóbb beolvasott színt tároló, other_color (23. ábra) nevezetű változó értékét olvassa ki. A legfontosabb lépés a blokkban, az összehasonlítás művelete. Ezt a compare (23. ábra) gyári blokk hajtja végre, amely két megadott (hozzákapcsolt) paramétert hasonlít össze a blokk biztosította lehetőségek (egyenlő, nem egyenlő, nagyobb mint, nagyobb egyenlő mint, kisebb mint, kisebb egyenlő mint) egyike alapján. Itt nyilvánvalóan az egyenlő összehasonlítási típus kell, vagyis azt vizsgálja, hogy a paraméterként megadott first_color (23. ábra) és other_color (23. ábra) változók értékei megegyeznek-e. Az összehasonlítás után kapott eredményt egy is_the_same (23. ábra) nevezetű, logikai változóban tárolja el. Ebben a változóban tehát kétféle érték lehet, vagy igaz, vagy hamis. Miután megtörtént az érték eltárolása, ugyanezen változó kiolvasása után, ismételten egy switch (23. ábra) elágazás alapján dől el a program folytatása, amely az is_the_same (23. ábra) változó értékétől függ. 41