Bányai Júlia Gimnázium. Kecskemét. Kutatási beszámoló,

Bányai Júlia Gimnázium Kecskemét

Kutatási beszámoló, a SZTE TTIK Kutatóiskola pályázatán elnyert támogatási összeg felhasználásáról és a megvalósult kutatási programról

2007/2008-as tanév

A KUTATÁSI BESZÁMOLÓT KÉSZÍTETTE: Kiss Róbert a kutatási program középiskolai felelőse, matematika-kémia-számítástechnika szakos tanár

A KUTATÁSI PROGRAM TÉMAVEZETŐJE A TTIK RÉSZÉRŐL: Dr. Mester Gyula Főiskolai tanár

Tartalomjegyzék Bevezető................................................................................................................................ 3 A megvalósult kutatási program ......................................................................................... 5 A támogatási összeg felhasználása ................................................................................................................5 A kutatási program felépítése ........................................................................................................................5

A kutatás tartalmi felépítése és a célok megvalósulása....................................................... 7 A LEGO Mindstorms NXT ............................................................................................... 10 Programkörnyezetek ......................................................................................................... 15 A grafikus programozási környezet A karakteres programozási környezet

..............................................................................................15 ..........................................................................................18

Elkészített programok ....................................................................................................... 20 1. programcsoport – a feltételes elágazás használata, képernyőkezelés (robot LCD), egyszerű végtelen ciklusok használata .....................................................................................................................................20 2. programcsoport – ciklusok és elágazások együttes használata, szenzorkezelés..........................................23 3. programcsoport – útvonalkövetés ............................................................................................................29 4. programcsoport – több szálú programozás – multitask .............................................................................31 5. programcsoport – robotok közötti kommunikáció bloetooth-on keresztül .................................................34 6. programcsoport – speciális robotok – „Sumo harcosok”...........................................................................37 7. programcsoport – speciális robotok – lift .................................................................................................42 8. programcsoport – speciális robotok – szkenner ........................................................................................44

Összegzés ............................................................................................................................ 46 További tervek ................................................................................................................... 48 1. melléklet: Eszközvásárlási igazolás ................................................................................. 49 2. melléklet: A résztvevők névsora....................................................................................... 50 I. kategória (6-8. évfolyam).........................................................................................................................50 II. kategória (8-11. évfolyam)......................................................................................................................50

3. melléklet: A kutatási program foglalkozásainak tematikus listája .................................. 51 I. kategória (6-8. évfolyam).........................................................................................................................51 II. kategória (8-11. évfolyam)......................................................................................................................51

4. melléklet: A sumo robot verseny szabályjegyzéke............................................................ 52 5. melléklet: A DVD tartalma.............................................................................................. 53

-2-

