Programozás | Egyéb » Kőrösi Gábor - Lego NXT robot programozása NXC nyelv segítségével

Az NXC nyelv Lego NXT robot programozása NXC Nyelv segítségével 1 Írta és fordította: prof.ingKőrösi Gábor Oldal 2010, Zenta-Szerbia, Bolyai Tehetséggondozó Gimnázium www.bolyai-zentaedurs Prof.ingKőrösi Gábor Az NXC nyelv 2010 BEVEZETŐ 2 I. 3 AZ ELSŐ PROGRAMUNK MEGÍRÁSA A ROBOT ÉPÍTÉSE 3 ISMERKEDÉS A BRICX COMMAND KÖZPONTAL 4 A PROGRAM ÍRASA 5 A PROGRAM FUTTATÁSA 6 HIBÁK A PROGRAMUNKBAN 6 A SEBESSÉG VÁLTOZTATÁSA 7 ÖSSZEFOGLALÓ 8 II. ÉRDEKESEBB PROGRAM KÉSZÍTÉSE 9 FORDULÓ MOZGÁS KÉSZÍTÉSE 9 UTASÍTÁSOK ISMÉTLÉSE 10 KOMMENTÁROK HOZZÁADÁSA 11 ÖSSZEFOGLALÓ 12 13 MOZGÁS SPIRÁL ALAKZATBAN 13 VÉLETLEN SZÁMOK 14 ÖSSZEFOGLALÓ 15 16 AZ IF – FELTÉTELES UTASÍTÁS 16 A DO UTASÍTÁS 17 ÖSSZEFOGLALÓ 18 V. ÉRZÉKELŐK 19 VÁRAKOZÁS AZ ÉRZÉKELŐRE 19 LEHETŐSÉGEK AZ ÉRINTŐ ÉRZÉKELŐVEL 20 FÉNYÉRZÉKELŐ 20 HANG ÉRZÉKELŐ 21 ULTRAHANGOS ÉRZÉKELŐ 22

ÖSSZEFOGLALÓ 23 VI. FÜGGVÉNYEK ÉS ELJÁRÁSOK 24 ELJÁRÁSOK 24 FÜGGVÉNYEK 25 MAKRÓK DEFINIÁLÁSA 27 ÖSSZEFOGLALÓ 28 Prof.ingKőrösi Gábor Az NXC nyelv 2 IV. VEZÉRLŐ UTASÍTÁSOK Oldal III. VÁLTOZÓK HASZNÁLATA 2010 VII. VIII. HANG SUGÁRZÁSA HANG FÁJL LEJÁTSZÁSA 29 HANG JÁTSZÁSA 30 ÖSSZEFOGLALÓ 31 A MOTOROK MÉLYEBB ISMERETE 32 LÁGY LEÁLLÍTÁS 32 ÖSSZETETT VEZÉRLÉS 32 PID VEZÉRLÉS 34 ÖSSZEFOGLALÓ 36 IX. AZ ÉRZÉKELŐK TOVÁBBI LEHETŐSÉGEI 37 ÉRZÉKELŐ MÓDOK ÉS TÍPUSOK 37 FORGÁS ÉRZÉKELŐ 38 TÖBB ÉRZÉKELŐ EGY BEMENETEN ÖSSZEFOGLALÓ X. PÁRHUZAMOS ELJÁRÁSOK 39 40 41 A ROSSZ PROGRAM 41 A KRITIKUS RÉSZEK ÉS A MUTEX VÁLTOZÓ 42 SZEMAFOROK HASZNÁLATA 43 ÖSSZEFOGLALÓ 44 XI. ROBOTOK KÖZÖTTI KOMUNIKÁCIÓ XII. 29 45 A MASTER-SLAVE ÜZENETKÜLDÉS 45 SZÁMOK ÉRTELMEZETT KÜLDÉSE 47 DIREKT VEZÉRLÉS 48 ÖSSZEFOGLALÓ 49 TÖBB UTASÍTÁS 50 IDŐZÍTŐK – TIMERS

50 PONT MÁTRIXOS KIJELZŐ 51 FÁJL RENDSZEREK 52 ÖSSZEFOGLALÓ 56 57 JOGOK ÉS FELHASZNÁLÁSI FELTÉTELEK 58 Oldal 3 XIII. ÁTTEKINTÉS Prof.ingKőrösi Gábor Az NXC nyelv 2010 Bevezető Ez a könyv elsősorban azok számára íródott akik most kezdenek ismerkedni a Lego Mindstrom programozási lehetőségeivel. Amennyiben foglalkozni szeretnénk valamely új vagy régebbi típusú lego robot programozásával, legyen az a Mindstorms RIS, CyberMaster, vagy Spybotic illetve a legújabb Mindstroms NXT, ehhez elsősorban valamilyen programozói felületre lesz szükségünk. Elsőként értelem szerűen mindenki az ingyenesen kapható és jól dokumentált NXG nyelvhez folyamodik, melyben grafikus környezetben tudunk dolgozni. A jól kezelhető felületnek köszönhetően, könnyedén oldhatunk meg programozási problémákat, legyünk akár óvodások vagy egyetemet végzett szakemberek. Ezt a nyelvet a LabViev a Legoval közreműködve hozta létre mely, animált

eszközökkel teszi lehetővé az egyszerű programozást még olyan emberek számára is akik az eddigi életükben soha, egy sort sem programoztak. Az NXG programkörnyezet nagyon egyszerű, viszont ennek következtében nem kellőképp rugalmas, és bizonyos esetekben csak felesleges program modulokkal tudjuk rákényszeríteni a gépünket a kívánt feladatra. Ezen problémák kikerülése miatt hozta létre John Hansen az NXC program nyelvet mely Lego és más robot rendszerek programozásban nyújt segítséget. Az NXC egy C nyelven alapuló program környezetet. Itt most sokan felkaphatják a fejüket, hogy „hogyan fogjak hozzá, hiszen és még soha sem programoztam”, azonban biztosíthatom az olvasót, hogy még az alapok hiánya mellett is megtanulhatja ezt a nyelvet, ha lépésről lépésre végigköveti a könyv egyes fejezeteit. Hogy a program írása még egyszerűbb legyen, használhatjuk a Bricx Command Center (BricxCC)-t. Ez az eszköz segít abban, hogy a

megírt programokat egyszerűen fel illetve letöltjük a gépünkbe, futathatjuk azokat, adatokat keressünk a NXT flash memóriájában, stb. Ez a leírás a BricxCC 3.3716 (vagy újabb) integrált fejlesztő környezetére épít A program letölthető : Oldal 4 http://bricxcc.sourceforgenet/ Prof.ingKőrösi Gábor Az NXC nyelv 2010 I. AZ ELSŐ PROGRAMUNK MEGÍRÁSA Ebben a fejezetben megtanuljuk, hogy hogyan kell egy egyszerű programot írni. A programban melyet megírunk a következőket fogjuk csinálni: a robot előrehalad 4 másodpercet, majd visszafelé megy 4 másodpercet, ezek után megáll. Ez nem tűnhet túl bonyolult feladatnak, viszont ezen a példán keresztül rálátásunk nyílik a programozás alap logikájára, valamint azt is megtekinthetjük, hogy valójában milyen egyszerű egy program elkészítése. Mielőtt azonban bármihez is hozzá foghatnánk, szükségünk lesz egy tesztelhető robotra. A ROBOT ÉPÍTÉSE Prof.ingKőrösi Gábor Az NXC

nyelv 2010 Oldal A megépítés után le kell ellenőrizni, hogy fel, lett-e telepíve a NXT fantom drivert, mely megtalálható az alap csomagban található. 5 A robot melyet építünk az egész leíráson keresztül használni fogjuk így célszerű, ha egy egyszerűbb robotot építünk. Így idő takarékossági okokból a következőkben az alap csomagban kapható TRIBOT-ot fogjuk megépíteni és használni. ISMERKEDÉS A BRICX COMMAND CENTERREL A elkövetkezőkben a programjainkat a BricxCC segítségével fogjuk elkészíteni. A program indításához kétszer rá kell kattintanunk a BricxCC ikonjára. (Ez csak abban az esetben lehetséges ha már előzőleg letöltöttük és feltelepítettük a gépünkre ezt az alkalmazást. Amennyiben ez még nem történt meg úgy pótoljuk ezt a hiányosságot). Miután elindítottuk az alkalmazást,”megkérdezi tőlünk”, hogy hol található a robotunk. Ekkor kacsoljuk be a robotunkat, majd kattintsunk az OK-ra, és ennek

hatására a program automatikusan (legtöbbször) megtalálja az eszközt. Ezek után ismerkedjünk a felhasználói felülettel. (lásd lent a képen) Mint látható az alkalmazásunk úgy néz ki mint egy egyszerű szöveg szerkesztő, és a menüje is a szokványos elemekkel rendelkezik,mit például: gombok a mentéshez, megnyitáshoz, nyomtatáshoz, stb. Továbbá, találhatóak további speciális menük is melyekkel, a megírt programunkat tudjuk fordítani,a gépbe tölteni vagy információkat kérhetünk le a robotból. Oldal 6 Ahhoz hogy megírhassuk az első programunkat legelőször szükségünk lesz egy új file nyitására, melyet a NEW FILE gomb megnyomásával tehetünk meg. Prof.ingKőrösi Gábor Az NXC nyelv 2010 A PROGRAM ÍRASA Gépeljük be a következő programsorokat Első ránézésre komplikáltnak tűnhet a dolog, ezért elemezzük át a fent látottakat. Amint észrevetettük az említett pár sor NXC nyelvi elemeket tartalmaz. A programunk

csak egy eljárásból épül fel , melynek neve main. Minden egyes programoknál szükséges hogy az eljárásokat main-nek nevezzük el melyet a robot egyetlenként értelmezve végrehajt. (Erről bővebben is beszélünk majd a hatodik fejezetben) Az eljárásunk továbbá tartalmaz több parancsot, melyet utasításnak is szoktunk nevezni. Láthatjuk, hogy a programunk kezdetét és végét egy zárójel( { } ) fogja, közre mely egyértelműen behatárolja a programunk törzsét. Minden utasítást kötelezően pontos vesszővel (;) kell zárnunk. Most hogy letisztáztuk az alapokat, érthető ,hogy hol kezdődik a program, hol kezdődnek egyes parancsok és hogy mire szolgálnak ez elválasztó karakterek, értelmezhetjük a programot. Az eljárásunk törzse a következő képen épül fel: Ennek alapján az előzőleg begépelt programunkban hat darab utasítást találhatunk. Tekintsük meg ezeket egyenként. OnFwd(OUT A, 75); 7 Ez az utasítás jelzi a robotnak, hogy

indulnia kell, az A kimenetre (output A) csatlakoztatott eszköznek. Ez egy motor mely a parancs hatására elindul előre (forward) A további számok a sebesség beállítására szolgálnak mely ez esetben a maximális sebesség 75%-át jelenti. Prof.ingKőrösi Gábor Oldal OnFwd(OUT C, 75); Az NXC nyelv 2010 Ez az utasítás megegyezik az előzővel, azzal az eltéréssel, hogy most a C motor indul meg. Ez az utasítás után már mindkét motorunk forog (előre -forward). Wait(4000); Most a várakoztatáshoz érkeztünk. Ez az utasítás 4 másodperces várakoztatást jelent Ezt az adatot a következő számok arányából kapjuk, egy másodperc késleltetés 1/1000. Tehát nagyon precízen be tudjuk hangolni a programunkat a várakoztatáskor. A 4 másodperc alatt a programunk alvó állapotba kerül(ez idő alatt nem érzékel semmit a külső világból), és a robot folyamatosan halad előre. OnRev(OUT AC, 75); Most már eleget haladt előre a robotunk, szóval

