Sapientia Erdélyi Magyar Tudományegyetem Műszaki és Humántudományok Kar Marosvásárhely
Robotprogramozási nyelv tervezése és fejlesztése négy szabadságfokú robotarchitektúrákra
Készítette: Demeter Zoltán Szak: Számítástechnika Évfolyam: V. Tudományos vezető: Dr. Márton Lőrinc Sapientia-EMTE, Műszaki és Humántudományok Kar Villamosmérnöki Tanszék
XI. Erdélyi Tudományos Diákköri Konferencia Kolozsvár 2008. május 23-24.
Tartalomjegyzék Kivonat ............................................................................................................................................ 3 1. Bevezetés..................................................................................................................................... 3 2. A rendszer specifikációi és architektúrája................................................................................... 6 2.1. A rendszer szerkezete, felépítése ......................................................................................... 6 3. Részletes tervezés........................................................................................................................ 7 3.1. Fejlesztett robotprogramozási nyelv .................................................................................... 7 3.2 Fejlesztett kompilátor............................................................................................................ 8 3.2.1 Lexikális elemző ............................................................................................................ 9 3.2.2 Szintaktikus elemző...................................................................................................... 11 3.3. Parancsok ........................................................................................................................... 14 3.3.1 Alapelvek ..................................................................................................................... 14 3.3.2 Változóspecifikus parancsok........................................................................................ 15 3.3.2.1 INIT....................................................................................................................... 15 3.3.2.2 LET........................................................................................................................ 15 3.3.3 Nyelvspecifikus parancsok........................................................................................... 15 3.3.3.1 IF ........................................................................................................................... 15 3.3.3.2 REPEAT................................................................................................................ 16 3.3.4 Robotvezérlési parancsok............................................................................................. 16 3.3.4.1 GRIPPER OPEN ................................................................................................... 16 3.3.4.2 GRIPPER CLOSE................................................................................................. 16 3.3.4.3 DELAY ................................................................................................................. 16 3.3.4.4 SPEED................................................................................................................... 17 3.3.4.5 ACCEL.................................................................................................................. 17 3.3.4.6 MOVE_TO............................................................................................................ 17 3.4. Pályatervezés...................................................................................................................... 18 3.4.1. Polinomiális pályatervezés.......................................................................................... 19 3.5. Összetett hibametrikán alapuló pályakövető szabályozás.................................................. 23 3.6. Use case diagram................................................................................................................ 26 3.7. Osztálydiagram................................................................................................................... 27 3.8. Kollaborációs diagram ....................................................................................................... 27 3.9. Szekvencia diagram............................................................................................................ 28 4. Következtetések ........................................................................................................................ 28 4.1 Felhasznált technológiák ..................................................................................................... 28 4.2 Mérési eredmények ............................................................................................................. 29 5. Irodalmi jegyzék........................................................................................................................ 32
2
Kivonat Számos ipari folyamatban
gyakran használt eszköz a robotkar manipulálási,
összeszerelési, festési, hegesztési feladatok végrehajtására. A robotok algoritmizálható mozgásokat hajtanak végre. Felprogramozásuk, az előírt mozgásuk meghatározása a mérnökök feladata. A feladatok leírására úgynevezett robotprogramozási nyelveket használnak, melyek lehetővé teszik a robotok magasabb szintű, felhasználóbarát irányítását. Ezeket a programozási nyelveket általában a gyártó biztosítja, de fejleszthetünk saját programozási nyelvet is. A dolgozatban egy általam kifejlesztett négy szabadságfokú robotra alkalmazható robotprogramozási nyelv kerül bemutatásra. A megvalósított robotprogramozási nyelven a felhasználó által írt – Assembly-szerű – programot a robotnak végre kell hajtania. A nyelv utasításkészlete segítségével bármely robotmozgás leírható. A szoftver környezetet biztosít a programok írásához, szerkesztéséhez, megfigyeléséhez (követendő pálya grafikus megjelenítése, szabályozási hiba változása a robot mozgása során, robotkar mozgásának 3 dimenzióban történő megjelenítése), valamint a robot alacsony szintű teszteléséhez (robot tesztelése nyílt hurokban, PD+F szabályozás). A megírt programot a rendszer elemzi (lexikális, szintaktikus elemzés), helyes program esetén a program végrehajtásra kerül, ellenkező esetben a rendszer jelzi a hibákat a felhasználónak. Kulcsszavak: ipari robotkar, robotprogramozási nyelv, off-line programozás, kompilátor, szintaktikai elemzés, lexikális elemzés, robotirányítás.
1. Bevezetés A robotprogramozási nyelvek célja, hogy a robotirányítást közelebb hozzák a felhasználóhoz. A felhasználónak arra kell fektetnie a hangsúlyt, hogy mit szeretne a robottal végrehajtatni és nem a végrehajtás módjára. A felhasználónak tehát nem kell értenie az irányítás mikéntjét, elég ha a műveleteket egy magasabb absztrakciós szinten ismeri. Ezen magasabb szint és a valós irányítás közötti kapcsolatot a robotprogramozási nyelv teszi lehetővé. A felhasználó egy virtuális világban gondolkodik, modellezi a valóságot, míg a robotprogramozási nyelv a valós, fizikai rendszert irányítja.
3
1. ábra. Robotprogramozási nyelvek működésének blokkrajza[1] alapján Mivel gyárakban a robotok használói általában kevés ismerettel rendelkeznek az alacsony szintű robotirányításról, ezért robotprogramozási nyelveket már az első robotkarok megjelenése óta készítettek a robotok felhasználóbarát programozásának lehetővé tétele céljából. Az első ilyen, Assembly-szerű programozási nyelvek a 70-es évek elején jelentek meg: az IBM által fejlesztett AUTOPASS[9] nyelv, az Edinborough Egyetemen fejlesztett RAPT[3] nyelv, az MIT által fejlesztett LAMA nyelv. Ezek a nyelvek feladatorientált nyelvek voltak, azaz a végrehajtandó feladatot egyszerű, Assembly parancsokhoz hasonló utasításokkal lehetett leírni. Az AUTOPASS nyelvet például kifejezetten összeszerelési feladatok megoldására tervezték[9], folyamatosan fejlődik, ma már a mesterséges intelligencia elemeit is használja[12]. A 70-es évek közepén megjelentek a strukturált robotprogramozási nyelvek. Ezek lehetővé tették az adatstruktúrák használatát. Ilyen volt például a VAL[2] vagy az IBM által fejlesztett AML[12]. A VAL nyelvet eredetileg PUMA robotkarok programozásához tervezték, de egyszerűsége miatt nagyon elterjedt[12]. Az AML nyelvben lehetőség van geometriai pont, tömb, paletta, logikai típusú változó létrehozására[12]. Ezek a nyelvek már a modern robotprogramozási nyelvek alapjait fektették le. A Braunschweigi Műszaki Egyetemen fejlesztették a
High
Lap valamint a
[1]
ZERO++ nevű nyelveket . A Richard E. Pattis által készített Karel nevű nyelv kifejezetten didaktikai és oktatási célokat szolgált[10]. Ezt a mininyelvet[11] Pattis a Stanford Egyetemen tartott kurzusaiban használta. Öt alaputasítással rendelkezik valamint programelágazást és iterációt tartalmaz. Egy Karel programot végrehajtó robot csak diszkrét mozgásokat tud végezni. A Karel nyelv egyszerűségének köszönhette sikerét. Számos nyelvre lefordított változata jelent meg. Továbbfejlesztett változata az objektumorientált Karel++ programozási nyelv. A japán FANUC Robotics robotgyártó cég főként Karel nyelven valósítja meg a robotkarok programozását[10]. Megállapítható, hogy számos programozási nyelv született a világ számos egyetemén, kutatóközpontjában.
A
gyakorlatban
használt
és
a
laboratóriumokban
kifejlesztett
robotprogramozási nyelvek képességei és lehetőségei közötti szakadék azonban nagyon nagy. 4
Manapság robotirányítás már nem csak felhasználó által írt program alapján képzelhető el, hanem akár hang vagy kép alapján is. Ilyen, laboratóriumban megalkotott és modellezésre használt programozási nyelv a Japánban kifejlesztett EusLisp[4], ami már objektumorientált paradigmát követ, és melynek első változata már 1986-ban megjelent. Ezzel a nyelvvel lehetséges a robotkarok 3D modellezése, akár hangfelismerésen, képfeldolgozáson alapuló irányítása. A német Bosch cég által kifejlesztett BAPS plus[13] nyelv folyamatábrák segítségével teszi lehetővé az ipari robotkarok programozását. A grafikusan megrajzolt folyamatábrát a rendszer fordítja programkóddá ezáltal csökkentve a hibalehetőséget. Kétféle robotprogramozási módot különböztetünk meg[12]: •
on-line programozás: létezik közvetlen összeköttetés a robottal
•
off-line programozás: nincs közvetlen összeköttetés a robot és a vezérlő program között a programírás pillanatában
Az on-line programozás során felhasználjuk a robotvezérlő szolgáltatásait. A módszer előnye, hogy helyes, működő program keletkezik, egyes pontokat betanítással adhatunk meg. Hátránya, hogy a programozás során a robot kiesik a termelésből. Az off-line programozás esetében a robotot vezérlő program írása és a robotarchitektúra térben elválik. Ebben az esetben nincs szükség sem a robotarchitektúrára sem a vezérlőegységre a program írásához. Egy rendszer ellenőrzi a megírt program lexikális, szintaktikai, szemantikai helyességét, szimulációs lehetőséget biztosíthat. Előnye, hogy nem okoz termeléskiesést. Hátránya, hogy nem feltétlenül keletkezik helyes program. A hibák csak a program valós futtatásánál derülnek ki. Az általam fejlesztett nyelv átmenetet képez a didaktikai célokat szolgáló Karel nyelv és az adatstruktúrákat is kezelő nyelvek között. A bemutatásra kerülő rendszer didaktikai koncepciókat is magában foglal: •
utasításai egyszerűek, mininyelv
•
tervezett pálya grafikus megjelenítése
•
megtett út 3 dimenziós ábrázolása
•
robotkar alacsony szintű tesztelése
A programnyelv ugyanakkor kezelni tud változókat is, ami már a VAL és az AML nyelvek sajátossága. A fejlesztett nyelv és a Pattis által fejlesztett Karel nyelv közötti különbség, hogy míg egy Karel programot végrehajtó robot csak diszkrét mozgásokat tud végezni, addig a bemutatásra kerülő nyelven bármely robotmozgás leírható. A fejlesztett nyelv négy szabadságfokú robotarchitektúrák off-line programozását teszi lehetővé. A nyelv könnyen bővíthető új utasításokkal, áttervezhető több szabadságfokú robotok 5
irányítására. A rendszer által rajzolt grafikonoknak nem csak didaktikai, hanem szimulációs értékük is van.
2. A rendszer specifikációi és architektúrája Az általam fejlesztett programozási nyelv célja lehetőséget biztosítani a felhasználónak egy négy szabadságfokú robot magasabb szintű irányításához. Az ezen a nyelven írt programnak olyan utasítássorozattá kell alakulnia, ami a robotkar számára értelmezhető és végrehajtható.
2.1. A rendszer szerkezete, felépítése A rendszer 5 fő részből áll: programozási nyelv, kompilátor, pályatervező modul, irányítási modul, monitorizálás.
2. ábra. A rendszer működésének blokkrajza A felhasználó, aki lehet akár mérnök, akár kevésbé képzett szakember, egy robotvezérlési programot ír a kifejlesztett robotprogramozási nyelven. Az így megírt programot első lépésben a kompilátor dolgozza fel. Abban az esetben, ha a megírt program hibamentes, a kompilátor generál egy kódsorozatot, ami alapján a pályatervező modul megtervezi az előírt pályát, amit a robotkarnak követnie kell. Ez a megtervezett pálya az irányítási modul bemenete, az irányítási algoritmus ezen pálya alapján számolja ki minden mintavételben a vezérlőjelet, amit kiküld a robotkarnak. A kiküldött vezérlőjel a robotkar valamilyen elmozdulását eredményezi. A robotkar valós helyzetét (pozíció, sebesség, gyorsulás) az érzékelők mérik. Ezek az adatok visszaáramolnak az irányítási modulba, valamint a felhasználó számára is megjelenítődnek a monitorizálás segítségével.
6
3. Részletes tervezés Az előzőekben láttuk, hogyan kapcsolódnak az egyes modulok egymáshoz, milyen viszonyban vannak egymással. Most lássuk részletesen, hogyan is épülnek fel egyenként.
3.1. Fejlesztett robotprogramozási nyelv A nyelvnek olyan egyszerű elemeket kell tartalmaznia, melyek a mérnökök számára könnyen érthetőek, átláthatóak. Mivel a nyelv használói nem feltétlenül programozók, ezért a nyelvi elemeknek kellően „szorosnak” kell lenniük, azaz nem engedhetünk meg túl nagy szabadságot a programíróknak, ellenkező esetben a nyelv átláthatatlanná, bonyolulttá válik az ipari dolgozó számára. Egy olyan mininyelvet kell alkotni, ami segítheti a robotkarok programozásának elsajátítását. Bármely nyelvet le tudunk írni a nyelv nyelvtanával. Bármely nyelvtant a következő négyes határoz meg[5]: G = ( N , Σ, P, S ) , ahol •
N a nemterminálisok halmaza, N ≠ Φ
•
Σ a nyelv ábécéje, a terminálisok halmaza Σ ≠ Φ és Σ ∩ N = Φ
•
P a helyettesítési szabályok halmaza
•
S mondatszimbólum vagy kezdőszimbólum, S ∈ N
Az általam fejlesztett nyelv nyelvtanát a továbbiakban G-vel jelölöm és a következő módon határozom meg: Nemterminális szimbólumok halmaza: N = {< commands >, < LET >, < INIT >, < MOVE _ TO >, < SPEED >, < ACCEL >, < GRIPPER >, < DELAY >, < REPEAT >, < var iable >, < number 1 >, < number 2 >, < container >, < operator >, < realtion >, < char >, < digit 1 >, < digit 2 >}
Terminális szimbólumok halmaza: Σ = {MOVE _ TO, X , Y , Z , T , SPEED, VX , VY , VZ , VT , ACCEL , AX , AY , AZ , AT , IF , ENDIF , ELSE , GRIPPER OPEN , GRIPPER CLOSE , DELAY , a..z , A..Z ,0..9, =, <, >, <=, >=, !=, ==,+,−,*, /, {, }, (, )}
Helyettesítési szabályok: I. rész S → {
→ | | <MOVE_TO> | <SPEED> || | | | | } → = → = → REPEAT () { 7
<MOVE_TO> → MOVE_TO X Y Z T <SPEED> → SPEED VX VY VZ VT → ACCEL AX AY AZ AT → IF () { <ENDIF> <ENDIF> → ENDIF | ELSE { ENDIF → GRIPPER OPEN | GRIPPER CLOSE → DELAY → | II. rész → | | → a..z | A..Z → | | . → - → 0..9 → 1..9 → < | > | <= | >= | != | == → + | - | * | / Mondatszimbólum: S A fentiekben leírt nyelvtan által generált nyelv az a robotprogramozási nyelv, melyet a felhasználó alkalmaz a robotikai feladat leírására. Az ezen a nyelven írt helyes program a nyelv egy mondata.
3.2 Fejlesztett kompilátor A kompilátor az első olyan modul, ami a felhasználó által írt programmal kapcsolatba lép. Feladata, hogy ellenőrizze, hogy a felhasználó által írt program eleget tesz-e a G nyelvtannak, azaz a programozási nyelv egy szava-e. Ha a program a G nyelvtan által generált nyelv egy szava, akkor a program helyes, ha nem, akkor az a program hibás, nem a G nyelv által generált nyelven íródott. A kompilátor két fő modulból épül fel: a lexikális és a szintaktikus elemzőből. A felhasználó által írt robotvezérlési program a lexikális elemző bemenetére kerül. Ha lexikálisan helytelen a program, akkor a fejlesztőnek ki kell javítania a programban előforduló lexikális hibákat. Ha a program lexikálisan helyes, akkor a lexikálisan elemzett program a szintaktikus elemző bemenetére kerül. Ha a program szintaktikailag helytelen, akkor a 8
programozónak ismét ki kell javítania az előforduló, ezúttal már szintaktikai hibákat. Ha a program szintaktikailag helyes, akkor a szintaktikus elemző kimenete a következő modulhoz (pályatervezés) kerül. Ezt a folyamatot szemlélteti a (3. ábra).
3. ábra. Kompilátor folyamatábrája A szintaktikus elemző kimente egy olyan kódolt állomány, ami a „hagyományos” kompilátorok esetében a tárgykódnak felel meg. Ez az állomány a háttértárolón tárolódik, bármikor végrehajtható az eredeti program hiányában is. Ezt az állományt tekinthetjük a robotkar által végrehajtható programnak. A különbség a „hagyományos” kompilátorok és a fejlesztett kompilátor között, hogy míg az első esetben a tárgykódot processzor hajtja végre, addig a második esetben a tárgykód egy mechanikai rendszeren, a robotkaron kerül végrehajtásra. Analógia alapján jelenthetjük ki, hogy a robotkar gépi kódja a szintaktikus elemző kimeneti állománya. Megállapítható továbbá, hogy a fordítási és futási idő elkülöníthető egymástól, ugyanis a szintaktikus elemző kimenete anélkül is létrejöhet, hogy a program végrehajtódna. Mindezek alapján kijelenthetjük, hogy a fejlesztett rendszer esetében kompilátorról beszélünk.
3.2.1 Lexikális elemző Egy programozási nyelven írt program elemzésének első lépése a nyelv szimbólumainak felismerése. Ezt a feladatot a lexikális elemző látja el. A lexikális elemző bemenete egy, a 9
felhasználó által robotprogramozási nyelven írt program, amelyben a nyelv szimbólumait fel kell ismerni. Ilyen szimbólumok például a kulcsszavak, változónevek, konstans értékek stb. A szimbólumok definíciójára kiválóan alkalmasak a reguláris kifejezések[14]. Például a MOVE_TO kulcsszót akárhány fehér szóköz előzheti meg vagy követheti, ezért a következő reguláris kifejezéssel írható le: (tab|space)*MOVE_TO(tab|space)+ Kijelenthető tehát, hogy a fejlesztett robotprogramozási nyelvben a kulcsszavak közé tetszőleges számú fehér szóközt tehetünk. A lexikális elemző kimenete két állomány: •
lex.out – a bementi állományban felismert szimbólumok kódjait tartalmazza
•
lex.err – ha a bemenetet nem sikerült lexikálisan elemezni, akkor tartalmazza a hiba sor- és sizmbólumszámát
A lex.exe állományt a Flex[15] külső eszközzel hoztam létre. Ennek bemenete egy lex.txt nevű állomány, mely a nyelv szimbólumainak megfelelő reguláris kifejezéseket tartalmazza. A Flex a lex.yy állományt generálja, ami nem más, mint egy ANSI C kód. Ennek futtatása során jön létre a lexikális elemző megfelelő kimenete. A lexikális elemző a G nyelvtan II. részét teljes mértékben felismeri, azaz a változókat, konstans értékeket, valamint az I. rész terminális szimbólumait: MOVE_TO, SPEED, DELAY, ACCEL, kapcsos zárójelek (programblokkot közrefogó szimbólumok. Minden terminális szimbólumnak megfelel egy kód. A kódokat úgy választottam meg, hogy a nyelv bővítése ne okozzon problémát, 1-50 a nyelvhez tartozó utasításszerű kulcsszavak tartoznak, míg az 51. kódtól kezdődnek a változók, számok, zárójelek, operátorok stb. A lexikális elemző kimenete tehát egy kódsorozat. A terminális szimbólumok kódolását foglalja össze a (1. táblázat). A lexikális elemzés után a program szövege már nem olvasható. Ettől a ponttól kezdve mindegy, hogy a nyelvben milyen kulcsszavakat adtunk például a ciklus megnevezésére: az angol while vagy a magyar ismételd szavak ugyanazt a kódot kapják. Ebből következően egy programnyelvet könnyű átírni bármely más nyelvre, hiszen csak a lexikális elemzőt kell megváltoztatni[14]. Ha a lex.err állomány nem tartalmaz bejegyzést, az azt jelenti, hogy a felhasználó által írt program forráskódját sikerült lexikálisan elemezni, és a forráskód kódolását megtaláljuk a lex.out állományban. Abban az esetben, ha a lex.err tartalmaz bejegyzést, akkor mindenik hibajelzés tartalmazza, hogy a hibát a forráskód hányadik sorában, a soron belül hányadik szimbólumnál fedezte fel a lexikális elemző.
10
Megjegyzendő, hogy mindig a legelső hiba javításával próbálkozzunk, majd próbáljuk meg ismét elemezni a programot, mivel a második hiba lehet, hogy az első következménye. 1. táblázat A G nyelvtan terminális szimbólumainak kódjai 1-50 utasítások
Literálok, változók, operátorok stb.
1 – MOVE_TO
51 – pozitív valós szám
2 – X a MOVE_TO parancs paramétere
52 – programváltozó
3 – Y a MOVE_TO parancs paramétere
53 – + - / * operátorok
4 – Z a MOVE_TO parancs paramétere
54 – = operátor
5 – T a MOVE_TO parancs paramétere
55 – (
6 – REPEAT
56 – )
7 – LET
57 – < > <= >= != == logikai operátorok
8 – IF
58 – {
9 – ELSE
59 – }
10 – GRIPPER OPEN 11 – GRIPPER CLOSE 12 – SPEED 13 – VX, a SPEED parancs paramétere 14 – VY a SPEED parancs paramétere 15 – VZ a SPEED parancs paramétere 16 – VT a SPEED parancs paramétere 17 – INIT 18 – DELAY 21 – ACCEL 22 – AX az ACCEL parancs paramétere 23 – AY az ACCEL parancs paramétere 24 – AZ az ACCEL parancs paramétere 25 – AT az ACCEL parancs paramétere 26 – ENDIF
3.2.2 Szintaktikus elemző A szintaktikus elemző egy programozási nyelv környezetfüggetlen nyelvtana alapján elemez[14]. Ez a környezetfüggetlen nyelvtan határozza meg az utasítások szerkezetét, felépítését. A szintaktikus elemző feladata annak megállapítása, hogy a felhasználó által megírt program a nyelvtan egy mondata-e. Ez úgy lehetséges, hogy az elemzőnek meg kell alkotnia a programhoz 11
tartozó levezetési fát. A levezetési fa gyökéreleme a mondatszimbólum, levelei pedig terminális szimbólumok. Ezeket a terminális szimbólumokat a lexikális elemző szolgáltatja a szintaktikus elemzőnek. A szintaktikus elemzőnek fel kell építenie a levezetési fa gyökéreleme és a levelek közti részét. Ha nem létezik egyetlen levezetési fa sem, akkor a program helytelen. Az elemzés függőleges irányát tekintve két féle elemzési módszerről beszélhetünk: •
fentről lefele elemzés: a mondatszimbólumból indulunk ki és a helyettesítési szabályok segítségével megpróbáljuk elérni, hogy a levezetési fa leveleit összeolvasva az elemzendő programot kapjuk. Ilyen elemzések: LL(1), rekurzív leszállás módszere stb.
•
lentről felfele elemzés: a programból indulunk ki és a helyettesítési szabályok segítségével megpróbálunk eljutni a mondatszimbólumig: LR(1), SLR, LALR stb.
Attól függően, hogy a terminális szimbólumok olvasását a szintaktikus elemző milyen irányból végzi, megkülönböztetünk balról jobbra és jobbról balra elemzéseket. A rendszer által használt szintaktikus elemző egyik bemenete a lexikális elemző által generált kódsorozat (lex.out), másik bemenete pedig a nyelvtan azon helyettesítési szabályai, melyeket a lexikális elemző még nem elemzett. A szintaktikus elemző az LL(1) elemző algoritmust[6,
7]
valósítja meg. Ehhez az
szükséges, hogy a nyelvtan teljesítsen bizonyos követelményeket: •
Minden szabály terminálissal kezdődjön
•
Ne legyen több lehetőség egy nemterminális szimbólum szabályai között ugyanazon terminálisra, azaz egy nemterminálishoz tartozó összes szabálynak különböző terminális szimbólummal kell kezdődnie.
Ezen követelmények teljesítése végett a fent ismertetett G nyelvtant át kell alakítanunk: Nemterminális szimbólumok halmaza: N = {< commands >, < container >, < ENDIF >}
Terminális szimbólumok halmaza: Σ = {INIT , LET , REPEAT , MOVE _ TO, X , Y , Z , T , SPEED, VX , VY , VZ , VT , ACCEL, AX , AY , AZ , AT , IF , ELSE , ENDIF , GRIPPER OPEN , GRIPPER CLOSE , DELAY , (, ), {, }, < number >, < var iable >, < relation >}
Megjegyzendő, hogy az előző nyelvtanban még nemterminális szimbólumként szerepelő , és szimbólumok ebben a nyelvtanban már terminális szimbólumként szerepelnek, mert a lexikális elemző már felismerte őket, és elkódolta. Helyettesítési szabályok: S → { → INIT = 12
→ LET = → REPEAT ( ) { → MOVE_TO X Y Z T → SPEED VX VY VZ VT → ACCEL AX AY AZ AT → IF () { <ENDIF> → GRIPPER OPEN → GRIPPER CLOSE → DELAY → } → | <ENDIF> → ENDIF <ENDIF> → ELSE { ENDIF Mondatszimbólum: S A nemterminális szimbólumok (beleértve a mondatszimbólumot is) a következő kódolással szerepelnek a grammar.txt állományban: 2. táblázat A szintaktikus elemző által használt nyelvtan nemterminális szimbólumainak kódolása Nemterminális szimbólum
Kód
S
-1
-2
-3
<ENDIF>
-4
A szabályok kódolt formában találhatóak a grammar.txt állományban. Az állomány első eleme megmondja, hogy hány szabály van. Minden sor első eleme megmondja, hogy hány szimbólum szerepel a helyettesítési szabályban, a második szimbólum a szabály bal oldalán szereplő nemterminális szimbólum, míg a harmadik szimbólumtól kezdődően van kódolva a helyettesítési szabály jobb oldala. A nemterminális szimbólumokat negatív, míg a terminálisokat pozitív számok jelölik. A szintaktikus elemzőnek tehát két bemenete van: a lexikális elemző kimenete, és a nyelvtan szabályait tartalmazó grammar.txt állomány. A szintaktikus elemző feladata tehát megvizsgálni, 13
hogy a lexikális elemző kimenetén megjelenő program megfelel-e a nyelvtan szabályainak. A grammar.txt bemeneti állomány alapján feltöltjük a szintaktikus elemző T tömbjét a megfelelő elemekkel. T tömb nem más, mint egy táblázat, amely a nemterminálisoknak megfelelő szabályokat tartalmazza. Az oszlopindexek a terminális szimbólumok kódja, a sorindexek a nemterminálisok kódjának aboszlút értéke. A szintaktikus elemzés ezen táblázat alapján történik az LL(1) elemző algoritmusnak megfelelően. A szintaktikus elemzésnek két kimeneti állománya van: error.log és sin.out. Abban az esetben, ha a error.log állomány tartalmaz bejegyzést, akkor a programban szintaktikai hiba van. A hibaüzenet tartalmazza a felfedezett szintaktikai hiba programbeli sorindexét, valamint, hogy hányadik szimbólum a sorban. Ha a error.log állomány nem tartalmaz bejegyzést, akkor a szintaktikus elemzés sikeres volt, azaz a program a G nyelvtan által generált nyelv egy mondata. Ebben az esetben a sin.out állomány tartalmazza a robotkar által végrehajtható kódot. Ez a kód nem más, mint a robotkar által végrehajtandó műveletek és azok paraméterei. Ennek a kódnak az értelmezése és végrehajtása már az alacsony szintű irányítás feladata. A következőkben ismertetem a meghatározott programozási nyelv szintaxisát.
3.3. Parancsok A kompilátor kimenete egy olyan állomány, amely az eredeti robotvezérlési program egy kódolt formája. Ez az állomány tartalmazza a műveletek kódjait valamint a literálokat, operátorokat, a felhasználó által deklarált változókat stb. Mondhatjuk, hogy egy robotvezérlési program műveletekből és a műveletek paramétereiből áll. A következőkben ismertetem a parancsok szintaktikai formáját. A következő jelöléseket használom: •
változónév – karakterlánc, ami nem kezdődhet számmal
•
operandus – változó vagy pozitív valós szám
•
operátor – +,-,*,/ aritmetikai operátorok
•
logikai operátor – <, >, <=, >=, !=, == logikai operátorok
•
[] – kötelező érték
•
<> – opcionális érték
3.3.1 Alapelvek Bármely, a fejlesztett robotprogramozási nyelven megírt robotvezérlési program literáljai az R , a valós számok halmazán értelmezettek. A nyelv minden kulcsszavát nagybetűvel kell írni. Bármely program programblokkokból épül fel, melyeket kapcsos zárójelek jeleznek. Magát 14
a teljes programot is kapcsos zárójelek közé kell tennünk, mert a teljes program is egy programblokknak számít. A programnyelv kulcsszavai közötti fehér karakterek számának nincs jelentősége.
3.3.2 Változóspecifikus parancsok A változóspecifikus parancsokhoz olyan műveleteket sorolok, melyek nincsenek közvetlen és azonnali hatással a robotkar vezérlésére, hanem adattároláshoz, aritmetikai műveletek végzéséhez köthetőek. 3.3.2.1 INIT Az INIT parancs lehetővé teszi a felhasználó számára változó bejelentését. Szintaxis: INIT [változónév]=[operandus] A változónév az újonnan bejelentett változó neve, az operandus valós szám az R -ből vagy egy előzőleg már bejelentett változó neve. 3.3.2.2 LET A LET parancs lehetővé teszi egy már előzőleg bejelentett változó módosítását, aritmetikai művelet végzését. Szintaxis: LET [változó]=[operandus1][operátor][operandus2]
3.3.3 Nyelvspecifikus parancsok A nyelvspecifikus parancsok csoportjába a ciklus, elágazás meghatározása tartozik. 3.3.3.1 IF Az IF parancs programelágazást tesz lehetővé egy logikai feltétel alapján. Szintaxis: IF ([operandus1][logikai operátor][operandus2]) { <művelet1> <művelet2> … <műveletN> } [ELSE { <művelet1> 15
<művelet2> … <műveletN> }] ENDIF Egymásba ágyazott elágazások is lehetségesek. 3.3.3.2 REPEAT A REPEAT lehetővé teszi a parancsok ciklikus végrehajtását. Szintaxis: REPEAT ([operandus1][logikai operátor][operandus2]) { <művelet1> <művelet2> … <műveletN> } Egymásba ágyazott REPEAT utasítások is lehetségesek
3.3.4 Robotvezérlési parancsok A robotvezérlési parancsok kategóriájába azokat a műveleteket sorolhatóak, amelyek közvetlen hatással vannak a robotkar alacsony szintű irányítására. 3.3.4.1 GRIPPER OPEN A GRIPPER OPEN parancs hatására kinyílik a végberendezés megfogója. Szintaxis: GRIPPER OPEN 3.3.4.2 GRIPPER CLOSE A GRIPPER CLOSE parancs hatására a végberendezés megfogója összezár. Szintaxis: GRIPPER CLOSE 3.3.4.3 DELAY A DELAY parancs hatására a robotvezérlés „felfüggesztődik”, azaz a robot a paraméterként milliszekundumban megadott időegységet vár, ezen idő lejárta után folytatódik az irányítás, a robotvezérlési program végrehajtása. Mivel a programnyelv valós számokkal dolgozik, ezért a DELAY utasítás paramétere is lehet valós szám. A robotvezérlés a paraméter egész részének abszlút értékéig fog felfüggesztődni. Az egész rész viselkedése a IEEE Standard 16
754 4. bekezdésének megfelelő, azaz ha a kerekítendő szám pontosan két egész szám közé esik, akkor a kerekítés eredménye a páros szám lesz. Szintaxis: DELAY [operandus] 3.3.4.4 SPEED A SPEED parancs segítségével beállíthatjuk a robotkar motorjainak maximálisan megengedett sebességét. A SPEED parancs a négy szabadságfokú robotkar négy motorjának az egymástól független sebesség-beállítását teszi lehetővé. Szintaxis: SPEED VX [operandus1] VY [operandus2] VZ [operandus3] VT [operandus4] A VX, VY, VZ, VT paraméterértékek százalékban értendők, azaz azt tudjuk beállítani, hogy a motor valós maximális sebességének hány százalékával szeretnénk dolgozni. Ez a valós maximális motorsebesség implementációban kódolt érték, jelen esetben v MAX = 3000 felhasználó által beállított csuklósebességek pedig v MAX i = v MAX
operandusi 100
fok . A s
ahol i = 1,4 .
Alapértelmezett módon operandusi = 100 . 3.3.4.5 ACCEL Az ACCEL parancs segítségével beállíthatjuk a robotkar motorainak maximálisan megengedett gyorsulását Az ACCEL parancs a négy szabadságfokú robotkar négy motorjának az egymástól független gyorsulás-beállítását teszi lehetővé. Szintaxis: ACCEL AX [operandus1] AY [operandus2] AZ [operandus3] AT [operandus4] Az AX, AY, AZ, AT paraméterértékek százalékban értendők, azaz azt tudjuk beállítani, hogy a motor valós maximális gyorsulásának hány százalékával szeretnénk dolgozni. Ez a valós maximális motorgyorsulás implementációban kódolt érték, jelen esetben aMAX = 5000 csukló
felhasználó
által
beállított
gyorsulása
aMAX i = aMAX
operandusi 100
ahol
fok . A s2 i = 1,4 .
Alapértelmezett módon operandusi = 100 . 3.3.4.6 MOVE_TO A MOVE_TO parancs segítségével a robotkart eljuttathatjuk a munkatér egyik pontjából egy másik pontjába. Mind a négy szabadságfokra meg kell adnunk a kívánt végpozíciót. A robotkar mindig az aktuális pozícióból indul ki és eljut a végpozícióba, azaz ha két MOVE_TO
17
parancs szerepel egymás után a második MOVE_TO kezdőpontja az a pont lesz, ahol a robotkar az első MOVE_TO után megállt. Szintaxis: MOVE_TO X [operandus1] Y [operandus2] Z [operandus3] T [operandus4] Az operandus1, operandus2, operandus3 és operandus4 értékek az X,Y,Z és T szabadságfokok előírt koordinátái fokban kifejezve.
3.4. Pályatervezés A pályatervezés a robotkar térbeli mozgásának megtervezése, az előírt mozgás meghatározása. Két féle robotmozgást különböztetünk meg: •
Ponttól pontig (Point To Point) mozgás: a robotkar eljuttatása a kezdőpontból
a végpontba oly módon, hogy a robotkar köztes állapotai nem fontosak, csupán az, hogy a robotkar véges időn belül eljusson az előírt pozícióba. Ilyen mozgás alapján működik az általam is implementált PD+F szabályozás, melyet terjedelmi korlátok miatt nem ismertetek. Ilyen szabályozást használok a robotarchitektúra csuklónkénti tesztelésénél. •
Pályakövetés: a cél ugyancsak a végpont elérése oly módon, hogy a
kezdőpont és végpont között minden időpillanatban előírom a robot kívánt pozícióját, sebességét, gyorsulását.
4. ábra. A pályatervező algoritmus helye a robotirányítási rendszerben Az előírt pozíció mellet meg kell adnunk az előírt sebességet és gyorsulást is a mozgás minden időpillanatában. Ez az előírt pozíció első- illetve másodrendű deriváltja lesz, tehát az előírt pozíciónak kétszeresen deriválható időfüggvénynek kell lennie[8]. x = x(t ) v = v (t ) = x& (t ) a = a (t ) = &x&(t )
18
Ha ezt a három időfüggvényt mintavételezzük egy Ts mintavételi periódussal, három pontsorozatot nyerünk a három időfüggvényből. Az általam készített pályatervező algoritmus Ts = 15ms mintavételi periódussal dolgozik. A fejlesztett rendszer a pályatervezést csuklókoordinátákra végzi, ami azt jelenti, hogy közvetlenül a robotkar csuklóit vezérlő motorok pályáját írjuk elő. Ennek előnye, hogy kis számítási költséggel jár, valamint a maximális sebesség és gyorsulás könnyen meghatározható a beavatkozó adatlapjából. Hátránya viszont, hogy a munkatérben két pont közötti mozgás nem prediktálható, ami ütközésveszéllyel jár. A pályatervező algoritmus által kiszámolt pontsorozat lesz az irányítási algoritmus bemenete.
3.4.1. Polinomiális pályatervezés A pályatervezést egy adott csuklóra mutatom be, az algoritmus mind a négy szabadságfokra ugyanaz. Adottak: x 0 – kezdeti pozíció, az illető csukló vezérlés előtti pozíciója x f – végpozíció, amit a MOVE_TO paranccsal az illető csuklónak megfelelő
paraméterrel lehet beállítani
v MAX – a csukló felhasználó által beállított maximális sebessége a MAX – a csukló felhasználó által beállított maximális gyorsulása Feladat: Határozzuk meg
x d (t ), v d (t ), a d (t )
időfüggvényeket oly módon, hogy
használjuk ki a maximális sebességet és a maximális gyorsulást. Mennyi idő alatt érkezik meg a csukló a végpozícióba? Legyen:
t1 – a mozgás első fázisának vége t 2 – a mozgás második fázisának vége t f – a csukló végpozícióba való megérkezésének időpontja, a mozgás vége
19
5. ábra. Pályatervezés I.A. esetben
6. ábra. Pályatervezés II.A. esetben
Két fő esetet különböztetünk meg: I. 2 x 0 − x f > 2 x (t1 ) Ebben az esetben az x 0 és x f pontok közti távolság elegendő ahhoz, hogy elérjük a v MAX maximális sebességet. Két alesetet különböztetünk meg: A. x f > x 0 , azaz a kezdeti pozíció a végpozíció alatt van. Lásd (5.ábra) A mozgást három szakaszra bonthatjuk: i) t < t 1 , a gyorsulás pozitív a (t ) = λ1 v(t ) = λ 2 t + λ3
(1)
x(t ) = λ 4 t 2 + λ5 t + λ6
A mozgás kezdetén a gyorsulás maximális mindaddig, amíg el nem érjük a maximális sebességet. Ez a t 1 pillanatban történik meg. A λi , i = 1,6 értékeket a következő módon határozzuk meg:
a (t1 ) = a MAX = λ1 v(0) = 0 = λ3 v&(t ) = λ2 = a(t ) = a MAX ⇒ λ2 = a MAX x(0) = λ6 = x0
x& (t ) = 2λ4 t + λ5 = v(t ) = a MAX t ∀t < t1 ⇒ λ4 =
a MAX , λ5 = 0 2
Az (1)-be behelyettesítve a meghatározott λi , i = 1,6 értékeket kapjuk, hogy
20
a(t ) = a MAX v(t ) = a MAX t x(t ) =
(2)
a MAX 2 t + x0 2
Mivel a t1 -ben elérjük a maximális sebességet, ezért írhatjuk, hogy
v(t1 ) = a MAX t1 = v MAX ⇒ t1 =
v MAX a MAX
ii) t1 ≤ t < t 2 , a sebesség konstans a (t ) = 0 v(t ) = v MAX x(t ) = v MAX (t − t1 ) + t2 =
2 v MAX + x0 (3) 2a MAX
x f − x0 v MAX
iii) t 2 ≤ t ≤ t f , a gyorsulás negatív a(t ) = − a MAX v(t ) = −a MAX (t − t 2 ) + v MAX 2 a MAX v MAX 2 (t − t 2 ) + v MAX (t − t 2 ) + x f − x(t ) = − 2 2a MAX
t f = t2 +
(4)
v MAX a MAX
B. x f < x 0 , azaz a kezdeti pozíció a végpozíció felett van
i) t < t 1 , a gyorsulás negatív a(t ) = −a MAX v(t ) = −a MAX t x(t ) = − t1 =
a MAX 2 t + x0 2
(5)
v MAX a MAX
ii) t1 ≤ t < t 2 , a sebesség konstans a(t ) = 0 v(t ) = −v MAX x(t ) = −v MAX (t − t1 ) − t2 =
2 v MAX + x0 2a MAX
(6)
x0 − x f v MAX 21
iii) t 2 ≤ t ≤ t f , a gyorsulás pozitív a(t ) = a MAX v(t ) = a MAX (t − t 2 ) − v MAX x(t ) =
a MAX v2 (t − t 2 ) 2 − v MAX (t − t 2 ) + x f + MAX 2 2a MAX
t f = t2 +
(7)
v MAX a MAX
II. 2 x 0 − x f < 2 x (t1 ) .
Ebben az esetben az x 0 és x f pontok közti távolság nem elegendő ahhoz, hogy elérjük a
v MAX maximális sebességet. Két alesetet különböztetünk meg: A. x f > x 0 , azaz a kezdeti pozíció a végpozíció alatt van. Lásd (6.ábra)
i) t < t 1 , a gyorsulás pozitív
a ( t ) = a MAX v ( t ) = a MAX t x (t ) = t1 =
a MAX t 2 + x0 2 x f − x0
(8)
a MAX
ii) t1 ≤ t ≤ t f , a gyorsulás negatív a(t ) = − a MAX v(t ) = − a MAX (t − t1 ) + a MAX x(t ) = −
a MAX (t − t1 ) 2 + a MAX 2
x f − x0 a MAX x f − x0 a MAX
(t − t1 ) +
x f + x0
(9)
2
x f − x0
tf = 2
a MAX
B. x f < x 0 , azaz a kezdeti pozíció a végpozíció felett van
i) t < t 1 , a gyorsulás negatív a(t ) = −a MAX v(t ) = −a MAX t a MAX 2 t + x0 2 x0 − x f
x(t ) = − t1 =
(10)
a MAX 22
ii) t1 ≤ t ≤ t f , a gyorsulás pozitív a(t ) = a MAX v(t ) = a MAX (t − t1 ) − a MAX x(t ) = tf = 2
x0 − x f a MAX
a MAX (t − t1 ) 2 − a MAX 2
x0 − x f a MAX
(t − t1 ) +
x f + x0
(11)
2
x0 − x f a MAX
A fenti pályatervezési algoritmust mind a négy szabadságfok x 0 és x f koordinátájára el kell végezni. Az így kapott (2), (3), (4), (5), (6), (7), (8), (9), (10), (11) időfüggvényeket Ts mintavételi periódussal mintavételezni kell. Az algoritmus kimente három pontsorozat: •
Pozíció: xr [i] , ahol i = 0, n − 1,
•
Sebesség: vr [i] , ahol i = 0, n − 1,
•
Gyorsulás: a r [i ] , ahol i = 0, n − 1,
⎡t f ⎤ n=⎢ ⎥ ⎣ Ts ⎦ ⎡t f ⎤ n=⎢ ⎥ ⎣ Ts ⎦ ⎡t f ⎤ n=⎢ ⎥, ⎣ Ts ⎦
ahol [] az egész részt jelenti. Ez a három pontsorozat egy adott csukló esetében az irányítási algoritmus bemenete. Könnyen belátható, hogy az így tervezett pálya időben optimális.
3.5. Összetett hibametrikán alapuló pályakövető szabályozás Az irányítási algoritmus feladata a bemenet alapján meghatározni a hardware-re kiküldendő vezérlőjelet. A szabályzás bemenete a pályatervező algoritmus által generált pontsorozat, valamint az érzékelők által a robot valós paramétereiről szolgáltatott információ. Az irányítási algoritmus ezek alapján számolja ki külön-külön az aktuális mintavételben a szabadságfokoknak megfelelő motorokra kiküldendő feszültségszintet, valamint a motorok forgási irányát. Legyen •
xr [i][k ] az i. mintavételben a k. csukló pályatervezési algoritmus által
kiszámolt, előírt pozíciója •
vr [i ][k ] az i. mintavételben a k. csukló pályatervezési algoritmus által
kiszámolt, előírt sebessége
23
•
a r [i][k ] az i. mintavételben a k. csukló pályatervezési algoritmus által
kiszámolt, előírt gyorsulása •
x[i ][ k ] az i. mintavételben a k. csukló valós pozíciója
•
v[i ][ k ] az i. mintavételben a k. csukló valós sebessége
•
a[i ][ k ] az i. mintavételben a k. csukló valós gyorsulása
Algoritmus: 1. lépés: Meghatározom x[i ][ k ] , v[i ][k ] értékeket
Mind a négy motorra egy-egy 500 beosztással rendelkező inkrementális adó van szerelve. Az inkrementális adó által generált impulzussorozat egy számláló bemenete. Minden mintavételben kiolvasom a számláló tartalmát, majd a számláló tovább számol. A motorok maximális sebessége valamint az inkrementális adó beosztásszáma nem teszi lehetővé a számláló többszöri túlcsordulását, ezért az i. mintavételben a k. motor frekvenciája az alábbi módon írható: ci ,k − ci −1, k ⎧ , ha ci ,k ≥ ci −1,k ⎪ Ts ⎪ , ahol freq[i ][k ] = ⎨ c k MAX + ci ,k − ci −1,k ⎪ , ha ci ,k < ci −1,k ⎪⎩ Ts ci ,k – a k. számláló tartalma az i. mintavételben ci −1, k – a k. számláló tartalma az (i-1). mintavételben c k MAX – a k. számláló maximális értéke. Jelen esetben c k MAX = 65535
A frekvencia segítségével számolható a motorok sebessége: v[i ][k ] =
360 freq[i ][k ] 500
fok s
A motorok pozíciója: x[i ][k ] = x[i − 1][ k ] + Ts
v[i ][k ] + v[i − 1][k ] 2
2. lépés: Meghatározom minden motor vezérlőjelét
Legyen S [i ][k ] = v[i ][k ] − v r [i ][k ] + λ k ( x[i ][k ] − x r [i ][k ]) hibafüggvény, ahol λ k kifejezi, hogy a k. motornál mennyire fontos a pozícióhiba. Az i. mintavételben a k. motorra a vezérlőjel a következőképpen számolható: u[i ][k ] =
1 ⋅ (a r [i, k ] − λ k ⋅ (v[i ][k ] − v r [i ][ k ]) − S ⋅ Ks k + Kv k ⋅ v[i ][ k ]) , ahol Jk
J k – a k. motorra csatolt terhelés tehetetlenségi nyomatéka Ks k – a szabályozó erősítése
24
Kv k – a k. motor elektromotoros állandója 3. lépés: Mivel minden motornál létezik a Coulomb súrlódás, ezért a vezérlőjelet kompenzálni
kell azzal a küszöbfeszültséggel, ahol a motor álló helyzetből elkezd forogni. Nevezzük ezt a küszöbfeszültséget offszet feszültségnek. Ez az érték motoronként változik, az általam használt motoroknál [1100,1300] mV-os tartományban található. Az offszet feszültséget figyelembe véve a vezérlőjel a következő: ⎧⎪u[i ][k ] + Vkoffset , ha u[i ][k ] > 0 , ahol u[i ][k ] = ⎨ ⎪⎩u[i ][k ] − Vkoffset , ha u[i ][k ] < 0
Vkoffset a k. motor offszet feszültsége. 4. lépés: Szaturáció. Annak elkerülése végett, hogy egy motorra se kerüljön túl nagy feszültség,
[
]
a kimenő vezérlőjelet korlátozni kell. A vezérlőjel csak − u k MAX ;+u k MAX tartományból vehet fel értékeket.
⎧− u k MAX , ha u[i][k ] < −u k MAX u[i][k ] = ⎨ ⎩ u k MAX , ha u[i][k ] > u k MAX Az általam használt motoroknál u k MAX = 5000mV , k = 1,4 . 5. lépés: Vezérlőjel kiküldése 6. lépés: Számlálóérték, frekvencia, pozíció, sebesség elmentése.
ci −1,k = ci ,k freq[i − 1][k ] = freq[i ][k ] v[i − 1][k ] = v[i ][k ] x[i − 1][k ] = x[i ][k ]
⎡t f ⎤ 7. lépés: vissza az 1. lépéshez mindaddig amíg i ≤ ⎢ ⎥ , azaz van még elem a pályatervező ⎣ Ts ⎦ algoritmus által meghatározott pontsorozatban.
25
3.6. Use case diagram A use case diagram szemlélteti a rendszer funkcionális működését, felhasználó (Programmer) által igénybe vehető rendszerfunkciókat.
7. ábra. A rendszer usecase diagramja
26
3.7. Osztálydiagram Az osztálydiagram bemutatja, hogy a rendszer 5 fő komponensét hogyan tervezhetjük meg osztályokra lebontva az objektumorientált paradigma alapján.
8. ábra. A rendszer osztálydiagramja
3.8. Kollaborációs diagram A kollaborációs diagram szemlélteti a rendszer egyes komponensei közötti funkcionális kapcsolatokat.
9. ábra. A rendszer kollaborációs diagramja 27
3.9. Szekvencia diagram A szekvencia diagram a rendszer időbeni funkcionális működését szemlélteti.
10. ábra. A rendszer szekvencia diagramja
4. Következtetések 4.1 Felhasznált technológiák A rendszer főként C# nyelven íródott Microsoft Visual Studio .NET 2003 környezetben .NET 1.1-es technológiát felhasználva Microsoft Windows XP operációs rendszer alatt. Az Advantech PCI 1780-as és Advantceh PCI 1723-as kártyák driverének burkoló osztályát (AdvantechDriver) Managed C++-ban írtam. A lexikális elemzőt az általam leírt reguláris kifejezések és az egyes reguláris kifejezésnek megfelelő programkód alapján a külső Flex eszközzel hoztam létre.
28
4.2 Mérési eredmények Az általam fejlesztett rendszer a felhasználó számára lehetővé teszi egy négy szabadságfokú robotarchitektúra magasabb szintű irányítását. A felhasználónak arra kell koncentrálnia, hogy mit szeretne elérni és nem arra, hogy hogyan szeretné. Láttuk, hogyan épül fel egy ilyen rendszer, melyek a fő komponensei, hogyan képződik le a robotprogramozási nyelven megírt program alacsony szintű irányítássá. Mivel a rendszert Windows platformon fejlesztettem, ezért figyelmet kell fordítani az időzítések kérdésére. Köztudott, hogy multitasking operációs rendszereknél hiába állítunk be egy időzítési értéket, az operációs rendszer nem biztosítja ezen érték pontos betartását. Az időzítés pontossága függ a processzor terheltségétől, azon szál prioritásától, melyen az időzítés található (ez lehet akár a főszál is), a beütemezett, futtatható, azonos prioritású szálak számától valamint magától a processzor gyorsaságától. Egyprocesszoros rendszerekben az azonos prioritású szálak azonos processzoridő-szeleteket kapnak. Ez az időszelet a Windows XP esetében 10ms nagyságrendű. Mivel a fejlesztett alkalmazásban fontos az időzítés, ezért méréseket végeztem a mintavételi periódus optimális megválasztása céljából. A mérést egy Athlon XP 1600+ processzoron végeztem. A cél: megállapítani, hogy egy 10ms-os időzítő milyen pontossággal tartható különböző prioritású szálakon. A mérés a processzor 100%-os terhelése mellett folyt. Az eredmények összefoglalását a (3. táblázat) tartalmazza. Minden esetben 1000 mérésből számolt mérési eredmény került a táblázatba a következő képlet alapján: valós idődőzítési idő =
szál futási ideje 1000
Az időzítést tartalmazó szál 1000 időzítést hajt végre. Két időzítés közti várt idő 10ms. 3. táblázat
Valós időzítési értékek 10ms-os időzítés esetében a processzor 100%-os terhelése mellett Szál prioritási szintje
Valós időzítés 10ms esetében
alacsony
45ms
normál alatti
43ms
normál
39ms
normál fölötti
34ms
magas
27ms
29
A processzor 50%-os terhelésére számítva és a robotvezérlést végző szál magas prioritású szintre emelésével a rendszer mintavételi periódusát 15ms-ban határoztam meg. Pontos időzítés valós idejű operációs rendszer, vagy időzítő áramkör segítségével oldható meg. A továbbiakban a négy szabadságfokon végzett méréseket mutatok be. Hasonló grafikonok a rendszer használata során a felhasználó által is elérhetőek, bár ezen grafikonok fő célja a hibaellenőrzés és szabályozási paraméterek minél pontosabb hangolása. Minden robotvezérlési program grafikusan szemléltethető. A robotarchitektúrákban a motorok áttételen keresztül hajtják meg a csuklókat. Legyen az áttételi arány η k . Az egyes csuklók pozíciójának pontossága
ε=
max(ek )
ηk
, ahol
k = 1,4 a csukló sorszáma
max(ek ) –a k. csukló pozícióhibájának maximuma a szabályozás során
11. ábra.
12. ábra.
A pozícióhiba változása az
A pozícióhiba változása a
első szabadságfokra
második szabadságfokra
13. ábra.
14. ábra.
A pozícióhiba változása a
A pozícióhiba változása a
harmadik szabadságfokra
negyedik szabadságfokra 30
15 ábra. Példa a rendszer által megtervezett összetett pályára
16 ábra. 3 csukló pozícióváltozása adott robotirányítási program esetében
31
5. Irodalmi jegyzék [1]
WAHL, F. M.–THOMAS, U. 2002. Robot Programming - From Simple Moves to Complex Robot Tasks. Institute for Robotics and Process Control Technical University of Braunschweig. http://www.rob.cs.tu-bs.de/content/03-research/03publications/download/uth_2002_05_workshop_sfb_b4.pdf Megtekintve: 2008.03.25
[2]
http://en.wikipedia.org/wiki/Variable_Assembly_Language Megtekintve: 2008.04.05
[3]
http://www.ipab.inf.ed.ac.uk/ARG/ Megtekintve: 2008.04.05
[4]
http://www.etl.go.jp/~matsui/eus/ Megtekintve: 2008.04.01
[5]
CSÖRNYEI Zoltán–KÁSA Zoltán 2007. Formális nyelvek és fordítóprogramok. Kolozsvári Egyetemi Kiadó. Babeş-Bolyai Tudományegyetem
[6]
CSÖRNYEI Zoltán 2006. Frodítóprogramok. Typotex. Budapest
[7]
CSÖRNYEI Zoltán 2002. Frodítási algoritmusok. Erdélyi Tankönyvtanács. Kolozsvár
[8]
LEWIS, Frank L.–DAWSON, Darren M.–ABDALLAH, Chaouki T. 2004. Robot Manipulator Control. Marcel Dekker. Inc., NY
[9]
LIEBERMAN, Lawrence I. – WESLEY, Wesley A. 1977. AUTOPASS: An Automatic Programming System for Computer Controlled Mechanical Assembly. IBM Journal of Research and Development. New York. http://www.research.ibm.com/journal/rd/214/ibmrd2104D.pdf Megtekintve: 2008.05.09
[10]
http://en.wikipedia.org/wiki/Karel_%28programming_language%29 32
Megtekintve: 2008.05.10 [11]
http://de.wikipedia.org/wiki/Minisprache Megtekintve: 2008.05.10
[12]
CSÁKI Tibor 2006. Robottechnika előadásvázlat. Miskolci Egyetem, Szerszámgépek Tanszék. http://www.szgt.uni-miskolc.hu/~csaki/robot.pdf Megtekintve: 2008.05.09
[13]
http://opetus.stadia.fi/koneautomaatiolaboratorio/robotit/BAPS_plus_En.pdf Megtekintve: 2008.05.10
[14]
CSÖRNYEI Zoltán 2005. Fordítóprogramok elemzési algoritmusai. Informatikai algoritmusok II, 20. fejezet. ELTE Eötvös Kiadó. Budapest. http://www.ms.sapientia.ro/~kinga/www/pages/komp/csornyei.pdf Megtekintve: 2008.05.11
[15]
http://flex.sourceforge.net/ Megtekintve: 2008.05.11
33