Bevezető Problémamegoldás, kreativitás, algoritmikus gondolkodás olyan összetett képességeket, ismereteket magában foglaló fogalmak, amelyek fejlesztése nemcsak oktatási szempontból fontos és szükséges. A közoktatás dokumentumaiban (pl. kerettanterv, érettségi követelmények) a kisiskolás kortól jelenik meg az algoritmikus gondolkodás fejlesztése mint cél. Több kutatásban kereszttantervi kompetenciákként említett elemek is besorolhatók a fenti kategóriák valamelyikébe. A tantárgyak rendszerén átívelő fejlesztési feladatról van szó, amely elsősorban a matematika és az informatika rendszereiben jelenik meg legdominánsabban. Jogos elvárás az informatika tantárgytól, hogy az IKT eszközhasználat fejlesztésével a hétköznapi technikai vívmányokat intelligensen használni tudó diákok kerüljenek a felsőoktatásba, a munkaerőpiacra. Az informatika oktatását olyan kettősség jellemzi, amely egyrészt a felhasználói szintű számítógép-használat általános fejlesztését tekinti célnak, másrészt sokkal szűkebb kör számára lehetőséget nyújt a programozói tudás elmélyítésére. Ez utóbbi tudásterületben rejlő lehetőség kiaknázása a szaktanárok innovatív hozzáállásától is függ. A hagyományos eszközökben rejlő lehetőségek magas absztrakciós szintjük folytán nem fejtenek ki kellő motivációs hatást, amely a kompetenciák fejlesztéséhez elengedhetetlen tényező. A folyamatosan és rohamosan fejlődő informatikai eszközök lehetővé teszik az oktatás megújulását. Szaktanári tapasztalatokra épülő és kutatási eredményekkel alátámasztott megállapítások, hogy a kisiskolás korban használt informatikai algoritmus-leíró nyelvek és szoftverek (pl. LOGO) egyszerűségük és „kézzelfogható” vizuális kimenetük révén megfelelő motivációs hatást fejtenek ki, amely visszahat az oktatási folyamatra. Így az 5-7. évfolyamon gyakorlatilag játékos formában lehet egymásba ágyazott iterációkat, paraméterezett eljárásokat tanítani. A későbbi évfolyamokon preferált programozási nyelvek (pascal, c++, c#) és környezet absztrakt nyelvi elemei és szintaxisa sokkal nehezebben sajátítható el és ezt még fokozza a jobbára monitoron megjelenő karakteres kimenetek kevésbé motiváló hatása. Hosszabb tanulási és gyakorlási folyamat végén lehet eljutni olyan feladatok megoldásáig, amelyek a hétköznapi élethez közelebb álló problémák megoldását teszik lehetővé. Az informatikai eszközök manapság leginkább kihasznált tulajdonsága, hogy a külvilág folyamataira, a környezet eseményeire reagálva képesek tevékenységek végzésére. Mindez nehezen jeleníthető meg ezekben a programkörnyezetekben középiskolában is érthető szinten. Pedig ezek az eszközök tennék lehetővé a programozási motiváció fenntartását és a modern programozási környezetek, technikák általános megismerését. A programírás során a kellően kitartó „kiválasztottak” általában egyszemélyes programozást folytatnak, amelyből hiányzik a kommunikáció mind programozói, mind eszközök közötti szinten. Ezeknek a problémáknak a kiküszöbölésére már közép- és általános iskolai szinten is használható informatikai eszközök állnak rendelkezésre. A cél tehát olyan informatikai eszközkörnyezet kialakítása, hogy  az algoritmikus gondolkodás fejlesztése a programírás eszközeivel minél szélesebb diákpopuláció számára váljon hozzáférhetővé és motiválóvá.  az absztrakt szintaktikájú programnyelvek helyett (életkortól függően) egyszerűbb grafikus (ikonvezérelt) nyelven lehessen az algoritmusokat fejleszteni.  a gyakorlati élethez közeli problémaszituációk megoldásával, modellezésével ne legyen a programozás öncélú „billentyűzetnyomogatás”.  a külvilággal való kommunikáció, a környezeti hatásokra való reagálás, mint programozási feladat épüljön be a oktatásba, így a tantárgyak közötti kereszttantervi kompetenciákat is erősítse.

-3-

 

a problémamegoldásra épülő kreatív algoritmusok tervezése és megvalósítása kerüljön előtérbe. Az egyszemélyes programírás helyett a csapatmunka lehetőségei és technikái is épüljenek be az informatika oktatási rendszerébe.

Megvalósítás lehetőségei A több innovációs nagydíjat nyert termék, az oktatás számára (is) kifejlesztett programozható LEGO robot (LEGO Mindstorms NXT) lehetővé teszi a programnyelvek szintaktikus elemeinek készségszintű elsajátítása mellett az egyéni kreativitás, és algoritmikus gondolkodás fejlesztését is. Kézzelfogható közelségbe hozza az absztrakt programozási algoritmusok tanítását, megértését, alkalmazását. A választható programkörnyezettől függően lehetőség nyílik olyan programkódolásra, amely absztrakciós szintje a diákok kognitív életkori sajátságaihoz illeszthető az ikonszerű elemekkel megvalósított programozástól a hagyományos programnyelvi szintaxisig. Problémaszituációs feladatok kitűzésével a problémamegoldó gondolkodás lépései kézzelfogható közelségbe hozhatók, és akár játékos formában fejleszthetők. A kitűzött probléma megoldására írt és optimalizált algoritmus helyességének ellenőrzésére közvetlen lehetőség nyílik, hiszen a robot azt végrehajtja. A paraméterek megváltoztatásával a mélyebb megértésre is lehetőség nyílik. A kitűzött probléma részekre bontása és vizsgálata a gondolkodási képességeket fejleszti és a megoldásban rejlő nagyfokú kreativitás egy új problémamegközelítési szemléletet ad. Az eszközök oktatásbeli elterjedése nagymértékben függ a tanárok innovációs hajlandóságától, hiszen publikált középiskolai szintű magyar nyelvű szakirodalom még kevés áll rendelkezésre. Az oktatásbeli elterjedése viszont a programozás tanítását-tanulását, az algoritmikus gondolkodás fejlesztését gyökeresen megváltoztathatja.

-4-

A megvalósult kutatási program A támogatási összeg felhasználása A pályázatban leírtaknak megfelelően, a kapott 200 000 Ft támogatási összeget 3 db LEGO Mindstorms Education készlet beszerzésére használtuk (a számla fénymásolatát az 1. melléklet tartalmazza). A készletek január végén érkeztek meg. A megrendeléssel párhuzamosan megtörtén a diákok körében a tájékozódó helyzetfelmérés a tervezett szakkörök résztvevői létszámát tekintve. A jelentkezők száma jóval meghaladta a 3 db készlet nyújtotta lehetőségeket (30 fő feletti létszám). Ezért korábbi oktatási kapcsolatokat felhasználva további készleteket sikerült kölcsönbe egy féléves időtartamra beszerezni, így a tervek szerint a tanév második félévétől 10 db készlettel indulhattak a szakkörök (sajnos júniusban a készleteket vissza kellett adnunk ). A kutatási program felépítése A kutatási program a II. félév kezdetétől indult, tehát öt hónapon keresztül tartott (januárjúnius). Ebben az időintervallumban 52 naplóval dokumentált és kb. ugyanennyi írásban nem dokumentált szakköri óra zajlott le. A pályázatban leírtaknak megfelelően két életkori kategóriában kezdődtek a programozói szakkörök. I. kategória (16 fővel) 6-8. évfolyam, és II. kategória (17 fővel) 8-11. évfolyam tanulói számára. Az I. kategória esetében minden második héten két-két órában kedden délutánonként, míg a II. kategória esetében minden héten két-két órás időtartamban hétfőn délutánonként. A jelentkezők magas száma miatt péntek délutáni időpontban Bakk János kollégám (matematika-fizika szak) szintén tartott egy szakkört, ahol a téma iránt különösen érdeklődő tanulók mélyíthették el programozói tudásukat. Az Ő segítségével történt a programok és a megépített robotok fizikai hátterének optimalizálása (pl. mechanikai problémák megoldása). A szakkörökön résztvevők névsorát és évfolyamát a 2. melléklet, míg a szakköri foglalkozások időpontját és rövid tematikáját a 3. melléklet tartalmazza. Ezzel a szervezési formával sikerült elérni, hogy legfeljebb két tanuló osztozott egy roboton. Célkitűzések A kutatási programban néhány olyan csomóponti tartalmat fogalmaztunk meg, amely a pályázati időtartamot és a választott megvalósítási formát tekintve fél éves időtartamban reálisan keresztülvihető. 

Programozási alapok. Programkörnyezet ikonvezérelt/nyelvi szintaxisú (életkortól függően), a nyelv szintaktikai és szemantikai elemei.



Kapcsolat a környezettel. Szenzorok használata, mért értékek értelmezése. Fényérzékelő, ultrahangos távolság érzékelő, ütközésérzékelő, hangérzékelő: útvonal-követési problémák, reagálás a környezeti hatásokra, adatgyűjtés a szenzorokon keresztül, paraméterektől függő viselkedési problémák (pl. szkennelés, …)



Kommunikáció. egyszerű kéteszközös kommunikációra épülő játékok szimulációja (pl.: stratégia nélküli véletlen játékok, egyszerű stratégiát használó véges lépésszámú játékszimulációk, …), távvezérlés.

-5-

Résztvevők köre Általános tapasztalat, hogy egy-egy előzetesen érdekesnek ítélhető szakkör esetén a jelentkezők kezdeti létszáma megfogyatkozik az idő előrehaladtával. Ezeknél a szakköröknél is volt ugyan mozgás, 3-4 tanuló tanév közben elmaradt, de helyettük érkeztek olyanok, akik kezdetben nem jelentkeztek. Az Ő bekapcsolódásuk nehezebben ment, de néhány diák segítővel sikerült megoldani. Leginkább a 6-7 és 9. évfolyamos tanulók alkották a szakkörök résztvevői létszámának zömét. A 6-7. évfolyamos korosztály az, amelyik legfogékonyabb a kreatív építést is igénylő játékosabb feladatokra, míg a Gimnáziumban a 9. évfolyamon fejeződik be az informatika tanórai keretek közötti oktatása, ezért azok, akik informatikai irányban szeretnének továbbtanulni a következő tanévektől, szakköri illetve fakultációs formában tanulhatják azt tovább. A kilencedik évfolyamon még nincs meg a szakkörökkel történő időbeli leterhelés, viszont az informatikai érdeklődés már kialakult. A két életkori kategória között nem mutatkozott különbség abban, hogy nem csak a programozás, hanem az építés is dominánsan jelentkezett a tevékenységi formák között. A motiváció fenntartása a félév során (február-június) végig sikerült. Ehhez arra volt szükség, hogy a „száraz” programozói ismeretek mellett olyan feladatok jelenjenek meg, amelyek kézzelfogható, látványos eredményt produkáltak. Ez természetes, hiszen a programozás elméletének ismerete csak szükséges feltétele a programozói tudásnak. Sok gyakorlás, a hibák folyamatos javítása nyújt készségszintű tudást. Ha a programozást éppen tanuló odahaza fut bele a programozási problémákba, hibákba és a megoldáson maga gondolkodik, akkor sokkal hatékonyabban tudja alkalmazni a megtanultakat, mintha a megoldásokat készen kapná. Ehhez persze először az ismereteket kell megtanulni, hogy rendelkezésre álljon egy olyan eszköztár, amelyet kreatívan lehet használni. Ennek a tanulásnak a megkönnyítését szolgálta a kézzelfogható látványos eredmény. Nehezítve azzal, hogy az eszköz csak erősen korlátozott ideig állt mindenki rendelkezésére, így a gyakorlás időtartama is rövid volt. Az ötödik évfolyamosok körében nem hirdettük meg a szakköri lehetőséget. Ennek oka, hogy az általános iskola alsó tagozatából bekerülő diákok nagyon heterogén informatikai tudással érkeznek a gimnáziumba. Vannak, akik szervezett keretek között itt találkoznak először a számítástechnikával, vagy ismereteik csupán az egérhasználat és az internet egyszerű böngészéséig terjed. A hatodik évfolyamosok már egy éves számítógéphasználati alapozással rendelkeznek, így az Ő informatikai tudásuk stabilabb, arra már lehet alapozni egy újszerű szoftver használatát. A 12. évfolyamosok az érettségi felkészülés utolsó szakaszába lépve kevesebb időt szánhatnak a szakköri munkára és a tanév is rövidebb számukra.

Néhány fénykép segítségével talán érzékeltethető a szakkörökön folyó munka.

-6-

1. ábra A szakköri foglalkozások hangulata.

A kutatás tartalmi felépítése és a célok megvalósulása A gimnázium tanterve szerint az intézményben a programozásoktatás tanórai keretek között két évfolyamon jelenik meg fél-fél éven keresztül heti egy-egy órás órakeretben. Hatodik évfolyamon logo (Imagine) tanulnak a diákok, míg nyolcadik évfolyamon turbo pascalt. A logo programozás a bevezetőben is vázolt okok miatt megfelelő motivációt nyújt, azonban a tanári tapasztalataim alapján megállapíthatom, hogy a pascal nyelv oktatása nem nyújt sok sikerélményt tanári szempontból. Az életkori problémákkal terhelt (kamaszkor) nyolcadikos diákok nem éreznek kellő motivációt egy absztrakt nyelvi szintaxis és szemantika megtanulására. Az algoritmikus gondolkodás fejlesztése miatt azonban szükséges a zárt és kötött formájú algoritmusok megismertetése a tanulókkal. A problémát nem csak az absztrakció okozza, hanem az operátorok beszélt nyelvi és programozásbeli használata is, Elegendő a logikai operátorokra gondolni (és, vagy, kizáró vagy), a de Morgan féle azonosságokra nem is gondolva. A matematika ugyan precízen megfogalmazza a definíciókat, de ezek alkalmazása más területeken nehezen működik, hiszen a kulturális környezetből hozott beszélt nyelvi minták a helyes használat ellen hatnak. Ezért volt örömteli, hogy a szakkörökre jelentkezve az iskolai tanulópopuláció mintegy 7 %-a úgy döntött, hogy programozást tanulna. A szakkörök az életkori sajátságoknak megfelelően más-más struktúrával és programnyelvi háttérrel indultak. Az alacsonyabb életkori kategóriában grafikus programnyelvi háttérrel, aminek nem volt feltétele a gépelési tudás és kevesebb volt a szintaktikai tévesztés lehetősége, ami egyik akadálya a hatékony programozói kompetenciák kialakításának. A tanulók

-7-

szakszókincse sem kialakult még. Ugyan a logo nyelvből a ciklus, a feltételes elágazás és a paraméterátadás fogalma ismert, de például változókkal, azok szerepével, típusaival nem találkoztak még a diákok. A logotól eltérő nyelvi szintaxis is szokatlanabb volt számukra. A magasabb életkori kategóriában egy karakteres C alapú programozási környezetet választottam, ezzel is elősegítve esetleg az emelt szintű érettségire készülést. A nyolcadik osztályban a turbo pascal alapjaival megismerkedett tanulók előtt sok programozásai fogalom ismert volt, de menet közben derült ki, hogy ezeket csak felületesen a ráismerés szintjén sikerül annak idején elsajátítaniuk. Ez nem meglepő, hiszen egy ideálisan 16 fős informatikai csoportban a programozás tanítása során két-három olyan tanuló van, aki egy fél éven keresztül követni tudja a tananyagot, és közülük sem mindenki érdeklődő. Ezért nem lehet nagyon komoly és mély tartalmakat tanítani. A C nyelv filozófiája sok tekintetben különbözik a középiskolákban preferált pascal nyelvétől (operátor és függvényszemlélet, kifejezések logikai és matematikai kiértékelési képessége, …), mégha az alapvető struktúrák csak szintaxisukban különböznek is. A 8-11. évfolyamosok esetében tehát a nyelv elemit is újra kellett tanítani. A fiatalabbak esetében a grafikus környezet nagyon könnyen tanulható így itt erre kevesebb időt kellett szánni. Mindkét szakkör esetében az első foglalkozásokra jellemző volt, hogy hirtelen szerettek volna a diákok mindent megtanulni, hogy látványos programokat tudjanak írni. Kevésbé voltak sikeresek azok az algoritmusok, amelyek ugyan programozástechnikai szempontból fontosak pl. megszámlálás algoritmusa, de látványelemeiket tekintve nem használták ki a robotok adta lehetőségeket. Nem hordozott kellő motivációt magában egy olyan feladat, hogy „Az asztallapra felragasztott szigetelőszalag csíkok felett elhaladva a robot számolja meg, hogy hány csíkot ragasztottunk fel és ezt írja a képernyőjére.”. Fontosabbnak éreztem a programozás megszerettetését, mint a programozási algoritmusok mechanikus gyakoroltatását. Hiszen 30 órás tanulás után úgysem lesz senkiből programozó, de ha megszereti és meglátja benne a szépséget, akkor nagyobb esélye van, így inkább olyan programok írására koncentráltunk, amelyek több látványelemet tartalmaznak. Ezeken keresztül próbáltuk a programozási elemeket és technikákat megismerni. A következő fejezetekben bemutatok néhány ilyet és próbálom azt is érzékeltetni, hogy mi benne az az elem, amely segíti a kompetenciák fejlesztését. Elsősorban a szenzorok használatával nyert információk feltételvezérlésekben történő használatát gyakoroltuk. Az első komolyabb program a színfüggetlen útvonalkövetés volt, egy szenzor használatával. Két fényérzékelőt használva az algoritmus elég egyszerű, de készletenként egy fényérzékelő állt rendelkezésre, így egy bonyolultabb algoritmust kellett kitalálni. A végső algoritmus ugyan nem nehéz, de maga az ötlet meglehetősen kreatív és a programozást most tanulóktól nem is várható el, hogy önállóan kitalálják. Miután átbeszéltük, megírtuk a programot és működött néhány más megközelítést, programozási ötletet használó változat is elkészült. A színfüggetlenség fontosságára a későbbiekben bemutatott példa elegendő volt és innentől kezdve a legtöbben ügyeltek arra, hogy programjaikban a lehető legkevesebb literális konstanst használjanak. Ha kikerülhető volt, akkor törekedtek az általános megoldásra. Újabb lökést adott programírásnak a bluetooth-os kommunikációval való megismerkedés. A távvezérlő egyszerű programjára négy-öt különböző változat is készült. A későbbiekben ezeket is bemutatom. A szakkör ezen stádiumában már a rendelkezésre álló 10 db robot is kevésnek bizonyult. Nem csak azért, mert a kommunikációhoz egy-egy tanulónak több is kellett volna, hanem mert a robotokat itt már átépítették. Kezdetben egy speciálisan megépített robottal kezdtük, amelyre minden típusú érzékelőből egyet-egyet felszereltünk, így a legtöbb programötlet megoldható volt vele. Később a folyamatos átépítések miatt már nem voltak alkalmasak minden feladat

-8-

megoldására, de szétszedni nem lehetett, mert a bonyolultabb programok írása több szakköri foglalkozást is igénybe vett. Kevésbé volt sikeres a fájlkezelés. Nehezen működött és túlságosan bonyolultak voltak azok a feladatok, amelyeknél nem tűnt erőltetettnek a használat, de még mindig kellően látványosak voltak. Ezért ezt a részt nem erőltettem, úgy gondolom, hogy sokkal komolyabb programozói tudás szükséges ahhoz, hogy érdemes legyen a robotok kapcsán ezzel foglalkozni. A természettudományos mérések adatgyűjtéséhez lehetne használni, de a szűk időbeli korlátok miatt ezek kipróbálása későbbi időpontra halasztódott. Újabb motivációs lökést adott a szakkörnek a LEGO robot sumo verseny. Néhány internetről letöltött videó megtekintése után a lelkesedés óriási volt. Végül hét sumo robot készült el (az építésben, programozásban 16 tanuló vett részt), amelyek közül öt részt vett az országos versenyen júniusban. Közülük kettő egy II. és egy IV. helyezést ért el. A robotok tervezése és építése három-négy hétig tartott. A diákok hétvégére kölcsönözhették és hazavihették a robotjaikat, így hatékonyabb volt a munka. Komoly mérnöki teljesítmény fizikai kísérletek álltak a legtöbb munka mögött (súrlódás, súlypont, sebesség, nyomaték, fogaskerék áttételek, …). Sok-sok kísérlet és néhány nagyon kreatív ötlet (négy motor csatlakoztatása három portra és együttes vezérlése, erőkaros emelőrendszer, és programozása, …). Néhány építési és programozási ötletet a későbbiekben bemutatok. A kommunikációt kihasználó programok közül a kő-papír-olló játék robotos szimulációja mindenképpen említésre érdemes. Míg a távvezzérlőnél a kommunikáció egyirányú, a master küld jeleket a slave-nek, addig ebben az esetben kétirányú kommunikáció valósul meg, ami komoly szinkronizálási problémákat vetett fel. A programot ketten írták meg a II. kategória szakköri résztvevői közül. Sokkal hosszabb idejű programozói tanulás szükséges egy ilyen probléma megoldásához, de nagyon hasznos, hiszen a hálózatok működését a fellépő szinkronizációs problémákat ezen keresztül lehet igazán megérteni. Összességében a három kutatási csomópontban megfogalmazott célokat nagyrészt sikerült megvalósítani, de sokkal fontosabbnak érzem, hogy a programozás gyakorlati alkalmazhatóságát a képernyőn megjelenő karaktersorozatok felől sikerült a kézzelfogható és látványelemekkel tűzdelt irányba elvinni, ami jelentős motivációs lökést adhat a résztvevő tanulóknak. A szakkörökre jelentkezett és végig jelen lévő tanulók kb. 80 %-a aktívan kivette részét a programok tervezéséből, írásából. Azt gondolom, hogy a szakköröket folytatva már sokkal könnyebben vihetők el a mélyebb és összetettebb feladatok irányába. Ezt is bizonyítja, hogy 2008-ban a szakkörre járók közül 12 tanuló jelentkezett a nemzetközi fll robotprogramozó versenyre. A kutatás azt igazolta, hogy a programozás a választott eszköz használatával közel vihető a diákokhoz, már 12 éves kortól. Lehetőségként adódik, hogy az algoritmikus gondolkodás fejlesztésére a tanórai keretek közötti használatát is kipróbáljuk. Ez lehet egy új kutatási program része. A kutatási program során elvégzett munkáról, a kitűzött feladatokról és megoldásaikról a továbbiakban részletesen is beszámolok, természetesen a teljesség igénye nélkül.

A bemutatott videók és programok a diákok munkái. Nem minden esetben tüntettem fel, hogy az adott programot ki írta. Ennek oka, hogy a szakkörön résztvevők valamennyien megírták. Abban az esetben, ha a programíró neve szerepel, akkor vagy olyan programról van szó, amelyet csak kevesen oldottak, meg vagy olyan ötletet tartalmaz, amely a tanuló saját gondolatára épül. De mindezek előtt a használt eszközök és a választott programozási környezetek rövid bemutatása következik.

-9-

A LEGO Mindstorms NXT A LEGO cég által az oktatás számára is kifejlesztett Mindstorms NXT egy intelligens számítógép vezérlésű LEGO építőelem, a robot „agya”. A 2006-os nürnbergi játékkiállításon innovációs nagydíjat nyert termék, amely magyarországi kereskedelmi forgalomba 2007-től került.

2. ábra A LEGO Mindstorms oktatási készlet.

A készlet legfontosabb eleme a programozható LEGO tégla (brick), amely egy 32 bites minikomputer, amelyhez a környezeti ingereket észlelő és azokra reagáló szenzorok és motorok csatlakoztathatók. Természetesen az eszközök összeépíthetők valamennyi létező LEGO elemmel, így olyan robotok építhetők, amelyek a programozásnak köszönhetően autonóm módon képesek viselkedni. Képesek kommunikálni minden bluetooth technikával ellátott eszközzel, így egymással, számítógépekkel, mobiltelefonokkal, PDA-kal, … A programozásuknak megfelelően önálló döntéseket képesek hozni, ezért különösen alkalmasak az oktatás számára alsó-, közép-, és felsőfokú szinten az algoritmikus gondolkodás, kreativitás, programozói tudás, mérnöki kompetenciák fejlesztésére. Az oktatásbeli elterjedésüknek jelenleg három fő akadálya van. Egyrészt a kevés publicitás miatt kevesen ismerik, másrészt a tanári innováció hiánya, harmadrészt financiális tényezők. A következőkben a robot néhány technikai paraméterét mutatom be.

- 10 -

A programozható tégla és a csatlakozási portjai, szenzorai A LEGO tégla csatlakozó portokkal rendelkezik, amelyekhez input és output szenzorok kapcsolhatók tetszőleges sorrendben. Output szenzorok csatlakozási portjai (A, B, C).

Input szenzorok csatlakozási portjai (1, 2, 3, 4).

3. ábra A LEGO Mindstorms tégla, robot „agya”.

4. ábra A LEGO Mindstorms robot szenzorai.

Három kimeneti port (A, B, C) és négy bementi port (1, 2, 3, 4) áll a rendelkezésre. Motorok: Kimeneti szenzorként interaktív szervomotorok építhetők a robothoz, illetve ledek. A motorok vezérlése történhet a tengelyük elfordulási szögének vagy a körülfordulások számának megadásával, 1o-os pontossággal. Az adatfolyam kétirányú, mert le is kérdezhetők ugyanezek a működési paraméterek programból. Beépített szinkronizációt képes végezni, ha több motor csatlakozik egy időben a robothoz. Bemeneti szenzorok csatlakoztatására négy port áll a rendelkezésre. Ezekhez ütközésérzékelő, fényérzékelő, hangérzékelő és ultrahangos távolságérzékelő csatlakoztatható alapértelmezésben, de a fejlesztések folyamatosak, így további speciális szenzorok is beszerezhetők, pl. giroszkóp, hőmérsékletérzékelő, PH mérő, …

- 11 -

Érintés vagy ütközésérzékelő: Két állapotú kapcsolónak tekinthető. Ha valamilyen akadály benyomja vagy elengedi az érzékelő rugós gombját, akkor 1 vagy 0 (igaz/hamis) értéket képes továbbítani a program felé. Egyszerűen használható és feltételvezérlésre alkalmas eszköz. Hangérzékelő: A hangérzékelő érzékelni tudja a hozzá érkező hangnyomás decibeleket (dB) és a korrigált decibeleket (dBA). Az értékeket általában % skálán kaphatja meg a program és használhatja feltételvezérlésre. A szenzor pontossága és jelelkülönítési képessége kevésbé teszi lehetővé precíz vezérlésre. Fényérzékelő: Az érzékelő a világos és sötét közötti különbséget érzékeli, tehát a fényintenzitás mérhető vele. Nem a színeket különbözteti meg, hanem az adott felületről visszaverődő fény intenzitását számszerűsíti. Ezért a mért érték nem csak a felület színétől, hanem a fényviszonyoktól és a tükrözési sajátságoktól is függ. Gyakorlatilag % skálán kifejezhető szürkeárnyalatot képes mérni. Az egyik legtöbb funkció megvalósítására alkalmas szenzor. Ultrahangos távolságérzékelő: Ultrahangos technikával képes a távolságot mérni, a gyári adatok szerint 0-250 cm-es intervallumban, 3 cm-es pontossággal. A gyakorlatban a 10 cm-nél kisebb értékeket nagyon bizonytalanul méri. Ennek az egyik oka, hogy több mérés átlagolásával számítja ki a távolságot, ami „lassúvá” teszi, így gyors mozgás közben nehezebben, pontatlanabbul működik. Használhatók továbbá a korábbi (LEGO RCX) robotok szenzorai is, amelyekhez speciális illesztőkábel szükséges (szintén része az oktatási készletnek). Kommunikáció a számítógéppel és más eszközökkel Az adatok kábel nélküli továbbítására és fogadására kifejlesztett bluetooth technikát használva a LEGO tégla képes kommunikálni minden olyan eszközzel, amely ugyanezt a technikát képes használni, így a számítógéppel és más mobil eszközökkel (mobiltelefon, PDA, további LEGO téglák, …).

Ha a megépített robotok egymás közötti kommunikációjáról van szó, akkor a kétirányú kapcsolat master-slave elvű. Egy master robothoz négy további slave kapcsolódhat. A slave robotok csak a masterrel tudnak kommunikálni, illetve a masteren keresztül egymással. A számítógéphez (ha nem alkalmas a bluetooth-os kommunikációra) USB porton keresztül is csatlakoztatható és a vezérlőprogramok áttöltése így is megvalósulhat.

- 12 -

Programozás A LEGO tégla rendelkezik saját operációs rendszerrel (firmware), amelyet a flash típusú memóriájában a tápfeszültség (6 db 1,5 V-os AA elem, vagy akkumulátor) megszűnése után is képes megőrizni. A firmware frissíthető és mivel többféle is létezik, ezért cserélhető. A programozás megvalósítható a roboton is, de itt csak néhány utasítássorból álló egyszerű programok készíthetők a roboton található négy nyomógomb segítségével, egy listából kiválasztható ikonok sorba rendezésével az LCD képernyőn. A komplexebb programozás asztali, vagy hordozható számítógépen történik erre a célra fejlesztett célszoftverek segítségével. Az elkészült forrásnyelvű programból egy bájtkódot állít elő a számítógép, amelyet áttöltve a robot memóriájába, annak firmware-e képes értelmezni és a benne szereplő utasításokat végrehajtani. Többféle programnyelvi környezethez készült szoftver. A készlettel rendelkezésre bocsátott változat a LEGO és National Instruments cég fejlesztése és ikonok segítségével lehet a programrészeket összeállítani. Az ipari robotok LabVIEW programrendszeréhez hasonló felépítésű. Ezen kívül alapvetően karakteres programírást lehetővé tévő fejlesztőkörnyezetek is rendelkezésre állnak C, Java, VisualBasic, Pascal, … nyelvi háttérrel. A kutatási program számára választott fejlesztőkörnyezetek részletesebb bemutatása a következő fejezetben olvasható. A programnyelvi környezetek sajátsága, hogy a magas szintű programnyelvek minden eszközét rendelkezésre bocsátják, így elméletileg bármilyen bonyolultságú program előállítható. Mindennek a robot hardver kiépítése szab csak határt. A LEGO robotok korábbi verziói Csupán érdekességként érdemes megemlíteni, hogy a LEGO cég Mindstorms NXT robotja a 3. generációt képviseli a cég robotika történelmében. Az első változat Spybotics névre hallgatott (~2000 körül került a kereskedelmi forgalomba). Szintén programozható microkomputert tartalmazott, viszont a szenzorai fixen beépítettek voltak. Két egyszerű kétirányú forgást megvalósító motor egy ütközésérzékelő és egy fényérzékelőt tartalmazott. A számítógéppel soros porton keresztül kommunikált, és infra távvezérlővel rendelkezett.

5. ábra A LEGO robotok első generációja (Spybotics).

A második generációt a Mindstorms RCX képviselte. Ennek felépítése már hasonlított az NXT változathoz, de a kisebb memóriával, gyengébb processzorral, és szerényebb pontosságú szenzorokkal került forgalomba. A szenzorai cserélhetők voltak. Három output és három input porttal rendelkezett. A robotok képesek voltak egymással is kommunikálni IR porton keresztül. A számítógéppel a kapcsolatot szintén az infraporton keresztül valósították meg. Ennek nagy hátránya volt, hogy az üzenetszórás miatt egy teremben lévő összes IR porttal rendelkező robot vette az adást, így ha nem volt kellő árnyékolás, akkor átviteli folyamatban hibák léphettek fel. További nagy hátrányt jelentett, hogy az itt megjelent cserélhető firmwaret nem tartotta meg a robot a tápfeszültség megszűnésével (pl. ha lemerültek az elemei). Azt minden esetben újra kellett telepíteni (~3 perc alatt).

- 13 -

6. ábra A LEGO robotok második generációja (Mindstorms RCX).

Mindkét korábbi generációs változatról elmondható, hogy programozásuk többféle programnyelven is megvalósulhatott, az NXT-hez fejlesztett programozói környezetekhez hasonló szoftverekkel. A harmadik generációt képviseli a Mindstorms NXT, amelynél a korábbi hibákat sikerült javítani. Említésre érdemes, hogy a 2007-es piaci megjelenés alkalmával a szakértők a „mérnök apukák játékának” nevezték a terméket. Az elnevezés találó, hiszen bármennyire is igyekezett a LEGO cég, programozói tudás nélkül maga az eszköz csak díszként, érdekességként funkcionálhat, viszont az oktatásban való megjelenése olyan új motivációs lehetőséget hordoz, ami segíthetné a természettudományos képzés presztízsének növelését.

- 14 -

Programkörnyezetek A szakköri munka során kétféle programkörnyezetet használtunk. A 6-8. évfolyam esetén a LEGO és National Instruments közös fejlesztéseként, egy LabVIEW alapokra épülő grafikus környezetet, a 8-11. évfolyam esetén Mark Overmars által elindított fejlesztés alapján a Bricx Command Center egy szabadon használható C alapú karakteres fejlesztőkörnyezetét. Mindkét esetben a LEGO téglán ugyanaz a firmware szükséges. A forrásnyelvű programból egy bytekódot állítanak elő a fejlesztőkörnyezetek, amely feltöltve a robotra végrehajtható.

A grafikus programozási környezet A 6-8. évfolyam esetén a sikeres programozás egyik gátja, hogy az absztrakt programnyelv nyelvi környezte nagyon szorosan kötött. Tehát a definiált szintaxistól nem lehet eltérni, így a lassabb és bizonytalanabb gépelési tudás csak nagyon lassú és fáradtságos munkával eredményez hibamentes programot. Ehhez még hozzájárul az algoritmusok tervezésének informatikai absztrakciója. Ezért a grafikus környezet tűnik járható útnak, annak ellenére, hogy az így készült programok nagyobb méretűek, lassabban futnak és hiányoznak a nyelvből olyan függvények, amelyek a C nyelvű változatban megkönnyítik a programozást. A nagyobb méret és lassabb futási idő annak ellenére jelentkezik, hogy ugyanaz a firmware futtaja az elkészült bájtkódot. A grafikus környezetben ikonok reprezentálják a program objektumait, amelyek listából választhatók és húzással beilleszthetők a program megfelelő helyére. Az egyes objektumok tulajdonságai egyszerűen beállíthatók, kiválaszthatók a megjelenő paraméterlistából.

Használható objektumok.

Kiválasztott objektum a beillesztve a programba.

Program munkaterülete.

Objektumlisták.

Paraméterlista.

Program áttöltést vezérlő ikonok.

7. ábra A grafikus környezet.

Néhány példa az ikonokra és azok paraméterezésére:

- 15 -

1. Output szenzor (motor) Az ikon és a paraméterlista:

8. ábra Paraméterlista a motorok vezérlésére.

2. Input szenzor (ütközés érzékelő):

9. ábra Paraméterlista az ütközésérzékelő vezérlésére.

3. Változók: Háromféle változótípus közül lehet választani: szöveg (string), szám (egész) és logikai. Alapértelmezésben a fejlesztőkörnyezetben nincs lehetőség tömbök létrehozására, de az internetről szabadon letölthetők és importálhatók kiegészítő modulok, például a tömbök kezeléséhez is. A szám típusok közül csak előjeles egészek használhatók, de figyelembe véve a szenzorok pontosságát, ez elegendő is. Új változókat az Edit/Define Variables menüpontban lehet létrehozni. 4. Programvezérlő szerkezetek: Feltételes elágazásokat (if (…) … else …) az alábbi ikon segítségével lehet megvalósítani. A felső „ágra” helyezett ikonok igaz esetben, míg az alsó ágra helyezettek az egyébként esetben hajtódnak végre. Egymásba ágyazhatók.

- 16 -

„Igaz ág”

„Egyébként ág”

10. ábra Feltételes elágazás ikonja.

Ciklusokat az alábbi ikon segítségével lehet létrehozni. Kétféle vezérlési lehetőségünk van a ciklusok esetében. A rendelkezésre álló operátorok, szenzorok és változók segítségével összeállított feltételtől függő, hátultesztelő ciklus (do … while(…)) és egy növekményes (for (…) …) ciklus.

11. ábra A ciklusszervezés ikonja és paraméterezési lehetőségei.

5. Operátorok Alapértelmezésben rendelkezésre álló lehetőségek: matematikai (négy alapművelet), logikai (és, vagy, kizáró vagy, valamint a tagadás), relációs (kisebb, nagyobb, egyenlő) operátorok, valamint egy intervallum típusú tartalmazás vizsgálatot lehetővé tevő operátor.

12. ábra A használható operátorok ikonjai.

6. Objektumok közötti paraméterátadás Az egyes objektumok közötti paramétereket, értékeket a programban szintén egyszerűen, egérrel lehet megvalósítani. Az egyes objektumok rendelkeznek kimeneti és bemeneti csatlakozó pontokkal (nem minden esetben mindkettővel). Ezek összekötésével lehet az értékek átadását megvalósítani.

- 17 -

13. ábra A motorok paraméterátadást lehetővé tevő csatlakozó pontjai.

A tényleges paraméterátadási technikát a bemutatott mintapéldáknál fogom bemutatni. 7. Egyéb lehetőségek: Sok további alapértelmezett lehetőség és bővíthető modul áll a rendelkezésre. A teljesség igénye nélkül pl.: véletlenszám generátor, szám-szöveg konverziós függvény a robot LCD képernyőjére történő íráshoz, fájlkezelés, robotok közötti bluetooth kommunikációhoz üzenetküldési és fogadási objektumok, több szálon futó (multitask) programozás …

A karakteres programozási környezet A karakteres fejlesztőkörnyezet egy szabadon használható „free” és nyílt forráskódú programkörnyezet. A keretprogram állandósága mellett az előállított kódból bájtkódot generáló programrész egy fájl cseréjét jelenti csupán. Így a folyamatosan fejlesztett program állandósága és frissítése is megoldott. A problémát éppen a folyamatos fejlesztés miatt az jelenti, hogy a használható függvények köre is bővül, de néhány esetben a régiek szintaxisa (paraméterek sorrendje) megváltozott, amit a programdokumentáció (help) nem követett. A programozás során a C nyelv szintaxisa érvényes. include állományok, változók, tömbök, struktúrák, feltételes elágazások, ciklusok, operátorok, megszokott és speciális függvények, … A kis és nagybetűket a program megkülönbözteti (mint a C alapú programok). Ez jelentősen megnövelheti eleinte a gépelési hibák számát. A keretprogram felépítése hasonlít más, komolyabb fejlesztőkörnyezetek felépítéséhez. Megjelenik a menüsor, a legfontosabb parancsikonok listája a szerkesztőterület és egy objektum tallózó panel. Szintaktikai hiba esetén a szerkesztőterület alján nyílik egy új ablakrész, ahol a hiba okára és helyéré történik utalás. A bájtkód előállítása előtt automatikusan lefut egy szintaktikai ellenőrzés, és addig nem lehet a programot áttölteni a robotra, amíg ez hibajelzést ad vissza (hiszen nem keletkezik bájtkód kimenetként). A szerkesztőterületen különböző automatikus színkiemelések segítik a szintaktikai ellenőrzést. Pl. literális konstansok piros színnel, egyéb konstansok zöld színnel, függvények nevei kék színnel. A nyelvben definiált konstanskészlet tartja a C-ből megszokott konvencionálisan nagybetűs írásmódot.

- 18 -

Több száz olyan függvény áll a rendelkezésre, amelyek a szenzorok beállítását, használatát teszik lehetővé, a C-ben megszokott operátorok és vezérlési szerkezetek mellett.

Szintaktikai ellenőrzés. Program feltöltés.

Programkód terület.

Kapcsolatjelző állapotsor.

14. ábra A karakteres fejlesztőkörnyezet.

Sok olyan eszköz is a rendelkezésre áll, amely megkönnyíti a programfejlesztői munkát. A Tools menü néhány funkciója (a teljesség igénye nélkül): Vezérlés a számítógépről. Egyszerű zeneszerkesztő a robot speaker-éhez. Közvetlen vezérlés a számítógépről.

Fájlkezelő, a roboton lévő programok manipulálására. A robot LCD képernyőjét jeleníti meg a monitoron.

Hangfájlok robotra alkalmas konverziós lehetősége.

Kapcsolat felépítése a számítógép és a robot között. Firmware csere.

15. ábra Néhány használható programozást segítő eszköz.

- 19 -

Elkészített programok A szakkörökön sok programot írtunk. A felépítés általában az volt, hogy kezdetben a megoldandó probléma vázlata után a szükséges programozási eszközök bemutatása, majd a konkrét programírás következett. Az alapprogramokat általában minden résztvevő megírta. A diákok programozási tudásának növekedésével a differenciált programírás került előtérbe, vagyis általában két-három fős teamek dolgoztak egy-egy feladat, projekt megoldásán, megvalósításán sok esetben több szakköri foglalkozáson keresztül. Valamennyi elkészített program bemutatására nincs lehetőség, ezért a válogatás elég önkényes. Azokat mutatom be, amelyeket valamilyen pedagógia, vagy programírási szempontból fontosnak tartok. A bemutatott programoknál szerepel a feladatspecifikáció mellett a forráskód is (a legtöbb esetben). Nem minden esetben jelenik meg mindkét programozási környezetbeli megoldás. Van olyan eset, amelynél csak az egyik változat készült el (pl. bonyolultsága miatt), vagy speciális feladat esetén csak néhányan készítették el az adott projektet. A grafikus környezetben készült programok rbt kiterjesztésű állományai, valamint a C alapú programok nxt kiterjesztésű állományai megtalálhatók a mellékelt DVD-n. Ahol nincs feltüntetve a szerző (programozó) neve, ott a szakkörön megvalósított általános megoldást mutatom be (hangsúlyozva mellette a programozási, kompetenciafejlesztési célt). A legtöbb bemutatott programhoz készült videó, amely a működés eredményét szemlélteti. Ezek egy része a szakkörökön készült, más részük utólag, de valamennyi a megírt programok alapján (a szakkörön sok esetben sem lehetőség, sem idő nem volt a videók elkészítésére). A videókat a DVD melléklet szintén tartalmazza (mov, avi és wmv formátumban), de a wmv változatokat a jelen dokumentumba is belinkeltem. Ezek lejátszása a videóhivatkozáson történő ctrl+bal klikk segítségével történhet. A legegyszerűbb programokat (pl. egyszerű motorvezérlés, …) nem mutatom be, de az első foglalkozások ezekkel kezdődtek. A programokat tartalmuk, használt programozástechnikai eszközeik és bonyolultságuk alapján bontottam kategóriákra a pályázatban megfogalmazott csomópontokat figyelembe véve. 1. programcsoport – a feltételes elágazás használata, képernyőkezelés (robot LCD), egyszerű végtelen ciklusok használata

a) Egymásba ágyazott elágazásokra egy egyszerű példát mutatok be, amelynek az rbt változata készült el. A példa ugyan tartalmaz egy végtelen ciklust is, de ez a feladat szempontjából irreleváns. Feladatspecifikáció: Készítsünk programot, amelyet végrehajtva a robot véletlenszerűen sorsol 1 és 3 közötti számot és a kisorsolt számot kiírja az LCD képernyőjére és ki is mondja angolul. (megj.: Természetesen magyarul is kimondhatná, ehhez rögzíteni kellene a számjegyek hangalakját tartalmazó fájlokat például vaw formátumban, majd bricx programmal konvertálni őket.)