jelezzük neki, hogy fordítsa meg a motorok forgás irányát hátrafelé. Mint láthatjuk nem kötelező, hogy ezt a parancsot egyenként adjuk ki , mivel módunk van rá, hogy akár két kimeneten megjelenő parancsot is kiosszunk az OUT AC utasítással. Wait(4000); Ismételten 4 másodperc várakozás következik. Off(OUT AC); És leállítjuk mind két motort. A programunk működése tehát: A motorok forognak 4mp előre és 4mp hátra majd megállnak. Bizonyára feltűnt, hogy a programozó környezetben a szövegek automatikusan elszíneződnek gépelés közben, így segítve a program íróját a munkában. (Ezeket a színeket tetszőlegesen módosíthatjuk a beállítások menüben.) A PROGRAM FUTTATÁSA Elsőként meg kellet írni a programot, majd le kell fordítani (ez a folyamat átalakítja a forrás kódot, hogy gép számára is érthető legyen) és átküldeni a robotba az USB kábel vagy a BLUETOOTH segítségével. Itt látható gombok segítségével tudjuk

fordítani, átküldeni, futtatni, és megállítani a programot. A második gomb megnyomásával, le tudjuk ellenőrizni, hogy találhatóak e hibák a programban, és hogy sikerült e lefordítani és átküldeni az adatainkat. Ha ezzel megvagyunk, futathatjuk a programunkat.(hogy ezt megtehessük, menjünk a MyFiles OnBrick menübe –>Software files ->run simple 1 program) Emlékezzünk rá ,hogy a programunk az NXT modulban ugyan azt a nevet viseli, mint amit az NXC-ben adtunk neki. A programot két féle képen tudjuk futtatni Automatikusan a CLRT+F5 gombkombináció vagy indíthatjuk a letöltés után zöld gomb megnyomásával is. A CTRl+F5(vagy a zöld gomb) hatására indulnia kell a robotnak.Amennyiben ez nem sikerült, ellenőrizzük át a vezetékeket. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal Amikor programot készítünk nagy eséllyel hibákat is vétünk. Ezeket a hibákat a fordító képes megtalálni és jelezni számunkra, az oldalunk alján,

ahogy az alábbi képen látható 8 HIBÁK A PROGRAMUNKBAN A hiba kereső automatikusan kiválasztja az első hibát.(pl rosszul lett begépelve az OFF parancs) Amennyiben több hiba is található a, az üzenetre kattintva kijelölődik a hibás programrész. Gyakori, hogy a program elején vétünk valami nagy hibát, így hogy időt spóroljunk ajánlatos, először kijavítani ezt majd ismételten lefordítani. A hibák kiküszöbölésben további segítség lehet a színes betűk figyelembe vétele, gyakran ennek áttekintésével szinte azonnal kiszúrhatjuk a félregépelés helyét. Viszont akadnak olyan hibák is, amelyeket a program nem tud érzékelni, mint például amikor csak az A és a C kivezetésekre (portokra) kötünk motorokat és az OUT B parancsot használjuk. A SEBESSÉG VÁLTOZTATÁSA Oldal 9 Ahogy láthattuk az előző program futtatásakor a robotunk túl gyorsan mozgott. Hogyan orvosolhatjuk ezt a problémát? A sebesség változtatásához

elegendő, hogy átírjuk a második paramétert a zárójelben. Ezeket a számokat 0 és 100 közötti értékekre állíthatjuk A 0 álló helyzetet jelent a 100 pedig a 100% sebességet. A következőkben láthatjuk az előző programunkat módosítva, melyben a robotunk lassabban mozog. Prof.ingKőrösi Gábor Az NXC nyelv 2010 ÖSSZEFOGLALÓ Ebben a fejezetben megírtuk az első programunkat az NXC nyelv és a BricxCC használatával. Most már tudjuk, hogyan kell programot írni, lefordítani azt és beletölteni a robotunkba. A BricxCC rengeteg tulajdonsággal bír viszont ebben a könyvben csak az alap funkcióival ismerkedünk meg. Amennyiben mélyebben szeretnénk megismerkedni ezzel a programozó környezettel, úgy ajánlatos letölteni a programhoz kapható további leírásokat. Oldal 10 Megtanultuk továbbá az NXC nyelv legfontosabb elemeit. Megismerhettük a main eljárás felépítését,és az alap motorvezérlő parancsokkal mint a :OnFwr(),OnRev(), és az

OFF() valamint a Wait() várakoztató utasítást. Prof.ingKőrösi Gábor Az NXC nyelv 2010 II. ÉRDEKESEBB PROGRAM KÉSZÍTÉSE Az első programunk nem volt valami érdekfeszítő, ezért második lépésként létrehozunk valami bonyolultabb mozgást. Ezt a lépések számának növelésével, és az NXC nyelv lehetőségeinek használatával érjük el. FORDULÓ MOZGÁS KÉSZÍTÉSE A robotunkat forduló mozgásra késztethetjük az egyik motorunk lefékezésével vagy a fordulási irány változtatásával. Tehát nincs más feladatunk, mint, hogy begépeljük, betöltjük és futtatjuk a programot. A következő példa hatására 900 fordulást hozhatunk létre, úgy hogy először mind két, majd csak az egyik motort forgatjuk meg. Kipróbálhatunk több különböző számot, mint például 500-at a késleltetésben (Wait()) mellyel pl. 90o fordulás hajthatunk végre. (Ez persze függet a felülettől is melyen a robotunk halad) Az értékek egyszerűbb

változtatásához előnyösebb, ha neveket használva azok értékei módosítjuk. Ezt az NXC – ben konstansok használatával valósíthatjuk meg, melyet a következő programban láthatunk. Oldal 11 Az első két sor a konstansok definiálása, melyeket ezek után tetszőlegesen tudunk használni a programunkban. Konstansok definiálása előnyös mert: ez átláthatóbbá teszi a programunkat, könnyebben tudjuk kicserélni az értékeket. Prof.ingKőrösi Gábor Az NXC nyelv 2010 UTASÍTÁSOK ISMÉTLÉSE Most próbáljunk meg olyan programot írni melyben a robot négyszög alakban mozog. Ahhoz hogy ez létre jöjjön, a következő lépéseket kell elvégeznünk: előrehaladás, fordulás 90o-ban, előrehaladás még egyszer, fordulás 90o-ban, stb. Ezt a programrészt többször,(4x) egymás után írva, készíthetünk olyan programot, amely egy feladatot ismétel. Ettől azonban van egy egyszerűbb lehetőség, az utasítások ismételtetésére szánt repeat

utasítással. A szám, amely a repeat parancs mellett található jelenti, hogy hányszor kell ismételni a feladatokat. A repeat ciklus csak azokat a parancsokat képes megismételni melyek az utasításhoz tartozó {} jelek közé vannak írva. Oldal 12 Egy következő példaként, készítsünk egy programot, amely elvégzi az előző feladatot 10 szer. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Ebben a programban a repeaten belül találhatunk még egy repeatet. Ezt egymásba épült ciklusoknak hívjuk. Lényegében a működési elve ugyan az mint az előzőé, először belép a program a belső ciklusba majd miután 4 szer végighajtotta a feladatok kilép, és újból indul amíg a külső ciklus 10 szer végig nem ér, Tehát valójában 10x4 alkalommal hajtódik végre. Ahogyan az előző esetnél itt is fontos figyelnünk a {} jelekre, különben könnyen végtelen ciklust hozhatunk létre. repeat { repeat { Utasítások. } } KOMMENTÁROK HOZZÁADÁSA Oldal 13

Ahhoz, hogy a programunk minél áttekinthetőbb legyen, szükséges hogy megfelelő kommentárokkal látjuk el. Ezeket a kommentárokat a // jelek közé kell tennünk A két // jel közötti részt a fordító figyelmen kívül hagyja, így ha véletlenül oda írunk program részeket, azokat nem hajtja végre. Amennyiben hosszabb kommenteket kívánunk hozzáadni, azt a /* / jelek közé tehetjük. A kommenteknek terméseztessen, más színük van a programtörzsön belül, így könnyen észrevehetjük azokat. Prof.ingKőrösi Gábor Az NXC nyelv 2010 ÖSSZEFOGLALÓ Ebben a fejezetben megismerkedhettünk az ismétlések használatára alkalmas REPEAT ciklussal, és azok egyszerű illetve egymásba épített használatával, melynek segítségével, rövid programmal is létrehozhatunk a robot számára hosszan tartó tevékenységet. Oldal 14 Figyelem:Mielőtt tovább lépnénk ajánlatos pár gyakorló feladatok készíteni az eddig megismertek alapján.

Prof.ingKőrösi Gábor Az NXC nyelv 2010 III. VÁLTOZÓK HASZNÁLATA A változók használata rendkívül fontos része a minden programozási nyelvnek. A változók valójában nem mások, mint memória címek melyeken az adott adatokat tároljuk. Ezek az értékek bár különböző helyeken találhatóak, tetszőleges változtathatóak. Lássunk tehát néhány konkrét példát a változók használatára. MOZGÁS SPIRÁL ALAKZATBAN Oldal E programban a számunkra legfontosabb sorokat kommenteztük. Az első ilyen a define a var melyben a változót definiáljuk az INT kulcsszó a változó típusát (int – egészszám,float – törtszám, char – karakter,stb.), a move time pedig a változó nevét jelenti, ez lehet bármi 1-32 karakterig (pl a) a lényeg , ha kis(vagy nagy) betűvel írtuk akkor a továbbiakban csak úgy hivatkozhatunk rá a programban. Ugyanez fordítva is igaz A név tartalmazhat számokat is, de csak betűvel kezdődhet A következő

kommentált sorban (set the.) kezdő értéket adunk az amúgy üres (0) változónknak A harmadik sorban (use the value.) használjuk a változó értékét, tehát ugyan az történik mintha a várakozás értéke 200 lenne (wait(200)) mivel az előbbiekben beállítottuk a move time változó alap értékét 200 ra. A negyedik sorban a move time változó értékét növeljük meg a 200-al Mivel ahogy a program elején észre lehetett venni a programunk ismétlő ciklusban(repeat) van ezért, ez a parancs mindig hozzáad 200 a változó értékéhez. Tehát először 200, másodszor 400, harmadszor már 600 a move time értéke, stb. amíg 50 szer meg nem ismétlődik 15 Elsősorban a már előzőkben megírt programunkban kell gondolkodnunk. Hogyan kellene az idő intervallumokat és a motorok forgás irányát átszerkeszteni, hogy spirális mozgási útvonalat kapjunk? Ehhez módosítanunk kell a MOVE TIME mozgási időt, de hogyan lehetséges ez? Eddig a MOVE TIME egy

konstansként szerepelt, tehát annak értékét nem változtathattuk, ezért most át kell alakítanunk, hogy a programban ezen túl változó ként szerepelhessen. Változókat, ahogyan a C nyelvbe az NXCben is egyszerűen definiálhatunk Íme, a példa: Prof.ingKőrösi Gábor Az NXC nyelv 2010 A változónk értékét nem csak a + paranccsal módosíthatjuk, hanem szorzással (*=), kivonással (-=) és osztással (/=). (Ha maradékos osztás történne, akkor a program felkerekíti az értéket) Nem csak ilyen módon változtathatjuk a változóinkat, hiszen tetszőlegesen végezhetünk bármilyen matematika műveletet akár két vagy több változó között illetve készíthetünk akár összetett egyenleteket is. A következő példában nem fogunk tapasztalni semmilyen változást a roboton, kizárólag a NXT tulajdonságait, programozási lehetőségeit szemléltetjük. Az első két sorban láthatjuk, hogyan tudunk egy sorban egy vagy több változót is deklarálni,