- 20 -

Forráskód (rbt) - ha a sorsolt szám 1, akkor a „one” hangállomány a speaker-re.

- véletlen szám sorsolás (1-3) - tárolás a Seri nevű változóban - konvertálás karakterré - képernyőre íratás - 2 mp-es várakozás

- ha a sorsolt szám nem 1, akkor újabb feltételvizsgálat - ha kettő, akkor a „two” hangállomány a speakerre - egyébként a „three” hangállomány

16. ábra Rbt programkód: beágyazott ha. Készítette: Benkő Emese 6. évfolyam.

Pedagógiai, programozási funkció A programmal lehet szemléltetni az egyes objektumok közötti paraméterátadási lehetőségeket. A sárga színű vonalak a számok, a piros színűek a karakterek, a zöld színűek a logikai értéket jelölik. A keretprogram szintaktikai ellenőrzést is végrehajt. Csak abban az esetben megfelelő színű a vonal, ha az adott szituációban jó a változótípus. A képernyőre íratáshoz a szám tárolási formáját karakteres tárolásra kell átkonvertálni. A grafikus képen jól követhető a program elágazásainak működése, valamint programozástechnikai szempontból a használható változótípusok és azok tárolása közötti különbség is magyarázható. A diákok itt szembesülnek (6. évfolyam) először azzal, hogy az „1” jelentheti a számjegyet és egy karakter is, a tárolási formától függően, amit a programozó az alapján dönt el, hogy matematikai műveletet végez-e vele, vagy szöveges műveletet.

b) Lottószámok sorosolása. A képernyőkezelésre és a változók dinamikus használatára vonatkozik a következő példa. Feladatspecifikáció: Készítsünk egy programot, amelyet végrehajtva a robot véletlenszerűen sorsol öt darab egész számot az 1-90 tartományból és egymás alatti sorokban kiírja őket az LCD képernyőjére. Az rbt programváltozatnál nem kell ellenőrizni, hogy kétszer ne sorsolja ki ugyanazt az értéket, az nxc változatnál igen. Forráskód (rbt)

17. ábra Rbt forráskód: képernyőkezelés.

- 21 -

Pedagógiai, programozási funkció A programban szerepel egy növekményes ciklus, amely ötször fut le. A ciklusváltozó értékének nyolccal történő szorzása határozza meg a kiírt szám képernyőn lévő helyének y koordinátáját. (Egy karakter 8 pixel magas. A 2. és az 5. ikon közötti sárga vonal a paraméterátadás.) A program nem figyel az azonos számok sorsolására. A ciklus lefutása után a program leáll és a képernyő törlődik, azért kell egy 6 mp-es várakozást beilleszteni, hogy a kiírt számok elolvashatók maradjanak. Forráskód (nxc) #include "NXCDefs.h" task main() { int szamok[],vel,csere,cv; ArrayInit(szamok,0,90); for (cv=0;cv<90;cv++) szamok[cv]=cv+1; for (cv=0;cv<5;cv++) { vel=random(90-cv); NumOut(10,10+8*cv,szamok[vel],false); csere=szamok[vel]; szamok[vel]=szamok[89-cv]; szamok[89-cv]=csere; } Wait(6000); }

Programozási ötlet A program hasonló felépítésű, mint a grafikus változat. Ami miatt érdemes bemutatni, az az ötlet, amely ugyanazon szám kétszeri kihúzását meggátolja. A programírás során mikor ez a probléma jelentkezett, akkor szinte mindenki az if (…) … else … szerkezettel próbálkozott. Volt akinek sikerült is. Viszont a fenti program ötlete olyan algoritmizálási kreativitást igényel, ami miatt érdemes volt megismerkedni vele. Egy 90 elemű tömböt (0-tól 89-ig indexelve) feltöltöttünk 1-től 90-ig a természetes számokkal. Amikor a program sorsolja az első számot, akkor nem a számot írjuk a képernyőre, hanem a neki megfelelő tömbelem tartalmát és a kiíratás után ki is cseréljük az aktuálisan utolsó tömbelemmel. A következő lépésnél már csak 89 szám közül sorsolunk és az újabb csere a most aktuális 89. elemmel történik (a 88-as indexű). A cv ciklusváltozóval szabályozzuk a sorsolás számtartományát és a csere helyét, valamint a képernyőre írás helyét is. A program akkor működik matematikailag helyesen, ha a kvázi véletlen számok valóban egyenletes eloszlással sorsolódnak. A program alkalmas a csere algoritmusának és a tömbök indexelési lehetőségeinek demonstrálására is. Különösen problémás a 0-tól kezdődő indexelés és számlálás megszokása. Meg kell jegyezni, hogy az algoritmus ötlet nem okozott osztatlan sikert .

- 22 -

c) Egyszerű ciklus- és szenzorhasználatra vonatkozik a következő példa. Feladatspecifikáció: Írjunk olyan programot, amelyet végrehajtva a robot a hangérzékelő által mért értéket használva vezérli a motorjait. Minél hangosabb a mért hangintenzitás, annál gyorsabban pörög a robot. Forráskód (rbt)

18. ábra: Rbt forráskód: a mért hangintenzitás erősségétől függő sebességgel forog a robot.

A program egyszerű, de igen látványos. Nagy tetszést aratott. Az elkészült videó nem adja vissza teljes egészében a látványt. Nehezen hallható a hangerő változása.

Porog.wmv

2. programcsoport – ciklusok és elágazások együttes használata, szenzorkezelés

a) Számláló. Egyszerű ciklikus növekményes számlálás. Feladatspecifikáció: Írjunk olyan programot, amelyet végrehajtva a robot az ütközésérzékelő benyomására mindig eggyel nagyobb számot ír az LCD képernyőjére, 1-től kezdődően. Ha elérte a 10-et, akkor előröl kezdi a számolást (1-től). Forráskód (rbt)

19. ábra Rbt forráskód: egyesével számol10-ig ciklikusan maradékos osztással.

- 23 -

Forráskód (nxc) #include "NXCDefs.h" task main() { SetSensorTouch(IN_1); int szamol=1; while(true) { if (Sensor(IN_1)) { TexOut(10,10,szamol%10,true); szamol++; } } }

Pedagógiai, programozási funkció A grafikus programból hiányzik a maradékos osztás függvénye (modulo). Mivel a C nyelvű környezetben rendelkezésre áll a megfelelő operátor (%), ezért ez a program jóval egyszerűbb. A tanulók életkori sajátságainak megfelelően (6-8. évfolyam), a maradékos osztás matematikából ugyan megjelenik a tanórán, de nagyon nehéz az informatikai algoritmusokra mindezt átvinni. A fenti ábrán bemutatott rbt forráskód ezt használja ki. A szamol nevű változó értékét növeli eggyel, elosztja 10-el az eredményt. Mivel csak egész számokat kezel a program, ezért az osztás eredménye a hányados csonkolt, tizedesjegyek nélküli része. Ha ezt az eredményt megszorozzuk 10-el (osztóval) és kivonjuk az eredeti számból, akkor megkapjuk a maradékot. A 10-zel osztás eredményeként 0-9 közötti maradékot kapunk, ehhez egyet hozzáadva a kiíratandó szám 1-10 közötti. Bár az algoritmust sokan megértették és néhányan sikeresen rá is jöttek a maradékképzés technikájára az alapműveletek segítségével, de a feladatot a legtöbben más módon oldották meg. Ezek közül mutatok be kettőt. Az algoritmus a matematika tantárgyi kapcsolat miatt, azonban remélhetőleg segít a modulo fogalmának elmélyítésében. Forráskód (rbt)

20. ábra Rbt forráskód: egyesével számol 10-ig ciklikusan a változó újranullázásával.