illetve mind három változót deklarálhattuk volna egy sorban is. A változó mely neve (values)mellett a [] szerepel, tömbök deklarálására szolgálnak, melynek segítségével egy változóban több értéket tárolhatunk (ennek megértéséhez ajánlatos a programozási alapok vagy legalább a matematikai mátrixok ismerte). A tömb egyes elemeit zárójelekbe írt számokkal tudjuk elérni Az NXC-ben integer (egész szám) tömböt tehát a következőként hozhatunk létre: int név[]; A 12. sorban találhatunk egy parancsot melynek hatására a 10 elemű tömböt, 0-val tölti fel ArrayInit (values,0,10); Oldal Az eddigi programokban előre meghatároztuk, hogy a robotunk konkrétan mit tegyen. Viszont a robot mozgását érdekesebbé tehetjük azzal, ha úgy írjuk meg a programot, hogy ne tudjuk előre mi is fog lenni a következő lépése. Az NXC-ben módunk van véletlenszerű számokat generálni, melyet kiválóan használhatunk erre a célra. A következő

programban a robotunk egy véletlenszerű úton fog haladni, úgy hogy az előrehaladás valamint az elfordulás ideje random módon lesz meghatározva. 16 VÉLETLEN SZÁMOK Prof.ingKőrösi Gábor Az NXC nyelv 2010 A programban definiáltunk két változót melyek értékét véletlenszerűen határozzuk meg. A random(600) azt jelneti, hogy a számok melyeket ez a parancs készít 0 és 600 közötti értéket vehetnek fel, és ezek minden egyes hívás után különbözőek. Az egyszerűsítés végett ezt a parancsot így is használhattuk volna wait(Random(600)). Itt is észrevehettük, hogy a programunk magja ciklusba van helyezve (while-ciklus). Ami azt jelenti, hogy a programunk mind addig fut amíg az állításunk igaz(true). Erre most jó páran kérdezhetik milyen állítás ? Mivel valójában semmilyen kivizsgálást nem végzünk ezért a true értékünk soha sem fog false-ra (hamisra) változni. Ezt a ciklust akkor használjuk, ha végtelen programot akarunk

készíteni, és a programból csak a NXT agyon található gomb megnyomásának(sárga) segítségével tudunk kilépni. A while ciklus működés hasonló a repeatéhozz azzal , hogy az utóbbi egy bizonyos szám eléréséig ismétli a zárójelek közé fogott parancssorokat. Itt viszont mindaddig ismétlődik a ciklus, amíg a while parancs melletti zárójelben található feltételvizsgálat igaz. (feltétel vizsgálat a következő fejezetben) ÖSSZEFOGLALÓ Oldal 17 Ebben a fejezetben tanulhattunk a változók használatáról és a tömbökről, melyeket tetszőlegesen felvehetünk a következő értékek szerint: int –egész szám,(mely lehet short –rövid illetve long – hosszú), byte – 0 vagy 1, bool – igaz(true) vagy hamis (false) és string – karakterlánc,szöveg. Továbbá megismerhettük a véletlenszerű számok készítésének módját, mellyel érdekesebbé tehetjük a robotunk mozgását, illetve megtudtuk, hogyan készíthetünk végtelenített

ciklusokat. Prof.ingKőrösi Gábor Az NXC nyelv 2010 IV. VEZÉRLŐ UTASÍTÁSOK Az előző fejezetekben láthattuk hogyan lehet alkalmazni a repeat és a while ciklusokat. Viszont van úgy hogy ezekkel az utasításokkal nem lehet minden problémát megoldani ezért meg kell ismerkednünk a vezérlő utasításokkal. Ebben a fejezetben tehát a vezérlő utasításokkal ismerkedhetünk meg. AZ IF – FELTÉTELES UTASÍTÁS Oldal Az if feltételes utasítás első ránézésre hasonlít a while-ra. Amennyiben a if melletti zárójelben található feltétel igaz, akkor a zárójelek közötti parancsok utasítások végrehajtódnak , ellenkező estben a program tovább lép. Pontosabban csak lépne, ugyanis módunk van rá hogy az if(ha,amennyiben) utasítás után else (különben) parancsot tegyünk, ilyenkor amennyiben az else előtt található if(ek) nem teljesül(nek) akkor az else hajtódik végre. De vegyük át a konkrét példát, hogy még világososabbá váljon

a dolog. A random() parancs értéka 0-val megegyező vagy eltérő lehet, így a random()>=0 kérdés vagy igaz, vagy hamis lehet, és ettől függően vagy belép az if-be vagy ugrik az else-re. A vizsgálódáshoz további összehasonlító parancsot használhatunk. Prof.ingKőrösi Gábor Az NXC nyelv 18 Néha megesik, hogy program egyes elemeit csak valamilyen feltételtől függően kellene végrehajtani. Az ilyen problémák megoldására használjuk a feltételes (if) utasítást. Az egyszerűbb érthetőség miatt egyből egy példa segítségével szemléltetjük a működését. Ismét az előzőekben használt programot vesszük alapul, azonban teszünk bele egy csavart. A robot halad egyenes vonalban, majd elfordul jobbra vagy balra. Hogy ezt megtehessük, szükségünk van ismét a véletlen számokat generáló parancsra. Felveszünk egy random számot, amely lehet pozitív vagy negatív, amennyiben a szám kisebb, mint nulla a robot jobbra fordul, ellenkező

esetben pedig balra fordul. Íme, a program: 2010 == egyenlőség <kisebb <= kisebb vagy egyenlő >nagyobb >= nagyobb vagy egyenlő != nem egyenlő valamint készíthetünk olyan feltételt is ahol több kivizsgálást végzünk, ilyenkor használhatjuk az && (jelentése és), || (jelentése vagy) uatasításokat. Íme egy példa: mindig igaz mindig hamis igaz ha ttt nem egyenlő 3-al igaz ha ttt 5 nél nagyobb és 10-nél kisebb igaz ha aaa vagy bbb (vagy mindkettő)egyenlő 10-el A DO UTASÍTÁS A soron következő utasításunk a DO. Melynek a következő az alapszerkezete: Oldal 19 Az utasításainkat a Do parancs után következő két zárójel közé kell beírnunk , melyek abban az esetben hajtódnak végre ha a feltételünk teljesül. A while után következő zárójelbe kell beillesztenünk a feltételünket melyeket ugyan úgy kell felállítanunk mint ahogy az IF feltételei esetén tettük. A következő példában a robot 20

másodpercig mozog véletlenszerűen, majd megáll Prof.ingKőrösi Gábor Az NXC nyelv 2010 A programunk tehát úgy működik, hogy a véletlenszerűen felvett idő intervallumokat összeadja, és ha ezek összértéke eléri a 20000-et (20mp)a program kilép a ciklusból és a robot leáll. A while és a do-while ciklus között első ránézésre nem sok különbség látható, azzal, hogy még a while ciklus először tesztel, és csak ha a teszt true akkor hajtja végre, ezzel szemben a do-while ciklus egyszer mindenképp végrehajtódik, hiszen a tesztelés csak ezután történik meg. ÖSSZEFOGLALÓ E fejezetben megismerkedhettünk két új vezérlő utasítással,az if-el és a do-while-al. Az eddig megismert utasításokkal együtt használva komoly összetett, mégis ugyanakkor rövid és áttekinthető programok írására nyílik módunk. Oldal 20 Figyelem: Ezeknek a parancsoknak a megértése létfontosságú a könyv folytatásához,így ajánlatos itt egy kis

pihenőt tartani és minél több példaprogramot létrehozni. Amennyiben az utasítások megértése gondot okoz, úgy érdemes az interneten algoritmikus-grafikus leírást keresni, ahol ábrákban magyarázzák el ezek működését. Prof.ingKőrösi Gábor Az NXC nyelv 2010 V. ÉRZÉKELŐK Természetesen az NXT-re nem csak motorokat, hanem érzékelőket is tudunk kapcsolni, melyekkel az eszköz további alkalmazási területeit bővíthetjük. Mielőtt tovább léphetnénk, a könyv megkezdésekor említett gyári tribot-ra szereljük fel(amennyiben ezt eddig nem tettük meg), a gyári csomagolásban kapható három szenzort. VÁRAKOZÁS AZ ÉRZÉKELŐRE Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal Itt két fontos sorra kell odafigyelnünk. Az első sorban a robotnak „elmondjuk”(SetSenzor), hogy mely szenzort használja. IN 1 azt jelzi a rendszernek, hogy mely bemenetre kapcsoltuk az érzékelőnket A további bemenetek IN 2,IN 3 és az IN 4. SENSOR TOUCH azt

jelenti, hogy érintő szenzort használunk. Ha például fényérzékelőt használnánk, akkor a LIGHT SENSORT kellene beírnunk Az érzékelő beállítása után a robotunk elindul amíg (until) az neki nem megy valaminek, ekkor az értéke 1 lesz (eddig 0 volt) és a motorok leállnak. 21 Kezdjük az egyik legegyszerűbb programmal, ahol a robot addig marad mozgásban, amíg valamit meg nem érint. LEHETŐSÉGEK AZ ÉRINTŐ ÉRZÉKELŐVEL Az érintő szenzor alaptulajdonságainak megismerése után, készítsünk, egy bonyolultabb programot. A következő példában a robot halad előre, amíg meg nem érint egy tárgyak. Ezek után kisé hátrál, majd elfordul és továbbhalad. Az előző példától eltérően a szenzort egy egyszerűbb paranccsal állítjuk be, majd a robot elindul ,ekkor belépünk a WHILE ciklusba melyben az IF teszteli a szenzort, ha annak értéke 1 akkor a motor hátramegy (300ms) és jobbra fordul (300ms), majd továbbhalad. FÉNYÉRZÉKELŐ

Oldal 22 Az érintés érzékelő mellé feltehetünk más szenzorokat is az eszközünkre, mint például fényérzékelőt,hangérzékelőt, vagy ultrahangos érzékelőt. A fényérzékelő képes segéd fény kibocsájtására, illetve annak, szintjének továbbá a környezet fényének mérésére. A segédfény visszaverődésének mérését akkor tudjuk hasznát venni, ha például egy földre rajzolt vonalat kell követnünk. Ezt fogjuk tenni a következő példánkban Ehhez a teljesen befejezett tribotra van szükségünk. (A képen látható formában) Prof.ingKőrösi Gábor Az NXC nyelv 2010 Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal A program először konfigurálja a harmadik bemenetet, mint LIGHT SENSOR (fényérzékelő). Következőben beállítja a robot előre mozgását, és belép a ciklusba a program. Amint a fény értéke több mint 40 (használhatunk, konstansokat erre az értékre mellyel egyszerűen tudjuk cserélgetni ezt az értéket,

ugyanis ez az érték nagyban függ a tér fényviszonyaitól) akkor az egyik motor forgásirány változtatásával ismét ráfordul a helyes útvonalra. Amint kipróbáltuk a kész programot,látható válik 23 Továbbá szükségünk lesz, egy pályára ahol egy fekete vonalat tudunk követni, melyet szintén a légó szettben találhatunk meg. Az alapelv szerint a robotnak képesnek kell lennie követni a fekete vonalat, úgy hogy a fekete vonal határait figyeli. Amennyiben a vonal felső részét észleli (fehér felület nagy fényvisszaverő érték) úgy befelé fordul, ha viszont a vonal belső határát (fekete felület kis fényvisszaverő érték) érzékeli, úgy kifelé fordul. A kör középpontjától számítva Íme, az egyszerű program, amely elvégzi a feladatot. hogy a robot mozgása nem túl egyenletes. Próbáljuk meg hozzáadni a Wait(100) parancsot az until elé, így a robot jobban fog haladni. Itt azonban meg kell említenem, hogy a robot csak az