21.ábra Rbt forráskód: egyesével számol 10-ig ciklikusan növekményes ciklussal.

- 24 -

b) Akadálykerülés ütközésérzékelővel. Feladatspecifikáció: Írjunk olyan programot, amelyet végrehajtva a robot egy ütközésérzékelővel képes az akadályok észlelésére és kikerülésére. A robot halad előre és ha nekiütközik valaminek (az ütközésérzékelője jelzi), akkor tolat és fordul egy rövid ideig, majd ismét halad előre. Mindezt kikapcsolásig ismétli. Forráskód (rbt)

22. ábra Rbt forráskód: akadályfigyelés és kerülés ütközésérzékelővel.

Pedagógiai, programozási funkció A program igen látványos, de ugyanakkor egyszerű, az első megírt programok egyike. A szintaxis alkalmas arra, hogy a többi érzékelőt használva is hasonló programokat tudjanak írni a tanulók önállóan, ahogy azt a következő példák mutatják. A feltételes elágazás fogalmának megértését szolgálja.

Utkozkerul.wmv

c) Akadálykövetés ultrahangszenzorral. Feladatspecifikáció: Írjunk olyan programot, amelyet végrehajtva a robot egy ultrahangszenzorral képes egy adott távolságon belül lévő akadály észlelésére és követésére. A robot egyenletes sebességgel forog és ha egy adott távolságon belül észlel valamit (az ultrahangszenzora jelzi), akkor elindul felé mindaddig, amíg az adott távolságon belül van az észlelt akadály. Ha elveszítette (kikerült az akadály a távolságon kívülre), akkor forog újra. Mindezt kikapcsolásig ismétli.

- 25 -

Forráskód (rbt)

23. ábra Rbt forráskód: akadálykövetés ultrahangszenzorral.

A program felépítése az előzőhöz hasonló. Távolságként 30 cm van beállítva. Az alábbi videó két robotváltozat esetében mutatja be a program működését.

Ulrasensor.wmv

d) Akadályészlelés fényérzékelővel konstansként megadott érték esetén és színfüggetlenül. Feladatspecifikáció: Írjunk programot, amelyet végrehajtva a robot fényérzékelő használatával az alap színétől jól megkülönböztethető színű felületnél megáll, tolat, fordul és tovább indul előre. Mindezt kikapcsolásig ismétli. Forráskód (rbt)

24. ábra Rbt forráskód: fényérzékelős akadályészlelés.

Pedagógiai, programozási funkció A program előkészítéseként az alap (asztal) felületének színét a fényérzékelővel be kell mérni és ennek megfelelően a 3. portra csatlakoztatott fényérzékelő által vezérelt elágazás

- 26 -

feltételeként ehhez viszonyítva (kisebb vagy nagyobb) eseteket lehet megkülönböztetni. Az alap mért színe és az akadály mért színe közötti értéknek legalább 3-4-gyel különbözni kell, a fényérzékelő bizonytalansága miatt. Az érzékelő által mért érték nem csak a színtől, hanem a fényviszonyoktól is függ. A program előnye, hogy látványosan lehet használni például arra, hogy a robot ne essen le az asztalról. Hátránya viszont, hogy nem veszi észre az alap színétől eltérő, de a beállított relációval ellenkező abszolút irányú akadályokat. Pl.: ha az alap mért színe 60, és feltételként azt állítottuk be, hogy 50-nél kisebb mért érték esetén forduljon meg, akkor az 50-nél nagyobb mért színű akadályok fölött áthalad, pl. 70-es értéken is, pedig ez is lényegesen eltér az alap színétől. Az alábbi három videó ezt szemlélteti.

Asztal_2.wmv

Asztal_1.wmv

Asztal_3.wmv

Fekete csíknál megfordul.

Asztal szélén megfordul.

Fehér csíkot nem látja.

Forráskód (nxc) #include "NXCDefs.h" #define ERO 50 task main() { SetSensorLight(IN_3); while (true) { if (Sensor(IN_3)>50) OnFwd(OUT_BC,ERO); else { OnRev(OUT_BC,ERO); Wait(1000); OnFwd(OUT_C,ERO); Wait(1000); OnFwd(OUT_BC,ERO); } } }

Pedagógiai, programozási funkció A videókon bemutatott példákkal egyszerűen szemléltethető, hogy a programon belül az elágazás feltételeként beállított határértéket nem érdemes konstansként megadni, hiszen a fény- vagy terepviszonyok változása használhatatlanná teszi a programot. Olyan algoritmust érdemes írni, amely színfüggetlenül képes a feladatot megoldani. Ehhez az szükséges, hogy kezdéskor a fényérzékelővel mintát kell venni az éppen érzékelt felület színéből és ezt egy változóban eltárolni. A későbbiek során az aktuális mért érték és az eltárolt érték különbsége abszolút értékben ha eltér egy adott tűréshatártól (a programokon belül ez az érték 5), akkor kell az elágazás különböző szálain szereplő utasításokat végrehajtani. Az első olyan program, amelyhez változót szükséges létrehozni. Az fiatalabb korosztály itt találkozott először a változó fogalmával. A grafikus programozási környezet alapértelmezésben nem tartalmaz abszolútérték függvényt, ezért ennek programozása külön problémát jelent. A megoldás során pl. a

- 27 -

rendelkezésre álló intervallum típusú objektum használható, vagy a logikai operátorokkal lehet a matematikai definíciónak megfelelően elkészíteni a kifejezést. Az alábbiakban a színfüggetelen megoldást mindkét programkörnyezetben bemutatom, valamint a program működését is egy videón. Forráskód (rbt)

25. ábra Rbt forráskód: színfüggetlen fényérzékelős akadályészlelés. A programot írta: Barna Szilvia 6. évfolyam.

Forráskód (nxc) #include "NXCDefs.h" #define ERO 50 task main() { SetSensorLight(IN_3); int alap=Sensor(IN_3); while (true) { if (abs(Sensor(IN_3)-alap)<3) OnFwd(OUT_BC,ERO); else { OnRev(OUT_BC,ERO); Wait(1000); OnFwd(OUT_C,ERO); Wait(1000); OnFwd(OUT_BC,ERO); } } }

Asztal_4.wmv

e) Fénykövetés két fényérzékelő szenzorral. Feladatspecifikáció: Írjunk olyan programot, amelyet végrehajtva a robot két fényérzékelőt használva képes egy mozgó fényforrást követni. A két fényérzékelőt a robot két oldalán elhelyezve attól függően kanyarodjon jobbra vagy balra, hogy melyik fényérzékelő mér nagyobb értéket. Mindezt kikapcsolásig ismételje.

- 28 -

Forráskód (rbt)

26. ábra Rbt forráskód: fénykövetés két fényérzékelővel. A programot írta: Bányai Balázs, Lengyel Balázs, Szabó Dániel 7. évfolyam.

Pedagógiai, programozási funkció A programban szerepel a motorok vezérlésére két speciális ikon. Ezek segítségével precízebben lehet a motorokat irányítani. Az is beállítható, hogy ha forgásszögben adjuk meg az elmozdulás értékét, akkor a programszálon szereplő parancsok végrehajtása folytatódjon, és ne várjon a végrehajtás a motorra. Azonban itt minden motor vezérlését külön-külön kell megadni. A hagyományos motorvezérlés esetén akár mindhárom portra kötött motort egyszerre tudjuk vezérelni, de a programszálon szereplő utasítások végrehajtása mindaddig áll, amíg a motorra beállított vezérlési paraméterek végre nem hajtódnak (kivéve a „unlimited” beállítás esetén). Egyenes haladás esetén a két motor automatikus szinkronizációja is megtörténik.

Fenykoveto_1.wmv

Fenykoveto_2.wmv

f) Körhinta Végezetül egy körhinta szimulációjának videóját láthatjuk. A hinta sebességét egy nyomásérzékelővel lehet növelni, míg egy másik nyomásérzékelő hatására megáll a hinta.

Korhinta.wmv

3. programcsoport – útvonalkövetés

a) Útvonalkövetés egy fényszenzorral. Feladatspecifikáció: Készítsünk programot, amelyet végrehajtva a robot egy fényérzékelőt használva az alap színétől jól megkülönböztethető színű vonalat követ. Az útvonalkövetés legyen színfüggetlen és irányfüggetlen. Az irányfüggetlenség azt jelenti, hogy az útvonal által kijelölt mind jobbos, mind balos kanyarokat, akár jobbra, akár balra indítva tudja követni.

- 29 -

Forráskód (rbt)

27. ábra Rbt forráskód: útvonalkövetés egy fényszenzorral.

Forráskód (nxc) #include "NXCDefs.h" #define ERO 50 task main() { SetSensorLight(IN_3); SetSensorTouch(IN_1); until(Sensor(IN_1)==1); int egyik = Sensor(IN_3); until(Sensor(IN_1)==0); until(Sensor(IN_1)==1); int masik = Sensor(IN_3); int hatar = (egyik + masik)/2; while(true) { if (Sensor(IN_3) < hatar) { OnFwd(OUT_C,ERO); Off(OUT_B); } else { OnFwd(OUT_B,ERO); Off(OUT_C); } } }

Pedagógiai, programozási funkció A programok alapötlete, hogy két színmintát veszünk a mozgási felületről. Egyet az asztal színéről, egyet a követendő vonal színéről. Ezen értékek számtani átlaga lesz az a határérték, amely alatti vagy feletti aktuálisan mért színérték esetén jobbra vagy balra fordul a robot. Tehát egyenesen előre soha nem mozog, hanem a követendő vonal szélén „ingadozva” halad. Ha mindezt elég gyorsan teszi, akkor a mozgása kevésbé lesz darabos. Tehát igazából nem a - 30 -

vonalat, hanem annak határát, szélét követi. A színminta vételével színfüggetlenné, a határvonal követésével pedig irányfüggetlenné válik a program. A működésre három különböző videófáljt is bemutatok.

Utkovet_3.wmv

Utkovet_1.wmv

Utkovet_2.wmv

Az egy szenzoros útvonalkövetésre egy másik lehetséges példaprogram. Forráskód (nxc) //A programot írta: Kasza Dániel és Tóth Mátyás 9. évfolyam #include "NXCDefs.h" #define KULONBSEG 5 #define SERVO_L OUT_C #define SERVO_R OUT_A #define SENSOR_LIGHT_1 IN_1 task main() { int i; SetSensorLight(SENSOR_LIGHT_1); i=Sensor(SENSOR_LIGHT_1); while(true) { OnFwd(SERVO_L, -35); OnRev(SERVO_R, -20); until(abs(i-Sensor(SENSOR_LIGHT_1))>=KULONBSEG); OnFwd(SERVO_R, -35); OnRev(SERVO_L, -20); until((abs(i-Sensor(SENSOR_LIGHT_1))>=KULONBSEG)==false); } }

4. programcsoport – több szálú programozás – multitask

a) Mozgás közben figyel más érzékelőkre is. Feladatspecifikáció: Írjunk olyan programot, amelyet a robot végrehajtva egy zárt konvex töröttvonal mentén mozog, ha az ütközésérzékelőjét nyomás éri, akkor megáll, tolat egy adott értékig, majd folytatja az útját a töröttvonal mentén. Mindezt kikapcsolásig ismétli. Pedagógiai, programozási funkció A feladat első hallásra nem tűnik nehéznek. A töröttvonal mentén végzett mozgást egyszerű modellezni. A motorok néhány másodpercig egyenesen mozgatják a robotot, majd az egyik motor néhány másodperces ellentétes irányú mozgatásával megtörténik a fordulás. Ezt a négy utasítást (motorok előre, várakozás néhány mp-ig, egyik motor hátra, várakozás néhány mpig) ismételve elő is áll a mozgásvonal. Első próbálkozásként a programban szereplő ciklusba helyezték be a diákok az ütközésérzékelő vezérelte elágazást (ha be van nyomva tolat néhány mp-ig). A kipróbálás során azonban nem működött a megfelelően.

- 31 -

Forráskód (nxc) #include "NXCDefs.h" #define ERO 30 task main() { SetSensorTouch(IN_1); while (true) { OnFwd(OUT_BC,ERO); Wait(1000); OnRev(OUT_C,ERO); Wait(500); if (Sensor(IN_1)==1) { OnRev(OUT_BC,ERO); Wait(1000); } } }

Koroz_1.wmv Rosszul működő program!

Pedagógiai, programozási funkció A hiba okára kevesen jöttek rá. A magyarázat az, hogy a ciklus futási idejének igen jelentős részét teszi ki a várakozás (Wait() függvény). Amíg a programvégrehajtás ezen az utasítássoron áll, addig az ütközésérzékelő hiába kap igaz értéket, a program nem veszi ezt észre. Ez a hátránya a lineáris programvégrehajtásnak. Ha véletlenül éppen akkor nyomjuk meg az ütközésérzékelőt, vagy (ahogy a videón is látszik) sokáig benyomva tartjuk, akkor elérhetjük azt az állapotot, hogy éppen akkor kap igaz értéket, amikor a ciklusmagban szereplő feltételvizsgálaton van a végrehajtás. A probléma megoldása a két párhuzamosan futó programszál lehet, az egyik vezérli a motorokat, a másik folyamatosan figyeli az ütközésérzékelőt. Ebben az esetben az a probléma jelentkezik, hogy az ütközésérzékelő igaz értékénél mindkét task egyszerre szeretné a motorokat vezérelni, mégpedig ellenkező irányba. Ilyenkor érvényesül a vektoros összegzés és a robot megáll. A motorok ellentétes vezérlésének kiküszöbölésére találták ki a karakteres fejlesztőkörnyezetben használható „mutex” változót. Ez nem okozott osztatlan lelkesedést a szakkörön. Valóban elég körülményes a használata. A grafikus rendszerben pedig nem is áll rendelkezésre. Másik megoldásként adódik, hogy egy globális változón keresztül tudnak a futó taskok adatokat cserélni egymással, így ha taskok folyamatosan figyelik a globális változó értékét, akkor ezen keresztül szabályozható, hogy mikor melyik taskban szereplő motorvezérlő utasítás kapja meg a végrehajtás jogát. Ez a megoldás a grafikus rendszerben is használható. Igaz, hogy programozástechnikai szempontból a globális változók használata kevésbé elegáns, de a célnak megfelelően hatékony. Az alábbiakban a két programkörnyezetben szereplő megoldás és az eredményről készített videófájlok szerepelnek. A programokban a glob nevű változó 0 vagy 1 értéke szabályozza, hogy mikor melyik task vezérli a motorokat.

- 32 -

Forráskód (nxc) #include "NXCDefs.h" #define ERO 30 int glob=0; task koroz() { while (true) { OnFwd(OUT_BC,ERO); Wait(1000); OnRev(OUT_C,ERO); Wait(500); if (glob==1) Wait(1000); } } task vissza() { while (true) { if (Sensor(IN_1)==1) { glob=1; OnRev(OUT_BC,ERO); Wait(1000); glob=0; } } } task main() { SetSensorTouch(IN_1); start koroz; start vissza; }

Forráskód (rbt)

28. ábra Rbt forráskód: többszálú program (multitask).

- 33 -

Koroz_2.wmv

5. programcsoport – robotok közötti kommunikáció bloetooth-on keresztül

a) Távvezérlő. Feladatspecifikáció: Írjunk programot, amelyet végrehajtva az egyik robot bloetooth-os kommunikáción keresztül vezérli a másik robot mozgását! Az egyik robot motorjait és szenzorait használva jeleket küldünk a másik robotnak, amely azokat értelmezi és ezek alapján végezi mozgását. Pedagógiai, programozási funkció A feladat megoldása során legkézenfekvőbb ötletnek az tűnt, hogy a távvezérlőként működtetett robot két motortengelyének elfordulása során mért előjeles szöget átküldve a vezérelt robotnak, az ezeket a számokat a saját motorjai sebességparamétereként értelmezze. Mivel a robotok a sebességet előjeles számként kezelik, ezért a negatív szögelfordulási érték ellenkező irányú sebességet fog eredményezni. A sebesség -100 és +100 között változhat. Az elfordulás szöge azonban ennél jóval nagyobb vagy kisebb is lehet. A vezérlés során ez nem okozott gondot. A határérték átlépését a vezérlő szerkezet konstrukciója fizikailag akadályozta meg. (A motorokat nem lehet egyébként túlvezérelni, még programozói hiba esetén sem.) A bemutatott videók több különböző megvalósítási módot is bemutatnak. Az alábbi három videó a fenti vezérlési szerkezetre épül. A karakteres és a grafikus környezettel előállított bájtkód végrehajtási sebessége között itt már szemmel látható különbség mutatkozott. A grafikus környezetben írt program esetén jól látszik a vezérelt robot darabos mozgása (3. videó). A kommunikáció master-slave alapú. A master a távvezérlő és a slave szerepét a vezérelt robot tölti be. A kommunikáció egyirányú, csak a master küld jeleket a slave-nek, ami értelmezi és végrehajtja azokat.

Tavvezerlo_2.wmv

Tavvezerlo_3.wmv

- 34 -

Tavvezerlo_4.wmv

Forráskód (rbt)

Master

Slave

29. ábra Rbt forráskód: távvezérlés master és slave programja. A programot írta: Kiss Ádám 6. évfolyam

Egy másik megvalósítási lehetőséget mutat be a következő videó. A távvezérlőben lévő egy darab motor különböző irányú elfordítása teszi lehetővé a kormányzást, a másik motor a sebességet szabályozza.

Tavvezerlo_1.wmv

b) Kő – papír – olló játék robotokkal. Feladatspecifikáció: Írjunk programot, amelyet végrehajtva két robot kő-papír-olló játékot játszik. Mindkét robot sorsol egy-egy véletlen számot 1 és 3 között. Az 1 felel meg az ollónak, a 2 a papírnak és a 3 a kőnek. A kisorsolt számok alapján eldöntik, hogy ki veszített és a vesztes tolat hátra néhány cm-t. Mindezt addig ismétlik, amíg a fényérzékelőjük el nem éri a alap színétől jól megkülönböztethető vonalat. Az a robot veszít, amelyik hamarabb eléri a vonalat. Azonos szám sorsolása esetén nincs mozgás. Pedagógiai, programozási funkció A program működése azon alapul, hogy nem kell mindkét robotnak ismernie a másik által kisorsolt számot. A master robot átküldi a slavenek a saját számait, majd a slave eldönti, hogy ki nyert és ennek megfelelően visszaküldi a masternek, hogy kell-e tolatnia, illetve ő maga is végrehajtja a mozgást (ha szükséges). Mindkét robot figyeli a fényérzékelő értékét és forgással reagál, ha elérte a vonalat. A kommunikáció már kétirányú. A legnagyobb problémát az adatküldés szinkronizálása okozta. Amíg a robot nem kapta meg a másiktól az üzenetet, addig nem léphet tovább a programjának végrehajtásában. Ezt while(…) … ciklusokkal oldották meg a diákok. A program bonyolultsága miatt csak C nyelvi környezetben készült el.

- 35 -

Forráskód (nxt) //A programot írta: Mikulás Bence 9. évfolyam //SLAVE #include "NXCDefs.h" #define KO 3 #define PAPIR 2 #define OLLO 1 task main() { SetSensorLight(IN_3); int x,in=0,valasz=0,alap=Sensor(IN_3); TextOut(0,50,"Mast",false); TextOut(50,50,"Slave",false); while (true) { x=Random(3)+1; while (in==0) ReceiveRemoteNumber(1,false,in); NumOut(0,0,in,false); NumOut(50,0,x,false); Wait(200); if ((in==KO && x==OLLO) || (in==PAPIR && x==KO) || (in==OLLO && x==PAPIR)) { valasz=4; SendResponseNumber(1,valasz); } if ((x==KO && in==OLLO) || (x==PAPIR && in==KO) || (x==OLLO && in==PAPIR)) { valasz=5; SendResponseNumber(1,valasz); OnRev(OUT_BC,50); Wait(100); Off(OUT_BC); } if (abs(alap-Sensor(IN_3))>10) { OnRev(OUT_B,100); OnFwd(OUT_C,100); Wait(300); Off(OUT_BC); Stop(true); } valasz=0; in=0; } } //A programot írta: Mikulás Bence 9. évfolyam //MASTER #include "NXCDefs.h" task main() { SetSensorLight(IN_3); int x,tolat=0,alap=Sensor(IN_3); while (true) {

- 36 -

x=Random(3)+1; SendRemoteNumber(1,1,x); while (tolat==0) ReceiveRemoteNumber(1,true,tolat); if (tolat==4) { OnRev(OUT_BC,50); Wait(100); Off(OUT_BC); } if (abs(alap-Sensor(IN_3))>10) { OnRev(OUT_B,100); OnFwd(OUT_C,100); Wait(300); Off(OUT_BC); Stop(true); } tolat=0; } }

6. programcsoport – speciális robotok – „Sumo harcosok” 2008. június 7-én rendezte meg a szegedi Ságvári Endre Gimnázium az első Magyar Robot Sumo bajnokságot. Nemzetközileg a versenynek nagy hagyományai vannak. Bizonyítja ezt a részletesen kidolgozott szabályrendszer és az interneten található sok publikáció és videó. A verseny lényege, hogy olyan LEGO építőelemekből készített robotot kell készíteni, amely autonóm módon képes működni (a távvezérlés nem megengedett). Egy 4 láb átmérőjű fekete színű körpályán mozoghatnak a robotok, amelyet körben 2 inch szélességű fehér körgyűrű határol. A mérkőzéseken két-két robot küzd egymással és az a cél, hogy az ellenfelet a küzdőtéren kívülre tolják, vagy mozgásképtelenné tegyék. Ehhez természetesen figyelnie kell arra, hogy a pályán belül maradjanak (tehát figyelnie kell a fehér színű szegélyt), érdemes kereső algoritmust írni a robot működtető algoritmusába, amely képes a pályán belül megkeresni az ellenfelet. A programozás mellett fontos szerep jut a tervezésnek, a konstrukció kialakításának. A mozgáshoz használt motorok és kerekek alapvetően meghatározzák a sebesség és nyomaték viszonyát. A súlypont elhelyezése is fontos. A pálya határát figyelő szenzor és a kerék távolsága nem lehet nagyobb, mint 2 inch, ellenkező esetben a fordulásnál a robot kilép a pályáról. Ezen kívül olyan technikai megoldásokra van szükség, amelyek lehetővé teszik az ellenfél robotjának megmozdítását, felemelését, pályán kívülre tolását. Mindezt úgy, hogy egy-egy robot tömege nem haladhatja meg a 2 fontot (~909 g) és el kell, hogy férjen egy 1x1 láb méretű négyzetben. Az építéshez csak szabályos LEGO elemek használhatók. A versenyen a robotok a pálya közepéről, egymástól 12 inch távolságról indulnak, egymásnak háttal, három másodperc késleltetés után. Kezdésként a középponttól legalább 2 inch távolságot távolodniuk kell, csak ezután kezdhetnek akciót. Az első támadást szemből kell intézniük az ellenfélhez. Minden robot minden robottal három, legfeljebb 1 perces mérkőzést vív. Az összesített eredmény alapján dől el a végső sorrend. A szabályok részletes leírása a 4. mellékletben található.

- 37 -

30. ábra Robot sumo pálya ábrája.

Az eddigi zömében programozást igénylő feladatok mellett a szakkör egyik fontos eleme lett az építés, tervezés. Ez nagyon időigényes feladat és rengeteg fizikai (elsősorban mechanika) probléma merült fel. Például: a kerekek hajtását fogaskerék áttétellel, vagy anélkül érdemes-e megvalósítani. A megengedett mérettartományon belül magasabb (magasság korlát nincs a robotra), vagy inkább szélesebb (nagy íven fordul) robotot érdemes építeni. A súlypont minél alacsonyabbra kell, hogy kerüljön a stabilitás miatt. A robot megépítése után következhetett a programírás. Általában a pályán maradáshoz, a fehér szegély észleléséhez és a megfelelő „menekülő” mozgás elindításához két-két fényérzékelőt (elől egy és hátul egy) használtak a diákok. Az ellenfél megtalálásához ultrahangszenzort, míg az ütközések figyelésére ütközésérzékelőt. Nem minden elkészített robot használta ki az összes szenzorok adta lehetőséget. A robotra elméletileg 3 motor és 4 szenzor csatlakoztatható egy időben. A programok minden esetben többszálú (multitask) technikát használtak. A tesztelés sok időt vett igénybe, folyamatosan át kellett építeni a robotokat és változtatni kellett a programokon, a feltárt hibáknak megfelelően. Ugyanakkor a versenyben rejlő kreativitási lehetőség hatalmas motivációt jelentett, amit az országos versenyre elkészült 5 különböző sumo robot is bizonyít. Itt már csapatmunkáról volt szó, minden robot mögött kéthárom fős konstruktőri csapatok álltak. Az országos versenyen egy 2. és egy 4. helyezést sikerült megszerezni.

31. ábra Az országos robot sumo versenyen részt vett öt robot. Konstruktőrök és programírók:

Bányai Balázs Lengyel Balázs Szabó Dániel

Lukács Kata Nagy Gergő

Benkő Emese Kiss Ádám

Fodor Péter Móczár Dávid

Kasza Dániel Tóth György Varga György

Az alábbiakban néhány videó részlet következik, amelyek bemutatják a robotokat. A működési algoritmusok is megfigyelhetők és néhány megjegyzéssel a konstrukciós vagy programozási ötletekre hívom fel a figyelmet.

- 38 -

Az előkészületek, tesztmérkőzések:

Sumo_proba_1.wmv

Sumo_proba_4.wmv

Sumo_proba_3.wmv

Sumo_proba_2.wmv

Az első videón két olyan robot szerepel, amelyekre nem építettek a konstruktőrök ultrahangszenzort, így nem keresik az ellenfelet, hanem egy algoritmus alapján mozognak és a „véletlen” műve, hogy találkoznak-e. Ez elnyújtja a mérkőzést, de pálya méretei miatt nem jelent problémát. A bal oldalról induló robot specialitása, hogy négy motor hajtja. A három output portra a LEGO készletben található, és az RCX (régebbi típusú) robothoz készült kábel segítségével sikerült a négy motort csatlakoztatni, de ez azzal járt, hogy két-két motor ugyanazt a vezérlőjelet kapta, viszont a sok motor miatt nagyon erős lett a gép. Ez jól érzékelhető a második, harmadik videón is és a döntőn készült videókon is. A negyedik videón szereplő bal oldali robot esetében előjött néhány konstrukciós és programozási hiba. Egyrészt, hogy a tolólapot meg kell erősíteni, mivel az ütközésnél szétesett, másrészt a nagy tengelyszélesség miatt, ha rossz szögben érkezik a fehér szegélyhez, akkor nem tud a pályán belül maradni, ezt algoritmikusan és szerkezetileg is javítani kellett.

32. ábra A sumo robotok és konstruktőreik.