óramutató járásával ellentétes irányban tud mozogni. Ahhoz hogy a program bármerre elindulhasson, ettől bonyolultabb programot kellene írni. Ha a környezet fényerejét szeretnénk megvizsgálni, ahhoz először ki kell kapcsolnunk a segédfényt, a következő parancsokkal. HANG ÉRZÉKELŐ A hangérzékelő használatával könnyedén alakíthatjuk át akár a tapsolásunkat, vezérlő utasítássá. Az elkövetkezőkben egy programot fogunk készíteni, mely egy hangos zajra várva indítja el a robotot mindaddig, amíg ismételt hangot nem hall. (ha még eddig nem tettük meg, csatlakoztassuk a hang szenzort a 2-es portra). Definiáltuk a THRESHOLD konstanst és egy alias-t (álnevet) a SENSOR 2-nek, a main(fő) programrészt úgy konfiguráltuk ,hogy olvasson be adatot a PORT 2-ről a hangszenzor segítségével és lépjen be a végtelenített ciklusba. Az until parancsnál a program várja a hangerősség változását melynek értékét a THRESHOLD –al

hasonlítja össze.(azért hogy ne keljen mindig kiírni a SENSOR 2 nevet , mic nevű alias-ra hivatkozunk) Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal A wait várakozást be kellet iktatni, mert különben a program azonnal elindulna és leállna. (ez azért van, mert az NXT nagyon gyorsan dolgozik és nem vizsgál két until között). Ha megpróbáljuk kivenni 24 Ha valami hangot hall a robot (mely nagyobb THRESHOLD-tól) megindul előre, amíg egy ismételt hang meg nem állítja. az egyik vagy másik Wait-et, azonnal érthetővé válik a dolog. Alternatív megoldásként megpróbálhatunk olyan programot írni, melyben a wait-ket kicseréljük while-ra. Figyelem:Ne feledjük el hogy, az előző két eszköz értékei csak 0 és 100 közötti számokat vehetnek fel. ULTRAHANGOS ÉRZÉKELŐ Az ultrahangos érzékelő gyakorlatilag úgy dolgozik, mint egy szonár. Kiküld, egy magas frekvenciájú jelet,és érzékeli a tárgyakról visszaverődött részeit, és a

két jel között eltelt időből kiszámítja a távolságot. Ez az előző szenzoroktól eltérően nem analóg, hanem digitális, ami annyit jelent, hogy az egység képes önmaga az adatok mérésére és feldolgozására. Így kész adatokat küld a rendszerünknek. Az ultrahangos érzékelő segítségével készíthetünk olyan programot, amelyben a robot képes megállni mielőtt neki ütközne valaminek, ellentétben azzal, ahogy az eddig az érintő szenzor esetében volt. A program beállítja a 4. portot a digitális US érzékelőnek (SetSensorLowspeed), majd belép a végtelen ciklusba, amely addig fut, amíg meg nem közelített valamit körülbelül 15 cm-re (While(SensorUs(IN 4)>NEAR)), ezek után hátrál egy kicsit és folytatja, előröl a ciklust. ÖSSZEFOGLALÓ Ebben a fejezetben láthattuk hogyan dolgoznak egyes szenzorok, hogy hogyan használhatjuk ezeket az eszközöket a until és a while utasítások kombinálásával. Oldal 25 Figyelem: Ismételten

ajánlatos most is egy kis kitérőt tartani és több lehetséges programot végigcsinálni, hogy jobban megérthessük és begyakorolhassuk a szenzorokról tanultakat. Prof.ingKőrösi Gábor Az NXC nyelv 2010 VI. FÜGGVÉNYEK ÉS ELJÁRÁSOK Az eddigi programjainkban mindössze egyetlen eljárást használtunk, ez volt a main vagy más néven a FŐ programrész. Viszont ahogy C nyelvben úgy az NXC-ben is módunk van többelemes összetett programokat készíteni, függvények és eljárások használatával. Ezek segítségével az ismétlődő programrészeket, továbbiakban nem kell számtalanszor megismételni, hanem elég csak a hozzájuk rendelt nevet meghívnunk. A függvények és eljárások segítségével egy bonyolultnak tűnő programot is egyszerűen el tudunk készíteni, mely így mindenki számára könnyen áttekinthető és gyorsan értelmezhető lesz. ELJÁRÁSOK Oldal 26 Az NXC programnyelv 255 saját egyedi eljárást tartalmaz. A legfontosabb a

main eljárás melyet mindig muszáj, megnyitnunk mivel ez képezi a programunk törzsét. A további eljárások a program betöltése után kerülnek használatba, melyeket csak a main törzsből lehet meghívni. Lássunk egy konkrét példát, hogy érthetőbb legyen az eljárások használata. Készítünk egy programot melyben a robot négyszög alakzatban halad, mint ahogy azt egy előző példánkban tette. Viszont ebben az esetben, ha ütés éri az érintés szenzort, akkor a robot erre reagál. Mind ezt nehéz lenne megoldani eljárások nélkül, mert a robotnak két dolgot kellene egy időben csinálnia (elfordulnia ás a szenzort vizsgálni). Tehát jobb megoldás, ha két eljárását használunk, egyet a mozgásra (négyszögben mozgás) és egyet a szenzor figyeléséhez. Íme, az így készült program Prof.ingKőrösi Gábor Az NXC nyelv 2010 A fő (main) programrészben nem foglalkozunk, mással csak beállítjuk a szenzor típusát és elindítjuk mindkét

eljárást (move square,check sensors), melyeknek átadja az irányítást, ezzel a main eljárás véget is ért . A move square eljárás a robotunkat négyszög alakzatban mozgatja, egy végtelen ciklusban, még a check senzor eljárásunk az érintő érzékelőt figyeli, és ha bármi hozzáér, a robotunkat elvezeti az akadálytól. Fontos megjegyezni, hogy amennyiben az eljárásokat egy időben indítjuk el, az nem várt eredményhez vezethet, mivel így mindkét eljárás egyszerre próbálná meg vezérelni a motorjainkat, hogy orvosoljuk ezt a problémát, deklarálunk egy változó típust, ez a MUTEX (mutal exclusion). Ezt a változót csak az ACQUIRE(elindít) és a RELEASE(megszakít) függvényekkel használhatjuk, melyeket a kritikus pontokra írva (a vezérlés kezdetére és végére illesztve)elérhetjük, hogy egy idő intervallumban,csak egy eljárás vezérelheti a motorokat. Ez a mutex típusú változót más néven szemafornak (útirányjelző lámpának) is

szokták hívni, és ezt a programozási módszert is szintén ezzel a névvel illetik. FÜGGVÉNYEK Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal Ebben a programban egy olyan függvényt deklaráltunk melyben a robotunk elfordul. Ezt a függvényt a program fő részében háromszor is meghívjuk. Megfigyelhetjük, hogy a függvényneve mellett szám is szerepel a zárójelekben, melyekkel a motor erőségének értékét adjuk át. Amennyiben nem kívánunk, értéket átadni úgy a függvényben konkrét értékeket írunk be és elhagyjuk a zárójeleket. A a függvény használatának legnagyobb előnye nem a gyorsaság, vagy az egyszerűség, hanem az így készült program memória foglalásában rejlik. Hiszen az így a készült programunk kisebb helyet foglal Ha azonban a függvényünk rövid, akkor célszerű inkább az INLINE függvényt használni az előző megoldásunk helyett. Ebben a megoldásban az adataink nem lesznek elkülönítve, tárolva, viszont 27

Néha megesik, hogy egy bizonyos program részre többször is szükségünk van a program során. Erre az esetre nyújt segítséget függvények használata, melyre annak nevének megadásával hivatkozhatunk. Lássunk egy példát a függvények használatával egyszerű több helyen használni. Az INLINE függvény több helyet foglal a memóriában, de így nincs limitálva a függvényeink száma. A deklarációja a következően néz ki: Az inline függvény deklarálása, használata és hívása ugyan úgy működik, mint az egyszerű függvény. A következő példában megláthatjuk az inline függvény használatát. Oldal 28 Módosíthatjuk úgy is az előző példát, a motor ereje és a késleltetés ideje csak a main programrészben legyen megadva. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Megjegyezném, hogy a zárójelekben található értékeket csak a main függvényben használjuk, ezért az érték átadás szabályai szerint, ahány változót

akarunk átadni (mindig ugyan annyit kell),annyi új változót kell felvenni a függvény neve után található zárójelben. A példánkban, mint integer változó deklaráltuk őket. Amennyiben több változóra lenne szükségünk, úgy vesszővel elválasztva tetszőleges számban tehetjük azt. Továbbá azt is fontos megjegyeznem, hogy függvényt mint void kell felvenni, ami annyit jelent, hogy a függvény nevének nincs visszatérési értéke. További lehetőségeket a függvényekről NCX guide leírásban találhatunk. MAKRÓK DEFINIÁLÁSA Oldal 29 Az NXC-ben definiálhatunk makrókat is,(nem összekeverni a BricxCC makrókkal) melyet a #define kulcsszóval kezdünk majd nevet adunk neki, ezek után felírjuk a programrészt. Ismételten felírjuk még egyszer az előző programot, de most makrók segítségével. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Miután felírtuk a #define kulcsszavat felírjuk a nevet, ezek után következik az utasítás , melynek

egy sorban el kellene férnie, amennyiben nem fér bele a sorba úgy / jelet ütünk, és a következő sorba írjuk a parancsunkat. A define parancsszóval nem csak egy, hanem több makrót is készíthetünk. A következő példában ezt szemléltetjük melyben négy makrót is használunk, egyet-egyet az előre és hátra mozgáshoz, valamint egyet-egyet a jobbra és balra forduláshoz. A fenti példában szemet szúrhatott, hogy ahogyan a függvényeknél és az eljárásoknál, itt is módunk van rá, hogy a konkrét vezérlő értékeket a main program részben adjuk meg. ÖSSZEFOGLALÓ Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal Most hogy átvettük az előző fejezeteket, és jól átdolgoztuk őket, megszerezhettük a kellő tudást hogy építsünk, és vezéreljünk egy saját gyártású robotot. A következő fejezetekben az eddigi alapismeretekre építkezve mélyedünk bele az egyes elemek mélyebb ismeretébe, melyekkel tovább bővítjük a

lehetőségeinket. 30 Ebben a fejezetben megismerkedhettünk az eljárásokkal, a függvényekkel, az inline függvénnyel és a makrókkal, melyek bár használata eltér egymástól, alkalmazásuknak célja azonban közös, hogy megkönnyítsék a program készítését, áttekinthetőbbé tegyék a forrás kódot, és hogy az amúgy véges befogadó képességű memóriából minél kevesebb helyet foglaljanak el. Az eljárások egyszerűen alkalmazhatóak, viszont némely helyzetben nem árt vigyázni, nehogy olyan parancsokat osszunk, ki melyeket nem lehet végrehajtani. A függvényeket olyan esetekben célszerű használni, amikor nagyobb kódrészeket többször is használnunk kell a programunk során, még az inline függvény esetében a kisebb kódok ismétlésének elkerülése a cél. Végül a makrókkal ismerkedhettünk meg, melyeket nagyon kis programrészek használatát könnyítik meg. VII. HANG SUGÁRZÁSA Az NXT modellünkben a sok okos alapeszköz mellet