Az országos verseny: A próbák után megtörténtek a korrekciók. Az országos versenyre öt megépített robot utazott. A versenyen a pályák fényviszonyai okozták a legnagyobb problémát. A megvilágítás nem volt egyenletes, így a fényérzékelők sok esetben eltérő értékeket mértek a fekete színű pálya különböző pontjain, de minden versenyző robot ugyanezzel küzdött, több-kevesebb sikerrel. Az alábbi videó jól érzékelteti mindezt.

- 39 -

Sumo_5_donto.wmv

A négy motorral megépített robot továbbra is stabilan demonstrálta az erőviszonyokat.

Sumo_7_donto.wmv

Az alábbi két videón szereplő robot IV. helyezést el az országos versenyen. Az ultrahangszenzorral fordulás közben keresi az ellenfelet, de a határként beállított érték 30 cm. Ez lehetett volna nagyobb is, de a pálya mellett állók zavarhatták volna a keresésében. A verseny közben már nem lehetett módosítani a programokon. A robot megépítése jól sikerült, stabil szerkezet és megfelelően alacsonyra helyezett súlypont jellemezte. Az első videó mutatja a nehezen boruló szerkezetet. Ugyanakkor az alkalmazott széles kerekek megfelelő tapadást biztosítottak, ami a második videón jól megfigyelhető.

Sumo_4_donto.wmv

Sumo_3_donto.wmv

Az országos versenyen II. helyezést elért robot négy mérkőzéséről készült videót láthatunk az alábbiakban, de előtte érdemes a felépítéssel és az algoritmussal megismerkedni.

33. ábra A robot sumo verseny II. helyezett robotja.

Két fényérzékelő figyelte a pálya szegélyét elől és hátul egy-egy. A fényérzékelők által vezérelt ciklusok külön taskban futottak. A fényérzékelők színfüggetlenül és 10-es tűréshatárok között tudtak különbséget tenni a mért értékek között. Ultrahangos távolságérzékelő kereste az ellenfelet (60 cm-re állított tartományon belül), de csak akkor, amikor a robot a pálya szélén fordult. Tehát a fordulás (ami kb. 200o-os fordulót jelentett) közben kereste az ellenfelet. Ha megtalálta 60 cm-en belül, akkor elindult felé, egyébként a forduló után egyenesen haladt a pálya szegélyéig, ahol ismét fordult. A sebessége viszonylag alacsony volt, mert fogaskerék áttétellel inkább a nyomaték növelése mellett döntött a

- 40 -

konstruktőr team. Ha megtalálta az ellenfelet és ütközött vele, akkor ezt egy, a robot elejére szerelt ütközésérzékelő jelezte. Ebben az esetben a robotra szerelt harmadik motor felemelte a tolólapot, ezzel próbálta az ellenfelet megemelni. Az emelés hatékonyságát egy egyszerű erőkaros emelővel sikerült fokozni, aminek a precíz vezérlése komoly programozási feladat volt. A próbák során az is kiderült, hogy a kerekek tapadása a sebesség függvényében változik, így nagy motorsebességnél, ha akadályt tol a robot a kerekek kipörögtek, így nem volt hatékony a folyamat. Ezért a robot algoritmusa úgy működött, hogy ha az ütközésérzékelő igaz állapotot jelzett, akkor nem csak az emelő indult be, hanem a sebesség is csökkent, így akadályozva meg a kerekek kipörgését. Több egyszerű ötlet is bekerült még az algoritmusba, amelynek fejlesztése sok próba után kb. két hétig tartott. Hozzászámítva az építésre fordított időt a robot teljes megépítése a dokumentációval együtt egy hónapos munka volt. Erre már nem volt elegendő a szakköri keret. A kutatási program ezen szakaszában lehetőség volt két szakköri foglalkozás között a robotok otthoni kölcsönzésére.

Sumo_8_donto.wmv

Sumo_1_donto.wmv

Sumo_2_donto.wmv

Sumo_6_donto.wmv

34. ábra Az országos robot sumo verseny néhány résztvevője és a verseny előkészületei.

Forráskód (rbt) A robot kommentekkel ellátott rbt vezérlőprogramja a DVD mellékleten megtalálható. Az alábbi képen ez szerepel (magyarázatok nélkül). A program mérete és bonyolultsága miatt valószínűleg kevésbé jól látható formában, csupán abból a célból, hogy elképzelést lehessen alkotni az egy hónapos fejlesztő munka eredményéről.

35. ábra Rbt forráskód: az országos robot sumo verseny II. helyezett robotjának vezérlőprogramja.

- 41 -

A következő képen egy másik robotvezérlő program látható, szintén csak a minta kedvéért.

36. ábra Rbt forráskód: az országos robot sumo verseny egyik robotjának vezérlőprogramja.

7. programcsoport – speciális robotok – lift A programozási alapok elsajátítása után a diákok fantáziája „meglódult” és sorra építettek olyan szerkezeteket, amelyek autonóm vagy külső irányítással működtek és vezérlő algoritmusuk tartalmazta azokat az elemeket, amelyeket a szakköri keretek között megismertek. Ehhez már kevés volt az iskola rendelkezésére álló LEGO építőelemkészlet, ezért otthoni forrásokat is fel kellett használni. Egy ilyen konstrukció, egy elkészült lift modellje, amely 5 emelet közötti mozgást szimulált, a földszinttől a 4. emeletig. A vezérléshez három szenzort használ. Egy nyomásérzékelővel lehet beállítani a célemelet sorszámát (0-4, ciklikus számlálás). Egy fényérzékelő megérintésével indul el a mozgás. Egy másik fényérzékelő figyeli azt, hogy éppen hányadik emeleten tart a lift (a második fényérzékelő az RCX robothoz kifejlesztett típus). A felvonó pillanatnyi helyzetének érzékeléséhez szerkezetileg a figyelő és a lifttel együtt mozgó fényérzékelő elé eltérő színű LEGO elemeket építettek be, amelyek alapján eldönthető az aktuális helyzet. Az aktuális és célemelet sorszámát változók tárolják, ezek összehasonlítása alapján dönt a program a szükséges mozgás irányáról (le vagy föl) és mértékéről. A mozgás mechanikailag fogaslécek és fogaskerék rendszerek együttes használatával teszi lehetővé a felfelé kapaszkodást és lefelé ereszkedést. További feszítő és tartó elemek beépítése volt szükséges a liftakna stabilitásának megőrzéséhez és a lift mozgás közbeni vízszintesen tartásához.

- 42 -

37. ábra A lift szerkezeti felépítése.

Lift.wmv

Forráskód (rbt)

38. ábra Rbt forráskód: lift vezérlőprogramja. A programot készítette: Kiss Ádám 6. évfolyam.

- 43 -

8. programcsoport – speciális robotok – szkenner A kutatási programhoz mellékelt pályázatban is szerepelt egy szkenner megépítése. A pályázat benyújtásának pillanatában még bizonytalan volt, hogy vajon a diákok közül lesz-e majd valaki, aki kellő motivációt és tehetséget érez egy ilyen projekt megvalósítására. Kasza Dániel 9. évfolyamos tanuló vállalta az elkészítést. Az autonóm módon működő gép egyetlen fényérzékelőt használ a beolvasáshoz. A képet a robot LCD képernyőjén jeleníti meg. Két motor vezérli a papír továbbítását és a fényérzékelő mozgatását. Az építéshez saját eszközöket, elemeket is használt. Az alábbi képek, videók és a forráskód alapján megérthető a működés.

39. ábra Szkenner szerkezete és a szkennelés eredménye.

Scanner.wmv

Forráskód (nxc) /* szkenner * Created by Daniel Kasza on 4/20/08. * Copyright 2008 __MyCompanyName__. All rights reserved. */ #include "NXCDefs.h" #define ADAGOLO OUT_B #define FEJ OUT_A #define FEJ_MOZGAS 475 #define SPEED 45 #define SPEED_ADAGOLO 30 #define PONTOSSAG 15

- 44 -

#define SENSOR_TOUCH_1 IN_1 #define SENSOR_FEJ IN_3 #define ELTERES 5 task main() { int minta; int i,i2; int count; byte meres; SetSensorTouch(SENSOR_TOUCH_1); SetSensorLight(SENSOR_FEJ); minta=Sensor(SENSOR_FEJ); OnFwd(ADAGOLO, SPEED_ADAGOLO); until(abs(minta-Sensor(SENSOR_FEJ))>ELTERES); Off(ADAGOLO); OnFwd(FEJ, SPEED); until(Sensor(IN_1)); Off(FEJ); for(i=0; i<64; i++) { for(i2=0; i2<30; i2++) { RotateMotor(FEJ, SPEED*(-1), PONTOSSAG); meres=Sensor(SENSOR_FEJ); if(meres<55) { PointOut(i2,i,false); } } OnFwd(FEJ, SPEED); until(Sensor(SENSOR_TOUCH_1)); Off(FEJ); RotateMotor(ADAGOLO, SPEED_ADAGOLO, PONTOSSAG); } }

- 45 -

Összegzés A programba bevont több mint 30 tanuló és az öt hónapos (február-június) időintervallum alatt megtartott közel 100 órányi foglalkozás azt bizonyítja, hogy a program sikeres volt. A megfogalmazott kutatási célok (csomópontok) többsége megvalósult. A természettudományos mérések területén nem sikerült valamennyi kitűzött célt elérni, de ez a szűk időintervallumnak volt köszönhető. A szakkörökön résztvevő tanulók legtöbbje, köszönhetően az eszközben rejlő motivációs hatásnak, elsajátította azokat az alapokat, amelyek a programozói tudás megszerzéséhez fontosak. A megírt programok bizonyítják, hogy az alapvető programozási fogalmak közül a ciklusok, feltételes elágazások, paraméterátadás, változók és tulajdonságaik, operátorok fogalmával tisztában vannak. Egyszerűbb programok kapcsán ezeket tudják a gyakorlatban is használni. Néhányan olyan kreatív programozási ötletet és megoldást is képesek kitalálni és megvalósítani, amely már komolyabb algoritmizálási kompetenciáról tanúskodik. A hagyományos középiskolai programozás oktatáson túl sikerült olyan eszközöket és technikákat is bemutatni, amelyek a számítástechnika legmodernebb alkalmazási területei közé tartoznak (pl. multitask-os programozás és bluetooth-os kommunikáció). Sikerült a kapcsolatot megteremteni más tantárgyakkal, elsősorban a matematikával és a fizika mechanika területével. Az utóbbi azért is fontos, mert társadalmilag már jelentkezik az igény a magasan képzett műszaki tudással rendelkező mérnökök irányában. A sikerek annak is köszönhetők, hogy a diákok egy része nem csak a szakköri alkalmakon foglalkozott a programozással, hanem önképzéssel, sok délutáni plusz órában, a zömében angol nyelvű szakirodalom egyéni feldolgozásával képezte magát. Természetesen a megszerzett tudás csak az alapot jelenti a továbblépéshez, de azt gondolom, hogy valamennyi szakkörre járó tanuló megszerezte ezeket az alapokat. A fenti megállapítások alátámasztására nem készültek empirikus vizsgálatok, de a beszámolóban bemutatott programok (amelyek a tanulók munkái) alátámasztják mindezt. A kutatás tapasztalatait felhasználva megnyílt a lehetőség arra, hogy a használt eszközöket tanórai szinten is, nem csak a teljes mértékben érdeklődők, hanem a csoport valamennyi résztvevője számára elérhetővé tegyük. Egy következő kutatás témája lehet az, hogy mennyire lehet az algoritmikus gondolkodás fejlesztését kiváltani ezen eszközök használatával. A megcélzott életkori kategória a 6-7. évfolyam lehet. Ebben az életkorban a logo nyelvet válthatja fel a robotprogramozás. A másik irány a természettudományos mérések és vizsgálatok végzése a robotok szenzoraival és azok értelmezéséhez, elvégzéséhez készített programokon keresztül. Az itt megcélzott korosztály a 9-10. évfolyam lehet. Figyelembe véve a szakkörökön résztvevő diákok életkorát (a többségük 13-16 éves), azt gondolom, hogy a programban rejlő programozási motivációnövelés a legfontosabb eredmény. A kísérlet bebizonyította, hogy a hagyományos középiskolai programozás oktatás tartalmi elemei (érettségi követelmények) sokak számára azért riasztóak, mert az igazán kihívást jelentő, gyakorlatközeli feladatok megoldásához hosszú és fáradtságos út vezet. Amíg egy adott programnyelv szintaktikai és szemantikai alapelemei kellően begyakorolt és készségszintű alkalmazási szintre jutnak, addig a legtöbb diák már megunja a sok hibajavítást igénylő programozást. Ez kiküszöbölhető a robotok használatával, mert közvetlenül kézzelfogható módon lehet a legfontosabb programozástechnikai elemeket megtanítani, és sok olyan informatikailag fontos technikát, amely enélkül megmaradna az elméleti ismeret szintjén. A középiskolás korosztály számára az absztrakt gondolkodás kialakulásának szakaszában a gyakorlati kézzelfoghatóság nagyon fontos. A logo nyelv sikere is ezzel magyarázható, hiszen ott is lényegesen nagyobb látványtechnika jelenik meg, mint pl. a

- 46 -

legtöbb középiskolában a mai napig favorizált karakteralapú programozásnál. A programfejlesztés hazai és nemzetközi trendjei is az objektumok segítségével elkészített programozói munka felé halad. Azt gondolom, hogy amennyiben a középiskolai oktatás financiális helyzete javul, akkor a jövő programozás oktatási eszköze lehet a bemutatott technika. Nemzetközi példák már vannak erre vonatkozóan. Ezért is lenne fontos, hogy tanórai alkalmazhatóságát sikerüljön demonstrálni és készüljön olyan tananyag, útmutató, amely alapját képezheti a közép- és általános iskolai elterjedésnek.

- 47 -

További tervek 1. Szakkörök A két szakkörön résztvevő diákok képezhetik a magját annak a populációnak, amely később a műszaki felsőoktatás felé tanul majd tovább. Ehhez az érdeklődést folyamatosan fenn kell tartani. Ennek egyik lehetősége a szakkörök további folytatása, valamint az országos és nemzetközi versenyeken való részvétel. 2. Versenyek Jelenleg egy olyan nemzetközi verseny van, amely nyílt nevezésű csapatverseny és részben a LEGO robotok programozására és építésére épül. Ez a First Lego League (fll) verseny minden év őszén. A 2008-as versenyre két 10 fős csapattal nevezett a Gimnázium (további információ: http://www.firstlegoleague.org). Egy másik, de országos verseny a robot sumo bajnokság, amely a tervek szerint minden évben késő tavasszal kerül megrendezésre. A 2008-as versenyen a Gimnázium 5 csapattal vett részt, terveink szerint 2009-ben is indulunk (további információ: http://sagv.gyakg.uszeged.hu/szumo). Mindkét versenyen nagy szerep jut az építésnek, tervezésnek. Jelenleg hiányzik a versenypalettáról egy olyan verseny, ahol a programozói tudás, a kreatív programírás dominálna. 2008 őszén kísérleti jelleggel (meghívásos verseny formájában) megpróbálunk egy nagyrészt a LEGO robotok programozására épülő és nagy versenyzői kreativitást igénylő versenyt szervezni. 3. Kontrollcsoportos kísérlet Az összegzésben is említett tanórai alkalmazás kipróbálása a másik tervünk. Ehhez egy olyan kontrollcsoportos kísérlet lebonyolítását tervezzük, amely a kezdeti bemeneti szinten mérné az algoritmikus gondolkodás fejlettségi szintjét. A kísérleti csoportokban a LEGO robotokkal, a kontroll csoportokban logo programozási nyelven történne meg a fejlesztés. A kísérlet végeztével újabb méréssel dokumentálnánk a csoportokon belüli hozzáadott értéket. Termékként előállna egy olyan tanmenet és tartalmi dokumentáció, amely kiindulási alapját képezhetné a későbbi esetleges szélesebb körű elterjedésnek. A megcélzott életkori korosztály a 6. vagy 7. évfolyam, és a kísérlet időtartama legalább 5 hónap.

A tervek megvalósításához még keresünk további pályázati lehetőségeket és szponzorokat.

- 48 -

1. melléklet: Eszközvásárlási igazolás

- 49 -

2. melléklet: A résztvevők névsora I. kategória (6-8. évfolyam) Ács Péter 6. évf. Bányai Balázs 7. évf. Barna Szilvia 6. évf. Benkő Emese 6. évf. Börönte Bence 6. évf. Buzási Gábor 6. évf. Buzási Tibor 8. évf. Csontos Máté 6. évf. Fodor Péter 6. évf. Győri Bátor 7. évf. Király Alfréd 7. évf. Kiss Ádám 6. évf. Lengyel Balázs 7. évf. Móczár Dávid 6. évf. Szabó Dániel 7. évf. Szabó Salamon 7. évf. II. kategória (8-11. évfolyam) Fodor Ferenc 11. évf. Horváth Martina 10. évf. Huszti Péter 9. évf. Jónás Máté 10. évf. Kádár Péter 9. évf. Kasza Dániel 9. évf. Katona Áron 9. évf. Kis Dávid 10. évf. Kurucz Milán 9. évf. Lukács Kata 8. évf. Mikulás Bence 9. évf. Molnár Dániel 9. évf. Nagy Gergő 8. évf. Tóth Mátyás 9. évf. Varga György 9. évf. Ziegner Kristóf 9. évf. Zöldi-Kovács Róbert 11. évf.

- 50 -

3. melléklet: A kutatási program foglalkozásainak tematikus listája I. kategória (6-8. évfolyam) Sorszám

Időpont

1-2.

2008.02.05.

3-4.

2008.02.12.

5-6. 7-8.

2008.02.25. 2008.03.11.

9-10.

2008.04.01.

11-12.

2008.04.08.

13-14. 15-16. 17-18. 19-20. 21-22.

2008.04.22. 2008.05.13. 2008.05.20. 2008.06.03. 2008.06.10.

Téma Ismerkedés a robottal és a grafikus szoftverkörnyezettel. A programozható tégla, szenzorok és motorok, programok készítése, ikonok használata, áttöltése a robotra. Programok szerkezeti elemei: elágazások, ciklusok és ezek megvalósítása szenzorhasználattal. Képernyőkezelés (LCD kijelző), adatfolyamok. Változók használata, paraméterátadás az objektumok között. Útvonalkövetési program írása (konstansokkal és színfüggetlenül). Egyszerű és bonyolultabb algoritmusok (paraméterátadással, változókkal, multitask programozás). Robot sumo algoritmusírás és robotépítés. Robot sumo algoritmusírás és robotépítés. Robot sumo verseny tréning. Bluetooth-os kommunikáció, távvezérlés. Projektek zárása, bemutatók, szabad robotprogramozás.

II. kategória (8-11. évfolyam) Sorszám

Időpont

1-2.

2008.01.28.

3-4.

2008.02.04.

5-6.

2008.02.11.

7-8.

2008.02.18.

9-10. 11-12. 13-14. 15-16. 17-18. 19-20. 21-22. 23-24. 25-26. 27-28.

2008.03.10. 2008.03.17. 2008.03.31. 2008.04.07. 2008.04.14. 2008.04.21. 2008.04.28. 2008.05.19. 2008.05.28. 2008.06.02.

29-30.

2008.06.09.

Téma Ismerkedés a robottal és a karakteres szoftverkörnyezettel. A programozható tégla, szenzorok és motorok, a C nyelv alapjai. Az NXC nyelv alapjai (változók, elágazások, ciklusok), input szenzorok kezelése. Ciklusok használata. Timerek, képernyőkezelés. Programozási tételek (megszámlálás algoritmusa). Útvonalkövetés (színfüggetlen), fájlműveletek. Bluetooth-os kommunikáció (távvezérlés). Egyéni programozási feladatok, projektek I. Egyéni programozási feladatok, projektek II. Robot sumo algoritmusok és robottervezés. Kő-papír-olló, kommunikációs feladatok. Ultrahangos falkövetés, egyéb programozási feladatok. Egyéni programozási feladatok, projektek III. Robot sumo verseny algoritmus tesztelés. Robot sumo verseny tréning. Projektek zárása, programozási feladatok megoldásának dokumentálása (videókészítés).

- 51 -

4. melléklet: A sumo robot verseny szabályjegyzéke Küzdőtér A szumó küzdőtér egy olyan összesen négy láb (4 láb = 121,92 cm) átmérőjű, matt feketére festett korong, amelyet két hüvelyk (2 inch = 5,08 cm) széles körkörös fehér gyűrű határol le. A küzdőtér felszíne sima furnérlemez, és néhány pár centivel a talaj fölött áll, hogy a bíróknak könnyebb legyen eldönteni, hogy melyik robot hagyta el elsőként a küzdőteret. A robot akkor tekinthető a küzdőtérről kiesettnek, ha valamely része megérinti a talajt.

Hogyan játszák a szumót? A versenyszabályok és irányelvek versenyről versenyre változhatnak kissé, itt általános iránymutatást adunk ahhoz, hogy hogyan lehet játszani ezt a játékot. A szumó robotok indításkor a szumó küzdőtérre egymástól 12 hüvelykre helyezzük el, egyenlő távolságra a küzdőtér központjától (6-6 hüvelykre, kb. 15-15 cm-re a központtól). A robotok egy egyenes mentén helyezkednek el, és mindegyik a másikkal ellentétes irányba indulhat el. Így a robotoknak aktívan kutatniuk kell az ellenfél után, és nem lehet legőzhengerelni az ellenfelet egyből. A verseny több körből áll. Mindegyik kör három percre van korlátozva (vagy három nyert rohamra, attól függően, hogy melyik következik be először jön). Ha nincs nyertes a három perc végén, akkor azt döntetlennek tekintjük. A kör nyertese az a robot, amelyik elsőként megnyert három rohamot. Egy roham nem lehet hosszabb, mint egy perc. Egy kör nyertese két pontot kap, a vesztes nullát. Ha az eredmény döntetlen, akkor mindegyik robot egy-egy pontot kap. Ha egy roham alatt a robotok összeakadnak, vagy láthatóan nem tudnak döntésre, mindkét versenyző elfogadhatja a roham újraindítását. A robotok többször is újraindíthatóak, de összesen három percig tarthat ekkor is a kör. (Más szóval amint három perc fenn áll mindig, és a kör eredményét a befejezett rohamok eredményei határozzák meg akkor is, ha három befejeződött roham nem valósult meg ez alatt az idő alatt). Egy roham kezdetén a robotok gazdái, a játékosok meghajolnak egymás előtt. Majd a játék vezető beszámol: három, két, egy, GO! A játékosok aktiválják a robotjaikat, és a térfelüket elhagyják. A robotoknak három másodpercet várniuk kell, mielőtt bármilyen elmozdulást kezdenének (ez alól kivétel tehát, hogy az alakja változik, például kinyúlik vagy behúzódik egy kar vagy másik része). Az első elmozdulásnak a küzdőtér középpontjától távolodónak kell lennie. Ha nem egyértelmű a robot elülső része, akkor az első mozgás iránya fogja meghatározni a robot az elülső részét a továbbiakban is. A robotnak mindaddig kell előre, a középponttól sugár irányban távolodva mozognia, amíg el nem hagyja teljes terjedelmében a kezdő területet, amit a robot számára nem érzékelhetően, de a bírók számára jól láthatóan festenek fel a pályára. Ezután bármilyen mozgást szabadon végezhet. Ha a robot a másik robotot az első alkalommal támadni akarja, akkor azt háttal nem teheti meg. (Azaz a robot nem teheti meg azt, hogy elhagyja a kezdőpozíciót, majd egyből hátramenetbe kapcsol, és úgy támad neki az ellenfélnek. A támadáshoz arccal felé kell fordulnia először.) Ha egy robotot már ért támadás, vagy végrehajtott egy támadást, utána bármely irányban haladva támadhatja az ellenfelét. A robotnak egy roham kezdését követő tíz másodpercen belül el kell kezdenie előre mozogni. A robotok küzdelme, azaz egy roham addig tart, amíg az egyik egység mozgásképtelen nem lesz, vagy elhagyja a küzdőteret. Egy robotról úgy válik egyértelművé, hogy elhagyta a küzdőteret, ha bármely része megérinti a padlót, vagy a gazdája hozzáér a küzdőtéren. Ha egy robot teste lebeg a küzdőtér élén, és nem érinti meg a talajt, akkor 10 másodperc után lesz csak vesztes, ha addig a másik robot nem hagyja el a küzdőteret, ha a másik ezalatt talajt fog, akkor ez első, fennakadt robot nyer. Az a robot, amelyik kilöki a küzdőtérről az ellenséget vagy megbénítja, győz, és ha egy robot öngyilkos lesz, akkor a másik robot győz. Mindkét tény megállapításában a bírók ítélete a döntő.

A szumó robotokról 

     

Minden szumó robotot úgy kell megépíteni, hogy 100 százalékban szétbontható legyen, és eredeti LEGO alkatrészekből állítják elő. (Ragasztást, szétvágást, olvasztást vagy bármilyen más módosítást az alapszabályok nem engednek meg). Ez a szabály az érzékelőkre és motorokra szintén vonatkoznak. A robotnak el kell férnie egy 1×1 lábnyi négyzetbe, bárhogy is áll benne, akár átlósan is. (1 láb =30,48 cm) Magasság határ nincs. A robot alapjának egy LEGO MINDSTORMS téglának (NXT vagy RCX) kell lennie. A robot súlya nem lehet több kettő fontnál. (2 font = 0,909 kg) Robotoknak elegendő állóképességgel kell rendelkeznie ahhoz, hogy potenciálisan 12-36 percet versenyezzen újratöltés nélkül. Egy mérkőzés alatt nem lehet megváltoztatni a robot szerkezetét vagy a programozását. A robotnak teljesen autonómnak kell lennie, de a korábban betáplált programok között lehet váltani a körök előtt, de kör közben már nem.

Források: http://sagv.gyakg.u-szeged.hu/szumo/ http://www.24tooth.com/SumobotRules.html

- 52 -

5. melléklet: A DVD tartalma A kutatás során használt C alapú fejlesztőkörnyezet és a hozzá tartozó dokumentáció (angol nyelvű). A kutatási beszámolóban hivatkozott képek. A kutatási beszámolóban hivatkozott programok, forráskódjai a megvalósítás során készített fontosabb robotprogramokkal. Két különböző nyelvi környezetben. Grafikus-ikonvezérelt környezet: rbt C alapú, karakteres környezet: nxc A kutatási beszámolóban hivatkozott videó fájlok, a megvalósítás során készített robotprogramok működéséről. Három különböző formátumban (avi, mov és wmv).

A beszámoló szöveges részét a Beszamolo_Banyai.doc és a Beszamolo_Banyai.pdf állományok tartalmazzák. A dokumentumba beillesztett videófájlok hivatkozott állományai a DVD-n teljes egészében megtalálhatók.

- 53 -