találhatóak beépített hangszórók is melyekkel különböző zene és hang fájlok lejátszására vagyunk képesek. Ez a tulajdonság akkor bizonyul hasznosnak amikor, szeretnénk, hogy a program futása közben valami féle visszajelzést kapjunk a gép működéséről. HANG FÁJL LEJÁTSZÁSA A BricxCC ben található egy beépített hang konverter mely a WAV fájlokat átalakítja RSO-ra. (Tools >Sound conversion) Ezek után az átalakított fájlt el kell tárolnunk a NXT belső memóriájába (Tools -> NXT explorer) és lejátszatnunk a következő paranccsal: Oldal Ez a szép ki program egy olyan dalt játszik le amit bizonyára mindenki ismer, melyet a standard kattintás zenéjével készít el. (a szám: Shave and haircut) Itt is terméseztessen, makrókat használunk az egyszerűbb programozás végett. A kész programba próbáljuk meg módosítani a hang erejét és idejét. 31 Az argumentumok helyére be kell írni a fájl nevét (filename), a hangerejét

(0 és 4 között lehet), és az ismétlések számát(1 esetén ismétli a fájlt, 0 esetén csak egyszer játssza le). Prof.ingKőrösi Gábor Az NXC nyelv 2010 HANG JÁTSZÁSA A NXT-nk nem csak hang fájlok lejátszására képes, hanem hangokat is képes lejátszani, hogy ezt megtehessük a következő parancsot kell használnunk Melyben négy argumentumot fedezhetünk fel. Az első a hang frekvenciáját, a második a hosszát(ugyan úgy adhatjuk meg mint a wait esetében),a harmadik a hangerő és az utolsó az ismétlés. PlayTone (frekvencia, hossz) parancsot szintén használhatjuk, ebben az esetben a hangerő az NXT alapbeállításától fog függeni, és az ismétlés inaktív lesz. Íme a hangjegyek táblázata: Oldal 32 Ahogyan a PlayFileEx parancsnál, az NXT itt sem fogja megvárni hogy befejeződjön a hang, tehát tudunk több hangot egyszerre is megszólaltatni illetve a különválasztáshoz várakoztatásokat kell használnunk. Íme, egy példa:

Prof.ingKőrösi Gábor Az NXC nyelv 2010 Könnyedén tudunk így zene részleteket készíteni a Brick Piano segítségével. Ha zenét szeretnénk lejátszani a robot mozgása alatt, jobb, ha eljárásokként oldjuk meg ezt. Íme, egy program melyben a robot előre-hátra halad miközben zene szól. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal Ebben a fejezetben megtudhattuk hogyan lehet zene fájlokat lejátszani illetve hangokat kibocsájtani, valamint megtekinthettük hogyan különíthetjük el a hangokat és a vezérlést eljárások segítségével. 33 ÖSSZEFOGLALÓ VIII. A MOTOROK MÉLYEBB ISMERETE Eddigiekben a motoroknak csak az alap lehetőségeit ismerhettük meg holott , számtalan megoldás és parancs létezik, melynek segítségével még precízebbé tehetjük a működésüket. Ebben a fejezetben megismerkedünk a következő parancsokkal: ResetTachoCount, Coast (Float), OnFwdReg, OnRevReg, OnFwdSync, OnRevSync,RotateMotor, RotateMotorEx, PID.

LÁGY LEÁLLÍTÁS Eddigiekben a motorok leállításához az OFF parancsszavat használtuk mely azonnali hatállyal megállította azt, a fékek bekapcsolásával. Ettől a megoldástól azonban van egy lágyabb megoldás is, ahol a fékek használata nélkül áll le a motor. Erre a Float() vagy a Coast() utasításokat használhatjuk, melyek gyakorlatilag levágják az áramot. Íme, egy példa a használatára Az először a robotot fékekkel majd fékek nélkül állítjuk meg. A különbség nem biztos, hogy nagyban érzékelhető, viszont nagyobb robotoknál és probléma megoldásoknál már számottevő lehet. ÖSSZETETT VEZÉRLÉS Az OnFwd() és a OnRev() a két legegyszerűbb rutin a motorok mozgásra bírásában, azonban a NXT szervo motorjai ennél jóval nehezebb és összetettebb feladat elvégzésére is képesek az intelligens belső felépítésüknek köszönhetően. Precíz PID vezérlésével lehetőségünk van a pozíció és a sebesség rendkívül pontos

beállítására. Oldal OnFwrReg(kimenet,sebesség,regmode) parancs a motorunkat vezérli a kimenet, sebesség függvényében, még a vezérlés mórját(regmode) a következők lehetnek OUT REGMODE IDLE,OUT REGMODE SPEED,OUT REGMODE SYNC. Ha az IDLE lehetőséget választottuk, akkor nem lesz úgynevezett visszacsatolásos vezérlés,a SPEED módban a NXT mindig állandó sebességen próbálja tartani a motorokat, a SYNC módban pedig az előzőekben említett COUPLE tulajdonság szerint működik. OnRevReg() – ez a parancs teljesen úgy működik, mint az előző csak ellentétes irányban. Prof.ingKőrösi Gábor Az NXC nyelv 34 Amennyiben azt szeretnénk elérni, hogy a robotunk szinte tökéltessen, egyenes vonalban haladjon, módunk van a motorokat szinkronizálni (syncronization), a COUPLE utasítással pedig képesek teljesen együtt mozogni, ha az egyik kerék lelassul a másik is követi, ha az egyik leáll, a másik is leáll vele együtt. 2010 Ez a program

bemutatja a különbségeket a vezérlések között. A futás közben próbáljuk a kezűnkkel megfogni a kereket, hogy lássuk, mi történik. Elsőként az IDLE mód működik, ahol nem történik semmi extra dolog, a második a SPEED mód, melyben lelassíthatjuk a kerekeket, ekkor az NXT az erő növelésével próbálja meg korrigálni a sebességcsökkenést, és utoljára maradt a SYNC mód melyben, ha lefogjuk az egyik kereket, a másik is követni fogja. OnFwdSyny(kimenet,sebesség,forgpont) parancs megegyezik az OnFwdReg() paranccsal ,csak szinkron módban, viszont itt a forgpont paraméterben megadhatjuk a fordulat pontját is (-100 tól 100 ig) OnRevSync() – ugyan az mint az előző parancs csak fordított irányban. Oldal 35 A következő példában bemutatjuk ezeket a parancsokat. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Végezetül bebírjuk állítani a motor forgását fokokban (0-360o). A következő utasításban hozzáférünk a sebesség és fokok

változtatásához, amennyiben a sebesség és a fok azonos előjelű úgy a motor előreforog, ha viszont eltérő, akkor visszafelé forog. RotateMotor(kimenet,sebesség,fok) parancs forgatja a motort a kimenet, a fok és a sebesség erejének(1-100) a függvényében. RotateMotorEx(kimenet,sebesség,fok,forgpont,szinkron,stop) egy utasítás a precíz irányításra. Legyen például az A,C kimeneten két motor szinkronizálva, a fordulás pont alapján (-100 tól 100 ig), a szinkron boole értékekkel (igen-true, nem-false), majd használjon féket amennyiben tejesítette a kívánt fokot, a stop használatával(igen-true, nem-false). PID VEZÉRLÉS Az NXT következőbe épített lehetőség a PID(propotional integrative derivative - soros kompenzáción alapuló szabályozótípus) vezérlés, mellyel egyszerűen tudjuk irányítania motorunk sebességét és helyzetét. Ez a vezérlés típus az egyik legelterjedtebb és leg hatékonyabb visszacsatolásos irányítási

eljárás az automatizációban. A PID szó angol szavak rövidítéséből ered, pontos fordítása helyett annak lényegét fogalmaznánk meg. A PID szabályozó egy lineáris rendszerek szabályozásánál gyakran alkalmazott, soros kompenzáción alapuló szabályozótípus. A PID rövidítés a szabályozó elvére utal, a szabályozó által kiadott végrehajtójel a hibajellel (P: proportional), 36 a hibajel integráljával (I: integral), valamint Oldal a hibajel változási sebességével, deriváltjával (D: derivative) Prof.ingKőrösi Gábor Az NXC nyelv 2010 arányos tagokból adódik össze. Ezen tagok közül nem mindig valósítják meg mindet, ilyenkor beszélhetünk P, PI, PID szabályozókról. A programunk átadja a vezérlés pontot (R(t)) az eléréshez, elindítva a motor vezérlését (U(t)) , mialatt méri annak pozícióját (Y(t)) a beépített kódoló segítségével, és kiszámítja a hibát E(t)=R(t)Y(t). Ebből láthatjuk miért is nevezzük

visszacsatolásos vezérlésnek, mivel a kimeneti pozíció Y(t) függvényében kiszámítja a hibát és ennek alapján kompenzálja a vezérlő U(t) jelet. U(t) = P(t) + I(t) + D(t), ahol P(t) = KP·E(t), I(t) = KI·( I(t–1) + E(t) ) és D(t) = KD·(E(t) – E(t –1)) Ez most összeetetnek, tűnhet, ezért egy példa segítségével talán világosabbá válhat a dolog. Például ha nagyon le akarnánk egyszerűsíteni a dolgot, akkor, beszélhetünk a hajszárító vezérléséről. Képzeljünk el egy hajszárítót melynek 3 fokozata van. Hideg, meleg (15-250), és nagyon meleg (26550) Amint bekapcsoljuk a hajszárítót (pl nagyon melegre) az maximális fordulaton és maximális fűtésen kezd dolgozni, de mivel a fűtés még nem melegedett át, a kifújt levegő hőmérséklete nem elég magas, így lejjebb veszi a fordulatot (visszacsatolt jel). Ezek után viszont értelemszerűen emelkedni kezd a hőmérséklet, így a kimenő hőmérséklet függvényében növelni kell

a fordulatot egész a maximálisig, ha még így is nagy a hőmérséklet, akkor a fűtőtest áramellátását kell csökkenteni, teszi ezt mind a kívánt hőmérséklet és a kimenő levegő (visszacsatolt jel) hőmérsékletének függvényében. Bár ez a példa nem tükrözi teljes egészében a PID vezérlést , az alapelvet megérthettük belőle. A RotateMotorPID (kimenet,sebesség,szög,Ptag,Itag,Dtag) a motornak különböző mozgását eredményezi a PID függvényében. Próbáljuk ki a következő értékeket: Prof.ingKőrösi Gábor Az NXC nyelv Oldal (50,0,0): a motor nem fordul el pontosan 1800-ot , az ellensúlyozatlan hiba miatt 37 A vezérlés valójában három értékből adódik össze,a p,i,d. A P(t) gyors vezérlést tesz lehetővé,de nem elhanyagolható hibával, az I(t) tag „memóriát biztosít” a vezérlésnek,mely az út alatt felhalmozódott hibákat megtartva garantálja a zéró hiba határos egyensúlyt. A D(t) tagunk „jövőbe

látásra” képes (mint a matematikai deriválás), így gyors reagálásra képes. A PID vezérlés megértése kellő alapok nélkül majdnem lehetetlennek bizonyulhat, hiszen ez már egyetemi tananyag. A következő példa segítségével azonban elsajátíthatjuk a használatát. 2010 (0,x,x): proportional tag nélkül a hiba nagyon nagy (40,40,0): ez egy túlhajtott eset, mely azt jelenti, hogy a motor be lett csapva az előre állított beállítás pontjával és visszafordításával. (40,40,90): pontos beállítás,és időnövelés (idő a beállítási pont eléréséhez) (40,40,200): oszcillálást eredményez a túl nagy deriváló tag miatt Több lehetséges érték kombinációt is érdemes kipróbálni, és megnézni, hogy arra hogyan reagál a robotunk. ÖSSZEFOGLALÓ Oldal 38 Ebben a fejezetben megismerkedhettünk a motorok további tulajdonságaival, mint a FLOAT,COAST utasításokkal melyek lágyabb leállítást eredményezek, az OnXxxReg és az

OnXxxSync parancsokkal a visszacsatolt sebesség és szinkronvezérléshez, valamint a RotateMotor és RotateMotorEx lehetőségeket a motor egyenletes és precíz mozgásához. Megismerkedhettünk a PID vezérléssel is amelynek lehetőségeiről érdemes az interneten leírást keresni. Prof.ingKőrösi Gábor Az NXC nyelv 2010 IX. AZ ÉRZÉKELŐK TOVÁBBI LEHETŐSÉGEI Az ötödik fejezetben megismerkedhettünk az érzékelők alap lehetőségeivel, viszont ezeknél a beállításoknál sokkal többet tudnak. Ebben a fejezetben a szenzorok beállítási módjaikkal és típusaival fogunk foglalkozni. ÉRZÉKELŐ MÓDOK ÉS TÍPUSOK A SetSensor paranccsal már találkozhattunk, mellyel beállíthatjuk az érzékelő típusát, valamint annak módját, amely a szenzor működését szabályozzuk. A módot és a típust-szenzorokét különböző féle képen kell beállítanunk, annak fajtájától és felhasználási területétől függően. A típus beállítását a

SetSenzorType() paranccsal alkalmazhatjuk ki, a következő lehetőségek szerint: érintés szenzor esetén SENSOR TYPE TOUCH, fényérzékelő esetén (a fény be van kapcsolva) SENSOR TYPE LIGHT ACTIVE, hangérzékelő SENSOR TYPE SOUND DB, és az ultrahangos érzékelő SENSOR TYPE LOWSPEED 9V. A szenzorok típusának beállítása egy fontos lépés,melyben beállítjuk milyen elektromos ellátásra van szüksége az adott alkatrésznek(fényérzékelőnél led ki-be), illetve digitális eszköz esetén az I2C (soros) kommunikáció elindítására. Lehetőségünk van továbbá a régi RCX rendszerekből használni egy-két szenzort, mint a hőmérsékletmérő SENSOR TYPE TEMPERATURE, a régi típusú fény érzékelőt SENSOR TYPE LIGHT és s fordulat mérőt SENSOR TYPE ROTATION. Az érzékelők módjának beállításait a SetSensorMode() utasítással végezhetjük, melyek közül a legfontosabb a SENSOR MODE RAW,mely módban a visszakapott érték 0 és 1023 közötti

értéket vehet fel. Ezt a durva-nyers (RAW) értéket a szenzor készíti Ez konkrétan annyit jelent az érintés szenzor esetén, hogy amikor nem történik érintés ez az érték közel 1023,teljes benyomás esetén 50 körül mozog, részleges ütődés esetén 50 és 1000 a kapott szám, tehát RAW módban módunk van érzékelni nem csak az érintést, hanem annak fajtáját is. A fényérzékelő esetében az értéktől függően megállapíthatjuk a fény erejét is (300 nagyon világos,800 nagyon sötét). Mint látható az előző alapbeállításoktól eltérően ahol gyakorlatilag két érték közül választhattunk, itt már precíz értékeket tudunk használni. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal További két érdekes beállítási lehetőség a SENSOR MODE EDGE és a SENSOR MODE PULSE, mely az átmeneteket hivatott számolni, az alsó állapotból a felsőbe vagy vissza. Például amikor az érintésszenzor alap módban van, akkor csak azt

érzékeli, amikor megérintjük, ahhoz hogy ismét jelet generáljon, először el kell engednünk és ismét megérinteni, de mi van akkor, ha számunkra az elengedés pillanata is olyan fontos, mint a megérintésé. Itt ugyebár két jel is keletkezett a kikapcsoltból bekapcsoltba, majd vissza. Ennek érzékelését és feldolgozását segíti a SENSOR MODE EDGE amely a SENSOR MODE PULSE val ellentétben nem egy hanem két jelnek érzékel minden érintést. Terméseztessen akár egy (pulse) vagy akár kettő (edge) érintést kívánunk megszámolni, előtte nullába kell állítanunk a számlálónkat a ClearSensor()utasítással. 39 A következő mód a SENSOR MODE BOOL, melyben az értékünk két lehetséges elemet vehet fel ezek a 0 és az 1, a Raw módból átültetve ez azt jelenti, hogy 562 alatt az érték 0, felette pedig 1. Az érintés szenzor esetén ez az alapbeállítás, még a hőmérséklet érzékelőnél a SENSOR MODE CELSIUS és a SENSOR MODE FAHRENHEIT

lehetségesek. A fényérzékelő alap beállítása viszont nem értékben, hanem százalékban (0-100)adja vissza az kapott értékeket SENSOR MODE PERCENT , a SENSOR MODE ROTATION viszont kizárólag a forgás érzékelőnél használhatjuk. Most lássunk egy konkrét alkalmazást. A következő programban egy érintésérzékelőt használunk a robot irányítására. Csatlakoztassuk az érintés szenzort egy hosszabb vezetékkel az 1-es bemenetre Ha a szenzor két gyors jelet kap, akkor elindul, ha egyszer nyomjuk, meg akkor megáll. FORGÁS ÉRZÉKELŐ A forgás érzékelő egy rendkívül jól használható szenzor, ez egy optikai kapcsolókkal megoldott eszköz, amelyhez hasonló van beépítve az NXT motorjába is. A forgás érzékelő szenzor képes lépésekben érzékelve meghatározni a motor helyzetét, egy teljes kör 16 lépéssel tehető meg, amely így lépésenként 22.5 fokot jelent Ez nagyon durva beosztás az 1 fokos vezérléshez képest, viszont ezzel a

berendezéssel képesek vagyunk méréseket végezni, anélkül, hogy elvesztenénk egy motort, emellett ha a motort használnák ilyen jellegű mérésekre, ahhoz elég nagy forgató nyomatékra lenne szükségünk, még a szenzor forgatása szinte semennyi erőt nem igényel. Amennyiben több lépésre van szükségünk, mint 16 akkor használtunk áttételeket fogaskerekekkel így akár megsokszorozhatjuk a lépések számát. A következőkben egy régebbi modell leírásából mutatjuk meg a szenzor lehetőségeit. Oldal 40 Egy átlagos megoldásnál melyben azt szeretnénk elérni, hogy a robotunk előre, haladjon, két motorra és az őket vezérlő forgás érzékelő szenzorra van szükségünk. Normál esetben kicsi az esélye hogy a két motor azonos időben és erővel indul meg. A szenzorok segítségével láthatjuk, hogy egyik előbb vagy gyorsabban forog, ekkor az érzékelt jelek alapján egy pillanatra leállíthatja a kereket és a kívánt értékekre

állíthatja be mind két motor adatait (float). A következő példában pont ezt tesszük Két motort és két szenzort (1,3 bemenet) a gépre kapcsolunk. Prof.ingKőrösi Gábor Az NXC nyelv 2010 A program első részében beállítjuk a szenzorokat, és visszaállítjuk az értékeiket 0 ra. A következőkben belépünk a végtelen ciklusba. Ekkor a motorunk elindul előre, amennyiben az egyik motor erősseben halad, úgy azt egy pillanatra megállítja, amíg a két meghajtó értéke meg nem egyezik. Ez egy nagyon egyszerű program, megpróbálhatunk ettől bonyolultabb programokat is készíteni. TÖBB ÉRZÉKELŐ KAPCSOLÁSA EGY BEMENETRE Egy kis találékonyság kell, hogy észrevegyük a lehetőséget az NXT-ben. Gyárilag 6 vezetéken kapcsolódik a géphez a szenzorunk, melyet szabadon ráköthetünk a 4 bemenetünk bármelyére. De mi van akkor, ha ennyi szenzor nem elegendő? Összekapcsolhatunk két vagy több NXt-t vagy analóg illetve digitális (Ultrahangos

érzékelő) multiplexerrel, viszont ezekhez már kell valamennyit érteni a logikai áramkörökhöz, ami a kezdő felhasználó esetén nem igen áll rendelkezésre. Mint említettük a NXT-n négy bemenet található, amelyre gyakorlatilag ugyanennyi érzékelő köthető, ám logikus gondolkozással könnyen megduplázhatjuk ezeknek a számát, ha egy bemenetre több szenzort kötünk (egyszerű technikai boltban kapható elosztó segítségével). Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal Szintén összeköthetünk egy érintés szenzort és egy fényérzékelőt (a régi RCX modellt), melyeket beállítunk RAW módba. Az érintés szenzor ebben az esetben a maximális 100 még a másik kizárólag száz feletti értékeket vehet fel. A következő példa ezt a lehetőséget szemlélteti A fényérzékelőnek lefelé kell, néznie az érintés szenzor pedig előre kell, hogy nézzen. Amikor a fényérzékelő észleli a fekete vonalat (>750) akkor kicsit hátrál és

tovább megy, ha az érintés kapcsoló ütközik valamivel(<100) akkor ugyan ez a folyamat játszódik le. Íme, a program: 41 Például két érintés szenzort köthetünk párhuzamosan egy bemenetre, amikor egyiket vagy a másikat illetve mindkettőt megérintjük az érték 1 ellenkező esetben 0. Ez a megoldás abban az esetben használható, ha például egyik érzékelőt az előre a másikat a hátra haladás vizsgálatára építenénk be. Ez esetben, ha jelet kapunk a haladás irányát figyelembe véve kikövetkeztethetjük, hogy mely érintkező kapta az ütést, mert az kizárt, hogy előre haladás közben a hátsó szenzor kapja az ütést és ez fordítva is igaz. A másik lehetőség az ha a RAW módban figyeljük a szenzorok jeleit, ha szerencsések vagyunk teljes benyomás mellett a két jel eltérő nagyságú, és így megkülönböztethetjük őket. Ez a program remélhetőleg érthetően mutatja be az előzőekben taglaltakat. A moverandom eljárás

körmozgást eredményez véletlenszerű irányba. Először a moverandom indul meg és vár, amíg nem történik valami, ha alacsony(érintés) vagy magas (feketeszín) jelet érzékel, akkor egy kicsit hátrál a robot, majd ismét véletlenszerűen mozog. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal Ebben a fejezetben a megismerhettük az érzékelők számtalan lehetőségét. Az érzékelők típusának és módjának beállításait. Meg tanultuk használni a forgás érzékelőt És párhuzamosan több érzékelőt kötöttünk egy bemenetre, melyek használatával további távlatokat nyitottunk az NXT használatára. Azonban ez a könyve nem kíván kitérni az összes beállításra, azokról bővebben a NXC guide című könyvben olvashatunk. 42 ÖSSZEFOGLALÓ X. PÁRHUZAMOS ELJÁRÁSOK Eddig csak az általános illetve kibővített eszközök beállításán volt a hangsúly, a programokat a leg egyszerűbb soros módon írtuk meg, ez azonban nem mindig

megoldható, néha szükség van két vagy több párhuzamos feladat elvégzésére (szenzorfigyelés, zenehallgatás és mindeközben előrehaladás). Ennek nem megfelelő használata azonban okozhat fejfájást a felhasználóknak. A ROSSZ PROGRAM Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal Első ránézésre egy tökéltessen működő programnak tűnhet, viszont ha elindítjuk, nem várt hatások jelentkezhetnek. Próbáljuk ki a következőt: Érintsük, meg a szenzort mialatt fordul, ekkor az elindul hátra, de azonnal elindul előre ismét, nekimenve az érintett tárgynak. Ennek oka az összeférhetetlenség a programban, ugyanis a következő dolog történt. A robot elkezdett jobbra fordulni és elindult a késleltető utasítás, ekkor ütés érte a szenzort és, amelynek következtében hátra indul(na),de ugyanebben a pillanatban a main eljárás készenlétbe kerül és elindítja a robotot előre. 43 Kövessük végig a következő programot. Az első

eljárásban a robot négyszög alakban halad (ahogy azt már jó párszor programoztuk), majd a második eljárásban az érintés szenzort ellenőrizzük. Amint a szenzorütést érzékel, a robot hátrál, és 90o fordulatot hajt végre. Ez az eset így már világos, viszont nem láthattuk előre. A gond az hogy az eljárások nem tudják egymásról, hogy futnak-e még avagy már megálltak. A KRITIKUS RÉSZEK ÉS A MUTEX VÁLTOZÓ Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal A megoldás ez esetben, hogy a chek sensors és s move square eljárások csak akkor férhetnek a motorokhoz, ha azt a másik nem használja. Ezt az ACQURIE utasítással érjük el amely megvárja a moveMutex érték visszaállítását, majd belép program törzsbe és „lezárja” azt. Az előző utasítás ellentettje a RELEASE utasítás, amely felszabadítja a moveMutex változót, hogy más eljárás is hozzáférhessen. Ezeket a parancsokat mindig a kritikus programrész kezdetére és

végére kell tennünk, így kerülve el annak lehetőségét, hogy egyszerre két egymással ellentétes parancsot adjunk ki. 44 Egy lehetséges megoldás erre a problémára, ha olyan programokat írunk, ahol erre az összeférhetetlenségre odafigyelve készítjük el a megoldásunkat. Ezt tettük a VI fejezetben is Ismételjük meg ezt a programot. SZEMAFOROK HASZNÁLATA A gyalog módszere az előző megoldásunknak az ha készítünk szemafort. Az általános megoldási technika, hogy felveszünk egy változót,mely jelzi számunkra, hogy épp melyik eljárás használja a motorokat, így csak akkor fér hozzá az egyik, ha már a másik befejezte a vezérlést. Hozzunk tehát létre egy SEM nevű változót, melynek 0 értéket adunk, jelezve ezzel, hogy nincs használatban a motor, melyet az alábbi programban tekinthetünk meg. Oldal 45 Tehát a programrész várakozik mindaddig, amíg a sem változó értéke nem lesz 0, vagyis senki sem használja a motorokat. Amint

ez az érték 0, belép a ciklusba és felülírja a változó értéket 1 re, mellyel „lezárja” a többi eljárás hozzáférését a motorokhoz. Ekkor a program meg önállóan vezérelhet, és ha befejezte a „munkáját” akkor visszaadja a vezérlést (sem=0). A következő programban, ha az érintés érzékelő hozzáér valamihez, akkor a sem változót 1-be állítja, és elindítja a hátráltató programot, ez idő alatt a move square eljárás várakozik. Mihelyt a hátramenet befejeződött, sem változót visszaállítjuk 0-be, és átadjuk a vezérlést a move square-nak. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Mint látható a move square esetben nem lenne szükségünk a sem 1-be és 0-ba állítására, azonban ennek használata sok kellemetlenségtől menthet meg bennünket, mivel a VIII. fejezetben láthattuk, hogy a OnFwd() valójában két utasítás, és azt nem szeretnénk ha ezek össze akadnának. A szemaforok használata nagyon hasznos

dolognak bizonyul, ha komplikált párhuzamos eljárásokkal telített programokat készítünk. ÖSSZEFOGLALÓ Oldal 46 Ebben a fejezetben megismerhettünk egy olyan probléma típussal mely az egyes eljárások együttes használata közben jelenhet meg. Ennek elkerülésére több lehetséges megoldást is láthattunk Első megoldásként az eljárás leállítását és újraindítását alkalmaztuk a kritikus pontokon, még a második megoldásban szemaforokat alkalmaztunk mely letiltotta illetve engedélyezte a motorokhoz való hozzáférést. Ezeknek a megoldásnak a használata nélkülözhetetlen, hiszen rengeteg jövőbeni problémát küszöbölhetünk ki velük. Prof.ingKőrösi Gábor Az NXC nyelv 2010 XI. ROBOTOK KÖZÖTTI KOMUNIKÁCIÓ Amennyibe több NXT-vel vagy számítógéppel rendelkezünk, és szeretnénk ezeket valami módon összekapcsolni, úgy ebben a fejezetben megismerkedhetünk ennek lehetőségeivel. A robotunk eltérően a programozás alatt

használt USB kábeltől, képes BLUETOOTH kapcsolatot is teremteni gép és gép illetve gép és PC között, mellyel képes adatokat-üzeneteket küldeni és fogadni egy illetve több gép között. Az NXT kiinduló kapcsolatát MASTER nek nevezzük, ezen felül további 3 SLAVE összekötetésre képes. A master mindig a 0 a slave pedig az 1,2,3-as vonalakra csatlakozik Üzenetküldésre 10 postaláda áll rendelkezésünkre. A MASTER-SLAVE ÜZENETKÜLDÉS Két programot fogunk készíteni, az egyiket a MASTER a másikat a SLAVE bemutatására. Az egyszerű program megtanít bennünket a gyors folyamatos üzenetküldésre, és a kapcsolat elépítésére két eszköz között. Oldal 47 A master program először ellenőrzi, hogy a slave kapcsolat tényleg az 1 vezetéken találhatóe,(BT CONN álandó)a BluetoothStatus(conn) függvénnyel. Ez a parancs felépíti és elküldi az M előjeles üzenetet(számokat) a SendRemoteString(kapcs,várak.sor,karakterlánc)-al, mialatt

fogadja(várja) az üzenetet a slave-ről a ReciveRemoteString(kapcs,törlés,karakterlánc)-al. Ez alatt folyamatosan növeli az i szám értékét melyet karakterekké alakít és elküld. Az egész folyamatot figyelemmel követhetjük a kijelzőn, mivel azt az TextOut(oszlop,sor,karakterlánc) paranccsal megjelenítjük a képernyőn. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal 48 A következő program a SLAVE lehetőségeit mutatja be, mely nagyon hasonló az előzőhöz, viszont a SendRemoteString helyett a SendResponseString(srosz,karakterlánc)-ot használjuk, mivel a slave csak a masternek tud üzenetet küldeni. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Észrevehetjük, hogy amennyiben az egyik programot megszakítjuk, a másik folytatni fogja az üzenetek küldését és a számok növelését, anélkül, hogy észrevenné,hogy valójában az üzenetek eltűntek, mivel senki sem fogadta a másik oldalon. Ahhoz hogy megoldjuk ezt a problémát, terveznünk

kell egy kiváló protokollt, a kézbesítés értelmezésére. SZÁMOK ÉRTELMEZETT KÜLDÉSE A következőprogramban láthatjuk, hogy ez esetben a master számokat küld a SendRemoteNumber(kapcs,sor,szám) utasítással és megállva vár a slave nyugtázására (ReceiveRemoteString), miután az nyugtázta az előző üzenet fogadását kezdi meg a master az új üzenet küldését. A slave a RecieveRemoteNumber(sorsz,törlés,szám) paranccsal fogad és a SendResponseNumber-el küld számokat. A master-slave programnak muszáj tartalmazni a nyugtázó eljárást, melyet ez esetben a 0xFF hexadecimális címen találunk. A master véletlenszerűen küld számokat és vár a slave nyugtázására. Minden küldés után érkezik az érkezés nyugtázása a megfelelő kódszámmal, mely változót mindig ki kell törölnünk, különben a master úgy érzékeli, hogy minden rendben van és küldi tovább az üzeneteket, nyugtázás nélkül. Oldal 49 A slave állandóan ellenőrzi a

postafiókot, és ha nem üres, kijelzi és az elolvasott érték alapján nyugtázást küld a masternak. A program elején, kiválasztjuk a küldés, nyugtázás üzenetolvasás nélkül, hogy ezzel leblokkoljuk a mastert. Ez a trükk nélkül, amennyiben a master indulna elsőként, lehetetlen lenne elindítani később a slave-et. Ebben az esetben az első pár üzenet elveszne Viszontindíthatjuk a mastert és a slavet különböző időkben is anélkül, hogy a felakadáson idegeskednénk. Prof.ingKőrösi Gábor Az NXC nyelv 2010 DIREKT VEZÉRLÉS Oldal 50 A másik érdekes tulajdonsága a Bluetooth kommunikációnkban, az, hogy a master képes direkt vezérelni a slave eszközt. A következő példánkban a master üzeneteket küld a slave eszköznek, mellyel vezérli annak motorját és hangokat adat ki. Ebben az esetben nincs szükségünk slave programra, mivel így az NXT üzemel úgy mint slave (szolga). Prof.ingKőrösi Gábor Az NXC nyelv 2010

ÖSSZEFOGLALÓ Ebben a fejezetben tanulhattunk a bluetooth kommunikáció alapjairól, mellyel két vagy több eszközt kapcsolhatunk össze, fogadhatunk és küldhetünk ezek között adatokat, melyeket fel is dolgozhatunk, értelmezhetünk. Legutoljára a direkt vezérlést ismerhettük meg mellyel távolról vezérelhetővé tehetjük a robotunkat. Oldal 51 Az utolsó példában láthatunk jó pár olyan parancsot melynek nincs leírva a működési elve. Ez két okból történt. Az első mivel ez a könyv csak az alapok elsajátítását hivatott bemutatni, ahol nincs mód az összes felhasználható parancsot bemutatni (NXC giude),a másik ok hogy a jól választott kulcsszavaknak köszönhetően könnyen ki lehet következtetni a parancs mibenlétét. Prof.ingKőrösi Gábor Az NXC nyelv 2010 XII. TÖBB UTASÍTÁS Az NXC szinte megszámlálhatatlan paranccsal rendelkezik. Ebben a fejezetben három újabb paranccsal ismerkedünk meg. Ezek a:időzítők használata,

írás a kijelzőre, és az NXC fájlrendszerének elérése. IDŐZÍTŐK – TIMERS Az NXT állandóan futó időzítőt tartalmaz. Ez az egység egy másodperc alatt 1/1000 számol Ennek értékét bármikor lekérdezhetjük a CurrentTick() paranccsal. Íme, egy példa arra, hogyan használjuk az időzítőnket, mely példában a robot halad 10 másodpercig véletlenszerűen. 52 Ezt a példát összehasonlíthatnánk a IV. fejezetben használttal, amely szinte ugyan azt csinálja, mint az utóbbi program, viszont itt sokkal egyszerűbb megoldást készítettünk. Az időzítő nagyon jól használható a várakoztató utasítás kiváltására, melynek azért van jelentősége, mert még a wait alatt a rendszerünk „alvó üzembe ” kerül addig ennél a megoldásnál csak két szám értékének különbözetét figyeljük. A következő program ezt próbálja szemléltetni Vezéreljük a robotot 10 másodpercig, vagy érintsünk meg valamit az érintés szenzorral.

Prof.ingKőrösi Gábor Az NXC nyelv Oldal Ne feledjük ,hogy az időzítőnk 1/1000 beosztással dolgozik. 2010 PONT MÁTRIXOS KIJELZŐ Az NXT blokk rendelkezik fekete fehér pontmátrixos kijelzővel, melynek felbontása 100x64 pixel. A szövegek, számok,pontok, vonalak,körök,alakzatok, bitmapok (.ric fájlok) kiírására számtalan API függvényt találhatunk az NXC utasítás készletében. A következő példában ezeket a lehetőségeket próbáljuk bemutatni. A pixelek a 0,0 értékről, tehát a bal felső sarokból indulnak Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal ClearScreen() képernyő törlés; NumOut(x, y, number) kiírja a számot az adott koordinátákra; TextOut(x, y, string) kiírja a szöveget az adott koordinátákra. GraphicOut(x, y, filename) kiírja a .ric kép filet az adott koordinátákra CircleOut(x, y, radius) kiírja a kört (kör középpontját) az adott koordinátákra LineOut(x1, y1, x2, y2) vonalat rajzol az (x1,x2) től

(x2,y2) ig PointOut(x, y) pontot rajzol RectOut(x, y, width, height) kirajzol egy négyszöget az adott koordinátákra, azzal hogy meg adhatjuk a magasságát és szélességét ResetScreen() újraindítja a képernyőt 53 Ezek a parancsok szinte azonnal érthetőek, mindenki számára, azonban a biztonság kedvéért elemezzük ki őket. FÁJL RENDSZEREK Az NXT rendszerünk rendelkezik saját beépített memória kártyával melynek adatait tetszőlegesen tudjuk olvasni és írni. Ennek a lehetőségnek alkalmazásával a program futása közben tárolhatjuk például a szenzorok adatait, számértékeket, stb. Ezt azonban csak korlátozott mennyiségben tehetjük, hiszen a beépített kártyánk mérete korlátozott. További beépített lehetőség ként az NXT adatait az API függvények segítségével tetszőlegesen tudjuk manipulálni (létrehozni, átnevezni, törölni, keresni), olvasni, írni, stb. A következő példánkban bemutatjuk, hogyan hozhatunk létre egy

szöveges (string) fájt, és hogyan nevezhetjük azt át. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Oldal Az eredmény meglátásához mennyünk végig a BricxCC->Tools->NXT explorer útvonalon, és töltsük le a DannySaya.txt fájlt, melyet kinyithatunk a PC-ken 54 A program először törli a fájlt melynek neve megegyező az általunk használtéval (amennyiben van ilyen), ezt a beállítást végezhetjük manuálisan is mivel így könnyen kitörölhetünk olyan fájlt is amely esetleg fontos lett volna. A fájl készítés első mozzanata ként létrehozzuk a CreateFile(“Danny.txt”,512,fileHandle) paranccsal, melyben az első adat a fájl nevét , a második a méretét, a harmadik pedig annak kezelését hívatott beállítani. A karakterlánc (string) felépítéséhez és a fájl írásához a következő parancsot kell használnunk (kocsi vissza paranccsal rendelkező utasítás): WriteLnString(fileHandle,String,bytesWritten), ahol a zárójelben található

összes adatnak, mint változó kell szerepelnie. Végül az adatot lezárjuk és átnevezzük Emlékeztető : a fájlt muszáj, bezárnunk mielőtt további műveletekbe kezdenénk, tehát ha újat hozunk létre, akkor abba írhatunk, ha olvasni akarjuk azt is megtehetjük, de be kell zárnunk illetve ki kell nyitnunk hozzá az OpenFileRead() paranccsal, a törléshez és átnevezéshez pedig lezárt állapotban kell lennie. A következő példában megpróbáljuk kigenerálni a ASCII(minden billentyűn található karakter és írásjel) táblát. Ez egy borzasztóan egyszerű program volt, melyben a program létrehozta a fájlt amennyiben nem talált hibát, a számokat 0-255 generálja melyeket átalakít szöveggé (NumToStr), és kezeli a WriteBytes(handle,s,slen), mely egy (kocsi vissza paranccsal nem rendelkező utasítás)másik megoldás arra, hogy karakter láncokat írjunk. Ezek után számokat írunk a WriteLn(handle, érték) utasítással(kocsi vissza paranccsal

rendelkező utasítás). A program futásának eredményét megtekinthetjük az ASCII.txt fájlban, melyet megnyithatunk bármely szövegszerkesztő segítségével Még két fontos függvénnyel kell megismerkednünk, a ReadLnString melyekkel a karakterláncokat tudjuk olvasni és a ReadLn melyekkel a számokat tudjuk olvasni. Most egy példaként, az első parancsot használva, e CreateRandomFile függvénnyel létrehozunk egy fájlt melyekben random számokat találunk (mint karakterek, nem mint számok). A main eljárás kinyitja a fájlunkat az olvasáshoz. Minden sort elolvas amíg a fájl végéhez nem ér, ekkor meghívja a ReadLnString eljárást és kijelzi a szöveget. A CreateRandomFile függvényben generálhatunk előre definiált számú véletlenszerű számot, átalakítva azokat karakterekké és beírjuk azokat a lementett fájlba. Oldal 55 A ReadLnString hozzáférést hoz létre a fájl kezeléséhez, ahol a hívás után a karakterlánc tartalmazza a szöveg

sorait, és visszatérési értékként a hiba kódokat, mellekkel ellenőrizni tudjuk, hogy a fájl rendben volt e. Prof.ingKőrösi Gábor Az NXC nyelv 2010 Az utolsó programunkban, láthatjuk, hogy hogyan olvashatunk számokat a fájlinkból. Ezt egy kis példa programmal szemléltetjük. A programkód elején létrehozunk egy makrót, melyet a továbbiakban fogunk használni. Íme, az előfeldolgozóz makró Oldal Ez a módszer megmutatja számunkra, hogy hogyan tudunk egyszerre kezelni INT (16bit) és LONG(32bit)-es számokat ugyan azzal a ReadLn(handle,ért) utasítással. Mielőtt a hozzáférnénk fájlhoz és a szám értékekhez, visszatérési értékként hiba kódot kapunk. Prof.ingKőrösi Gábor Az NXC nyelv 56 Ez az egyszerű programrész úgy segíti a kódolást, hogy megnézi vajon milyen szám a beolvasott adat. Amennyiben a beolvasott érték Int típusú, akkor az első beállítás hajtódik végre , ha viszont Int helyett Long típust írunk be

akkor a második main-re ugrik a program. 2010 Oldal 57 A függvényünk 2byte-ot fog visszaolvasni a fájlból, amennyiben a változó deklarálása int , és 4 byte-t ha a változó long típusú. Ugyan így olvashatnánk vissza BOOL típusú változót is Prof.ingKőrösi Gábor Az NXC nyelv 2010 ÖSSZEFOGLALÓ Oldal 58 Ebben az utolsó fejezetben találkozhattunk a NXT haladó felhasználói megoldásával,a időzítőkkel a pont mátrixos kijelzővel és a fájlrendszerekkel, ennek a fejezetnek a megértése azonban már jóval túl van az alapok ismeretén. Így megtörténhetett, hogy ez a fejezet sok olvasó számára érthetetlen szavak keveréke lett, ez történhetett amiatt, hogy lehetetlen ilyen rövid idő alatt a nulláról indulva mindent elsőből megérteni, illetve az író nem tudta kellőképp megfogni és átadni a lényeget, úgy hogy az egy mindenki számára érthető legyen. Amennyiben ez így történt nem kell egyből megijedni, hiszen a

fájlrendszerek kezelése külön tananyag minden programnyelvben, és annak tanulása alatt sem érti meg mindenki első nekirugaszkodásra. Ha többszöri alkalomra sem sikerül használható alapokat megérteni, akkor célszerű valamely egyszerű programnyelv, mint például a pascal,c fájlkezelésének alapjait áttekinteni. Prof.ingKőrösi Gábor Az NXC nyelv 2010 XIII. ÁTTEKINTÉS Amennyiben sikerült átolvasni és átdolgozni ezt a könyvet, elmondhatjuk magunkról hogy profi felhasználóivá váltunk az NXT robotunknak. Hisz eleddig csak grafikus NXG környezetet ismerhettük, azonban ettől a pillanattól kezdve kiszeélesedett tudásunkkal, olyan programozási feladatokat is megoldhatunk melyekre eddig egyáltalán vagy csak nagyon nehezen lehettünk volna képesek. Ez a könyv nem fedi le a BricXCC összes lehetőségét, mivel ez a dokumentum alig 50-60 oldalas addig az teljes parancskészletet tartalmazó NXCguide.pdf több mint 2000 oldalas kiadvány, így

célszerű további fejlődésünk miatt annak részletes áttanulmányozása. Oldal 59 Továbbá nem jutottunk oda, a robot Pc-ről való irányításához sem , mivel ahhoz szükséges valamilyen vezérlő program megírása C++,Vb,vagy Delphi nyelvben. Az NXT képe több nyelvel és programmal együttműködve dolgozni, ha ez iránt érdeklődünk, akkor a Fantom SDK nyílt forráskódú program letöltésével kell kezdenünk. Prof.ingKőrösi Gábor Az NXC nyelv 2010 JOGOK ÉS FELHASZNÁLÁSI FELTÉTELEK Ennek a kiadványnak nem a pénzszerzés, hanem az információ terjesztése volt a szándéka. Így másolása, továbbküldése nemhogy tiltott, hanem kötelező minden Lego Mindstrom rajongó és felhasználó számára. Bárki tetszés szerint formálhatja, szerkesztheti, amíg annak nem pénzszerzés a célja. Azonban ha valaki nyomtatott kiadványként kívánja felhasználni, úgy köteles azt a szerzőnek, tehát nekem jelenteni és beleegyezésemet kérni,

ugyanis annak tartalma szerzői jogvédelem alatt ál. Versenyek, érettségi munkák, záró munkák felhasználása esetén csak annyi a követelmény, hogy forrásirodalomban ne felejtsük el megjelölni a dokumentum származásának helyét illetve annak írójának nevét. Mivel ez a könyv első kiadása így várhatóan számtalan hibát illetve hiányosságot fog tartalmazni, ezért előre is elnézést kérnék az olvasóimtól. A továbbtanulásom folyamán szándékomban áll felhasználni ezt a könyvet, így remélhetőleg hamarosan egy új kiforrottabb verzióval jelentkezem. Amennyibe az olvasónak észrevételei vannak, a könyvel, kapcsolatban azt jelezheti az imgaboy@yahoo.com email címen Illetve elérhet a wwwbolyai-zentaedurs oldal segítségével A NXC nyelv kidolgozását, a magyar nyelvű kiadvány hiány pótlására készítettem el. A jelenlegi munkahelyemen (szerbiai, zentai Bolyai Tehetséggondozó Gimnáziumban) az idei évben én tanítom a fakultatív

tantárgynak minősülő Programozás Előrehaladott Technikája elnevezésű tantárgyat melynek keretein belül szeretnénk foglalkozni ezzel az igen érdekes és jól alkalmazható „játékkal”. Mire elkészültem a fordítással-írással jutottam arra a következtetésre, hogy ez nem volt valami jó ötlet. Hiszen a mai világban, ha egy informatikus annyira sem ért angolul hogy egy ilyen könyvet megértsen, akkor előbb vagy utóbb el fog veszni a szakmai életben. Azonban ha már megírtam, ajánlom mindenkinek szeretettel. Jó programozást és szórakozást kívánok Kőrösi Gábor 2010, Zenta, Bolyai Tehetséggondozó Gimnázium Könyv címe: NXC programnyelv Oldal 60 Írta és fordította: prof.ing Kőrösi Gábor Daniele Benedettelli hasonló nevű könyve alapján Prof.ingKőrösi Gábor Az NXC nyelv 2010