| RCML ( Robot Control Meta Language ) Metanyelv robotok számára | |
|---|---|
| Nyelvóra | eljárási |
| A végrehajtás típusa | összeállított |
| Megjelent | 2014 |
| Szerző | Robotvezérlési technológiák |
| Fájlkiterjesztés _ | .rcml |
| Kiadás | 1.0.6 (2015.12.18.) |
| Típusrendszer | statikus gyenge |
| befolyásolta | Robotépítési nyelv |
| Weboldal | A fejlesztő hivatalos weboldala |
Az RCML ( Robot Control M eta L Anguage , ejtsd: [ ar -si-em-el ] egy magas szinten lefordított statikusan tipizált programozási nyelv . Úgy tervezték, hogy a robot végrehajtásától függetlenül ugyanazt az eredményt kapja [1] . Lehetővé teszi a feltételek megteremtése több robot együttműködési munkájához Egy robot vagy robotok csoportja műveleteinek leírására szolgál [2] . Tartalmazza a kód bemutatásának számos vizuális aspektusát olyan programozási nyelvekből származó osztályokkal és objektumokkal kapcsolatban, amelyek megvalósítják. az objektum-orientált programozási paradigma [3] .
Az RCML szintaxis közel áll a C , Java és JavaScript programozási nyelvekhez . A szintaktikai hasonlóság szükséges ahhoz, hogy a programozók könnyen áttérhessenek más nyelvekről [4] .
Az RCML a robotikára összpontosít, és programozási nyelvként meglehetősen csekély komponenssel rendelkezik, mivel nem célja általános célú alkalmazási szoftverek létrehozása, és a robotikával való interakcióra irányul, lehetővé téve ezzel kapcsolatban új eredmények elérését.
Az RCML-ben egy robot egyfajta végrehajtó erőforrásként jelenik meg, amely egy adott feladat (funkció) elvégzésére használható, majd újraaktiválható, de például egy másik feladatban.
A robotmodul az RCML környezetet a hozzá rendelt robotosztály leírásával látja el, feltételezve, hogy lokálisan abban az objektumvilágban, ahol az RCML-t használják, egy vagy több azonos osztályú robot lehet egy robotmodulhoz hozzárendelve. Sőt, az RCML környezetben, a robotmodul keretein belül, két kulcsfontosságú objektumtípus létezik, az ábrának megfelelően:
Megjegyzendő, hogy egyidejűleg sok robotosztály csatlakoztatható, azaz sok robotmodul, és mindegyik egyszerre több osztályába tartozó robothoz is hozzáférést biztosíthat. Az azonos osztályba tartozó robotoknak teljesen azonosaknak kell lenniük mind a fizikai, mind a funkcionális ábrázolásban.
A robotmodulok foglalják el az egyik kulcspozíciót az RCML-ben, mivel rajtuk keresztül történik a kommunikáció és a parancsok továbbítása egy fizikai robot felé.
A robotmodul felelős azért, hogy az RCML értelmezőtől a parancsokat átadja egy vagy több azonos osztályú (vagy típusú) robotnak, amelyek e modul alá vannak csoportosítva. Minden osztályhoz vagy robottípushoz külön modul használata javasolt. Az RCML értelmező a deklarált API -n keresztül kapcsolatot létesít a robotmodullal, amely viszont kapcsolatot létesít minden hozzárendelt robottal. Így a robotmodulon keresztül a kommunikáció és a robot vezérlésének megvalósítása el van rejtve a tolmács elől, ami lehetővé teszi különféle robotok csatlakoztatását.
A függvénymodulokon keresztül lehetőség nyílik olyan új funkciók hozzáadására az RCML-hez, amelyeket ezen a nyelven nem célszerű vagy lehetetlen megvalósítani, például bonyolult számításokat. Így egy külön API -n keresztül a funkciómodulok lehetővé teszik az RCML összekapcsolását más gyártók szoftvereivel.
Vezérlőmodulok segítségével különféle vezérlőeszközöket kapcsolnak össze az RCML környezettel, hogy ezeket az eszközöket a robotok kézi vezérlésében felhasználhassák, amelyek moduljai erre lehetőséget adnak. Ez a típusú modul hasonlít a robotmodulokhoz abban az értelemben, hogy egy adott API -n keresztül a függőségek megszakadnak a vezérlőeszköz és a robot között. Így lehetséges ugyanazt a robotot különböző eszközökkel vezérelni, valamint lehetőség nyílik ugyanazt a vezérlőeszközt különböző robotokhoz használni. Természetesen ez ugyanazt a hatást éri el, mint a vezérlőeszköz kommunikációs megvalósításának elrejtése az RCML környezet elől, és elérhető a sokféle vezérlőeszköz csatlakoztatásának képessége.
A robot programban való használatához meg kell adni az osztályát és a funkciót, amelyet végre kell hajtania. A robot osztály elnevezése megegyezik a robot modul elnevezésével a config.ini fájlban, de egy RCML programban a robot osztályt a robot kulcsszó és aláhúzás segítségével kell megadni.
Például meg kell hívni a robotot a tesztmodulból, akkor az osztályának jelzése így fog kinézni:
robot_test
Miután a programszövegben találkozott a robotosztály nevével, az RCML kérést küld a megfelelő robotmodulnak, és leállítja a program végrehajtását, amíg meg nem találja a kívánt osztályba tartozó szabad robotot.
A robotfunkciókat a robot fejlesztője programozza a robotmodullal együtt, és leírásuk a robotmodul dokumentációjában található.
Egy függvény hívása vizuálisan hasonlít egy objektum metódus meghívásához C-szerű programozási nyelvekben . Következik a robot osztálya, majd a mutatójelen keresztül megjelenik a kívánt függvény , majd ->zárójelben ( )megjelenik a függvény argumentumlistája .
Robot függvényhívás szintaxisa:
robot_класс_робота->функция_робота(аргументы);
Példa a do_something függvény meghívására a tesztrobot modulbólPéldául a tesztosztályú robotból meg kell hívnia a do_something függvényt egy 1000-es argumentummal:
robot_test->do_something(1000);
Ha egy ilyen konstrukcióval találkozik, az értelmező lefoglal egy adott osztályba tartozó robotot, megvárja, amíg valódi fizikai robot kerül bevonásra, majd utasítja a robotreprezentációt a megadott függvény végrehajtására a megadott paraméterekkel. A funkció végrehajtása után a robot automatikusan elenged és szabad állapotba kerül.
Megjegyzendő, hogy a robot függvény meghívásának ilyen jelzése esetén az értelmező megvárja a funkció végrehajtásának megerősítését a robot reprezentációjából, és csak ezután folytatja a program többi részének végrehajtását.
Gyakran nem a robot egy funkcióját kell meghívni, hanem egyszerre több funkciót, és ezeket egy robotnak adott műveletsorként kell végrehajtania. Ha meghívja a szükséges függvénysorozatot, akkor több azonos osztályba tartozó robot jelenlétében valószínű, hogy a megadott funkciókat különböző robotok hajtják végre. Ha egy adott osztályból csak egy robot van, akkor minden egyes funkciónál az aktiválódik és minden alkalommal elenged.
A leghatékonyabb és legracionálisabb, ha a robotot egyszer használjuk, és szükség szerint parancsokat küldünk neki, majd elengedjük, ezzel megvalósítva a robot munkamenetet. Ehhez a kívánt osztályba tartozó robotot kell használni, és emlékezni kell a kapcsolatra az adott robottal. Ezt úgy tehetjük meg, hogy a robotot egy speciális változótípusban tároljuk , amelyet egy szimbólumnak kell megelőznie @. Például egy osztályrobot aktiválása testés egy változóban kapott egy adott példányra mutató hivatkozás tárolása @r:
@r = robot_test;
Egy adott érintett robot függvényének meghívásához a függvényt az adott változóhoz, nem pedig a robotosztályhoz kell hozzáférni. Például a használt robot hívása azonos funkcióval do_somethingparaméterekkel:
@r->do_something(1000);
A funkció végrehajtása után a robot is aktív marad, és ezen a példányon hívhatja meg a következő függvényt.
A változó típusban tárolt robot szükség @esetén speciális kezelővel deletekiengedhető. Ezt az utasítást egy speciális változónak kell kísérnie, amely a felszabadítandó robotra mutató mutatót tárol. Példa egy olyan robot felszabadítására, amelynek mutatója korábban egy változóhoz volt rendelve @r:
delete @r;
Az összes olyan robot, amely érintett és nem került kiadásra a nyilatkozaton keresztül delete, csak akkor kerül kiadásra, ha az a funkció, amelyben részt vettek, véget ér. Ez az állítás nem vonatkozik az RCML-ben írt robotfüggvényekre, mert ezek a funkciók egy robotpéldány kontextusában futnak, és nem hívhatók meg egy robotpéldány által.
Az RCML egyik jellemzője a robot automatikus kiválasztása egy feladathoz. A funkció használatához csak a robot kulcsszót kell megadni egy adott robotosztály helyett azokon a helyeken, ahol robotosztályt kell megadni: robotfüggvények hívása vagy robot hozzárendelése egy változóhoz. Például:
robot -> do_something ( 1000 ); @ r = robot ; @r - > csinál_valamit ();robotA teljes minősítésű robotosztálynév helyett csak a kulcsszó használatát mostantól absztrakt robotnak nevezzük.
Absztrakt robottal való kommunikációhoz speciális változó használata esetén az @RCML minden függvényhívást e változó alapján elemzi, és csak azokból a robottípusokból állít össze jelöltlistát, amelyek minden hívható funkcióval rendelkeznek ehhez a változóhoz képest.
Az RCML-ben írt függvények két fő módban hajthatók végre:
Ha a függvényt "várakozás nélkül" hajtjuk végre, akkor a létrehozott szál az OS eszközök segítségével átvihető egy külön számítási magba , és így az RCML kód párhuzamos végrehajtásának hatása érhető el.
Alapértelmezés szerint az összes függvény függőben lévő függvény-végrehajtási módban kerül meghívásra. Ez a mód az alapértelmezett mód.
A függvények végrehajtási módja többféleképpen módosítható:A program két robotot használ. Ebben az esetben a robotokat egy tesztmodul képviseli, amely egy absztrakt robot munkáját szimulálja.
Alapértelmezés szerint a függvények végrehajtási módja vár.
function main() { @rt_1=robot_teszt; @rt_2=robot_teszt; @rt_1->csinál_valamit(1000); @rt_2->print("Helló világ!\n", 0); }A program végrehajtása eredményeként a tesztrobot @rt_1végrehajtja a funkciót do_something, és csak ezután aktiválódik a második robot @rt_2, amely megjeleníti a képernyőn a karakterláncot Hello world!.
Ha azonban várakozás nélkül használja a zászlót, ~és átadja az első robot által végrehajtott függvénynek @rt_1.
function main() { @rt_1=robot_teszt; @rt_2=robot_teszt; ~@rt_1->csinál_valamit(1000); @rt_2->print("Helló világ!\n", 0); }A program a következőképpen fog futni. A parancs átadása után a @rt_1program további végrehajtása következik be. A tesztrobot eközben @rt_2megjeleníti Hello world!, majd @rt_1befejezi a funkciót.
Az RCML a C , Java és JavaScript programozási nyelvekhez hasonló módon teszi lehetővé a kivételkezelést .
Az RCML-ben azonban az operátor tryolyan paramétereket vehet fel, amelyek jelzik, hogyan kell működnie. Az első paraméter a működési módot jelző karakterlánc-konstans, a megadott módtól függően egy valós adattípus második paramétere adható meg.
A kezelőnek összesen tryhárom üzemmódja van:
Bár egy operátor tryvehet paramétereket, ez nem függvény, és nem ad vissza értéket.
Példa a megadott módok használatáraPélda arra, hogy ezekkel a módokkal dolgozza fel a feladatát teljesítő robot sikerességét, három kísérletet adva neki 2 másodperces időkorláttal:
function fő () { try ( "error_try_count" , 3 ) { try ( " error_time_limit " , 2000 ) { robot -> do_something (); } catch { //ha az idő múlott dobás ; //majd dobjon egy kivételt, hogy kimerítse a próbálkozást } } catch { //ez a blokk akkor kerül végrehajtásra, ha minden próbálkozás kimerült, //és az eredmény nem érkezett meg } }A throwkivételes operátoron keresztül adhatja át a kivétel értékét.
Az RCML környezet lehetővé teheti egy adott robotpéldány manuális vezérlését egy adott vezérlőeszközön keresztül hand_controla megfelelő paraméterekkel rendelkező rendszerfunkció meghívásával.
Az RCML környezet fő elve a kézi vezérlési módba váltáskor az, hogy a robot tengelyeit, amelyek mentén valamilyen módon el tud mozogni, összekapcsolja a vezérlőeszköz tengelyeivel, amelyek mentén ez az eszköz rögzíteni tudja a változásokat.
RAz ábrán egy lánctalpas robot látható (a bal oldalon), amely két tengely mentén, a mozgási tengelyen (előre vagy hátra) és a mozgási tengely mentén tud elmozdulni új abszolút pozíciójába a síkon . forgatás A(balra vagy jobbra). És van egy egyszerű joystick típusú vezérlőeszköz (jobbra látható), amely a síkban eltérhet a kiindulási helyzetétől a két tengely Xés a tengely mentén Y. Ennek megfelelően az RCML-en keresztül lehetőség van a joystick és a robot tengelyeinek összekapcsolására úgy, hogy a joystick elhajlása a robot mozgásához vezessen. Például a joystick tengely mentén Ypozitív irányba történő mozgatása előremozgáshoz vezetett, a joystick tengely mentén Xtörténő negatív irányú eltérése pedig a robot balra fordulását okozta. Tegyük fel, hogy ezt a robotot az RCML környezetben a robotmodul parrot, a joystick pedig a vezérlőmodul képviseli joy, akkor a példában látható hatás elérése érdekében manuális vezérlési módban történő csatlakoztatásukhoz tartozó RCML kód a következő lesz:
@ r = robot_tarakan ; hand_control ( @ r , " öröm " , " R " , " Y " , " A " , " X " );Az RCML-környezet robotnézetében van egy parancssor , amely a robotfüggvények RCML-kódból történő meghívásával van tele parancsokkal. Amikor egy parancs üres sorban érkezik, a parancs végrehajtásra átkerül a robothoz. Az első parancs végrehajtása közben az összes újonnan kapott parancs sorba kerül. A robot egy funkciót hajt végre az anyagi világban, általában lassabban, mint ahogy az RCML értelmezőnek sikerül végrehajtania a következő RCML kódot és elérni a következő robot függvényhívást, azaz. általában a robot cselekvései "lassabbak", mint a számítási processzoré.
Van azonban egy másik helyzet is, amikor a robotnak egy sor gyors mozdulatot kell végrehajtania megállás nélkül, és ezeknek a mozgásoknak a paramétereinek kiszámítása több időt vesz igénybe, mint a mozdulat végrehajtása. Ekkor hatékonyabb előre kiszámítani a mozgási paramétereket, és azonnal elküldeni a robotnak egy parancscsomagot a kiszámított paraméterekkel, hogy a robot ne lassítson le a következő parancsra várva. Vannak helyzetek, amikor maga a függvényhívási mechanizmus lassabb, mint ahogy a robot végrehajtja a parancsokat, és egy gyors mozdulatsor késik.
Ennek a hatásnak a kompenzálására egy mechanizmust vezettek be a parancsok kötegelt továbbítására a robot felé. A robotfüggvények meghívásával kapott parancsok csomagolhatók és egy egészben továbbíthatók a robotreprezentációnak. Ha parancsot szeretne küldeni egy kötegnek, előzze meg a függvényhívást a szimbólummal >. A köteg végrehajtásra való elküldéséhez meg kell hívnia a rendszerfüggvényt send_package().
Példa egy parancs kötegben történő küldésére //parancs küldése a csomagnak >robot_teszt->csinál_valamit(1000); //a csomag végrehajtásra küldése system.send_package();Ebben a példában először egy osztály ingyenes robotjára vonatkozó kérés kerül elküldésre test, és csak a robot megtalálásakor kerül átadásra a függvény a csomagnak, majd a csomag elküldésre kerül. Akárcsak a robotfunkciók hívásakor, a parancsok kötegelt küldésekor a robot végrehajtóit előre lefoglalják. A függvény meghívása után send_packagelehetőség van új csomag létrehozására, beleértve az előző csomag végrehajtásának megvárását ~a függvényvégrehajtási jelző használatával.
Egyszerre két robotra is lehet csomagot készíteni, ebből a csomagból a parancsok egyszerre két robotreprezentációba kerülnek át, ezen kívül kombinálható a függvényhívások típusa is.
Példa egy parancscsomag összeállítására két robot számára > robot_test -> do_something ( 1000 ); > robot_test -> do_something ( 1000 ); rendszer . küld_csomag ();A példa szerint egyszerre két robot lesz aktiválva, és nem ugyanazt kétszer egymás után. Ebben az esetben a robot egyes reprezentációinak sorában az első parancsok végrehajtása egyszerre kezdődik meg. Ez a mechanizmus lehetővé teszi, hogy szinkronizálja a különböző robotok parancsainak végrehajtásának kezdetét.
A legegyszerűbb RCML program így néz ki:
function fő () { visszatérés ; }A program indítás után azonnal kilép.
A tesztrobot modulon keresztül adja ki a konzolra a " Hello world! " karakterláncot.
function fő () { robot_teszt -> print ( "Hello world! \n " , 0 ); }Mint korábban említettük, az RCML a robotok készletével (halmazával) való munkavégzésre összpontosít, amelyből a végrehajtókat osztják ki a dinamikusan felmerülő feladatok megoldására.
Legyen egy robotkészlet, ebből a készletből néhány robot képes ellátni a szükséges technológiai funkciót do_something(). A funkció végrehajtásának szükségességét valamilyen külső érzékelő határozza meg, majd a feladat végrehajtásához szükséges dinamikus elosztási program így fog kinézni:
function fő () { hurok { have_new_task = get_data_from_sensor (); if ( van_új_feladat ) { ~ robot -> do_something (); } rendszer . alvás ( 300 ); } }Ebben a programban egy 300 ms-os ciklusban egy külső érzékelő lekérdezése a get_data_from_sensor()3. sor funkcióval történik. Ha szükségessé válik a funkció végrehajtása, akkor a készletből az első szabad robot, amely képes a funkció végrehajtására. aktiválva do_something(), 5. sor. Ebben az esetben a program nem várja meg, hogy a robot végrehajtsa a függvényeket, mert a funkció várakozás nélküli végrehajtásának jelzője be van állítva ~. Ez lehetővé teszi, hogy a program ne lassuljon le, amíg a robot teljesíti a feladatát, és meghatározott időközönként folytatja az érzékelő lekérdezését.
Ha a következő 300 ms után a funkciót újra végre kell hajtani, és az első érintett robot még nem fejezte be a munkáját, akkor az RCML aktiválja a második robotot a készletből, és így tovább. A megadott funkció befejezése után a robotok automatikusan felszabadulnak, és visszakerülnek a közös medencébe. Ha az összes robot érintett, akkor a program megvárja a robot elengedését.
Ez a technika lehetővé teszi a feladatok dinamikus elosztását a sorból a robotok között, és több robot használatát egyszerre.
Tegyük fel, hogy 1-15 kg tömegű alkatrészek mozgatására van szükség , az alkatrészek egymás után érkeznek, de a lehető leggyorsabban el kell őket mozgatni. Különböző típusú robotok állnak rendelkezésre, köztük nagyobbrobot_heavy (10 kg-ig) és robot_lightkisebb (5 kg-ig) terhelhető robotok. Ugyanakkor robot_heavy10 másodperc alatt mozgatja az alkatrészt, és robot_light5 másodperc alatt. Így a robotok által elvégzett feladatok paraméterezve vannak, és a rendelkezésre álló paraméter (az alkatrész súlya) alapján kell a legracionálisabb döntést hozni arról, hogy milyen típusú robotot használjunk, hogy a minimális állásidő és maximális legyen. az oldal termelékenysége. A parancscsomagok használatának bemutatásához ebben a példában tegyük fel, hogy egy 10 kg-nál nagyobb alkatrészt egyszerre két robot is képes szállítani.
function fő () { hurok { részletek_súly = get_weight_from_sensor (); //Keresse ki az alkatrész súlyát if ( részlet_súly < 5 ) { //Ha a súly legfeljebb 5 kg ~ robot -> move_detail (); //Bármilyen robotot használhatsz } if (( részletek_súlya >= 5 ) && ( részletek_súlya < 10 )) { //Ha a súly 5 és 10 kg között van ~ robot_heavy -> move_detail (); //Csak nagyobb emelőrobotot használhat } if ( detail_weight >= 10 ) { //Ha a súly 10 kg-tól származik > robot_heavy -> move_detail (); //Egy robotnak nagyobb teherbírásúnak kell lennie > robot -> move_detail (); //A második robot bármi lehet ~ rendszer . küld_csomag (); //Parancscsomag küldése a végrehajtandó robotoknak } rendszer . alvás ( 300 ); } }Ha az alkatrész súlya 5 kg-nál kisebb, akkor az alkatrészt bármelyik osztályba tartozó robot szállíthatja, 5. sor. Azonban az RCML először lekérdezi az osztály összes robotját, robot_lightés ha nincs köztük szabad robot, akkor az osztály robotjai lekérdezésre kerülnek robot_heavy(A lekérdező robotosztályok prioritása a konfigurációs RCML értelmezőben van beállítva). Az elsõ szabad robottal az elõzõ példához hasonlóan mozogni fogunk anélkül, hogy megvárnánk, hogy a fõprogram a robot által teljesítse a funkcióját - mozgassa az alkatrészt. Így az RCML először a legmegfelelőbb osztályba tartozó robotot próbálja meg aktiválni robot_light, és ha ebből az osztályból nincs szabad robot, akkor egy kevésbé megfelelő osztályba tartozó robotot használnak robot_heavyaz üresjáratok megelőzésére.
Ha azonban az alkatrész súlya 5-10 kg, akkor csak nagyobb emelőrobot használható, 7. sor.
Ha az alkatrész súlya 10 kg-tól van, akkor két robotot kell bevonni, amelyek közül az egyiknek nagyobbnak kell lennie, a másodiknak pedig bármilyen. Meg kell jegyezni, hogy ebben az esetben az alkatrész mozgatására vonatkozó parancsot egyidejűleg két robotnak továbbítják a parancscsomagok összeállítására szolgáló mechanizmuson keresztül (11-15. sorok).
Megjegyzendő, hogy ez a példa azt feltételezi, hogy az alkatrészek szigorúan egymás után érkeznek, pl. a következő rész csak akkor érkezik, ha a robot elvette az előzőt és egy ideig viszi. Így a robotok munkasora is szekvenciális, és ha több nehéz alkatrész érkezik, majd egy könnyű, akkor a könnyű rész csak akkor kerül áthelyezésre, ha az összes nehéz alkatrészt elmozdították, emiatt az üresjárati osztályú robotok lehetségesek robot_light.
Bonyolítsuk le az előző példát. Hagyja, hogy az alkatrészek véletlenszerűen kerüljenek egy adott tartályba, a látórendszer megfigyeli a tartályt, és felismeri a benne lévő alkatrészeket, megkapja az alkatrész koordinátáit és típusát, és típusonként meghatározza a súlyát. A következő alkatrész felismerésekor be kell állítani azt a feladatot, hogy a robotok mozgassák az alkatrészt. Az alkatrészek felismerésekor egy bizonyos függvény get_new_detail_index()a felismert alkatrész egyedi indexét adja vissza, amelyből később megkaphatja az alkatrész koordinátáit és súlyát, amely a robotok bevonásával, illetve a mozgással kapcsolatos döntés meghozatalához szükséges.
function executeMoveTask ( detail_index ) { részletek_súly = get_weight_by_index ( részletes_index ); //Keresse ki az alkatrész súlyát detail_coords = get_coords_by_index ( részletes_index ); if ( részlet_súly < 5 ) { //Ha a súly legfeljebb 5 kg ~ robot -> move_detail ( detail_coords ); //Bármilyen robotot használhatsz } if (( részletek_súlya >= 5 ) && ( részletek_súlya < 10 )) { //Ha a súly 5 és 10 kg között van ~ robot_heavy -> move_detail ( detail_coords ); //Csak nagyobb emelőrobotot használhat } if ( detail_weight >= 10 ) { //Ha a súly 10 kg-tól származik > robot_heavy -> move_detail ( detail_coords ); //Egy robotnak nagyobb teherbírásúnak kell lennie > robot -> move_detail ( detail_coords ); //A második robot bármi lehet ~ rendszer . küld_csomag (); //Parancscsomag küldése a végrehajtandó robotoknak } } function fő () { hurok { new_detail_index = get_new_detail_index (); //A következő részindex beszerzése if ( new_detail_index ) { // Új rész érkezett ~ executeMoveTask ( new_detail_index ); //Végezze el a mozgatási feladatot } rendszer . alvás ( 300 ); } }Ebben a példában, amikor egy új alkatrész érkezik a konténerbe, annak egyedi indexét kapjuk meg (19. sor), amelyet átadunk annak a függvénynek executeMoveTask(21. sor), amelyben a robotok aktiválódnak, pl. valójában a kérések kialakítása a robotok készletéhez. Külön figyelemre méltó, hogy ezt a függvényt a no wait jelzővel hívják meg ~.
Összegezve ez a következő hatást eredményezi: ha nagyszámú, legfeljebb 10 kg súlyú nehéz alkatrész került a konténerbe, és az összes emelőrobotot a szabad robotok készletéből használták robot_heavy, majd bizonyos mennyiségű, legfeljebb 5 súlyú könnyű alkatrészt kg került a konténerbe, akkor az RCML képes lesz használni a korábban tétlen osztályrobotokat, robot_lightmielőtt az osztályrobotok robot_heavyminden nehéz alkatrészt megmozgatnának. Azáltal, hogy a robot aktiválását egy külön funkcióba helyeztük át, amely várakozás nélkül történik, sőt, lehetőséget kaptunk arra, hogy különböző feladatsorokat alakítsunk ki a különböző robotosztályokhoz. Így a robotok állásideje, ha vannak rájuk alkalmas feladatok, minimalizálódik, ami az előző példában szigorú feladatsorrend mellett lehetetlen volt.
Az RCML lehetővé teszi a programozó számára, hogy kifejezetten megadja, hogy egyes robotok ugyanazt a funkciót ugyanúgy végrehajtsák, és így felcserélhetőnek tekinthetők e funkció végrehajtása során, bár a robotok más API -t kapnak a programozó számára RCML szinten.
A fenti példákban az űrlap sorai találhatók robot->move_detail()a kulcsszó használatával robot. Ez a kulcsszó azt mondja az RCML-nek, hogy a készlet bármely robotja, amely rendelkezik a kért funkcióval, használható ennek a funkciónak a végrehajtására move_detail().
Legyen a robotosztályoknak egy robot_heavyfunkciókészlete robot_lighta markolat és a markolat mozgásának vezérlésére, de ezekben a halmazokban a funkciók eltérő elnevezéssel és paraméterekkel rendelkeznek.
A következő példa bemutatja, hogyan lehet egyesíteni a robot API -t egy adott programon belül, hogy a robotok különböző osztályai végezhessék ugyanazt a funkciót.
function robot_heavy::move_to ( x , y , z , w , p , r ) { //Következő az adott pontra való mozgás kódja, //a robot_heavy osztályba tartozó robotokra jellemző függvények meghívásával robot -> set_real_di ( "x" , x ); robot -> set_real_di ( "y" , y ); robot -> set_real_di ( "z" , z ); robot -> set_real_di ( "w" , w ); robot -> set_real_di ( "p" , p ); robot -> set_real_di ( "r" , r ); robot -> go_position (); } function robot_heavy::gripper ( s ) { //Robot_heavy-specifikus rögzítési vezérlőkód if ( s ) { robot -> set_gripper_pos ( 124 , 25 ); } másik { robot -> set_gripper_pos ( 350 , 50 ); } } function robot_light::move_to ( x , y , z , w , p , r ) { //Robot_light-specifikus megfogó mozgási kód robot -> mozgat_to ( x , y , z ); robot -> set_angle ( w , p , r ); } function robot_light::gripper ( s ) { // Robot_light-specifikus rögzítési vezérlőkód if ( s ) { robot -> pump_on (); } másik { robot -> pump_off (); } } function fő () { //Univerzális kód egy alkatrész mozgatásához bármely osztályba tartozó robot által robot -> mozgat_to ( 46 , 76 , 73 , 235 , -34 , 23 ); //Mozgás a munkadarabra robot -> megfogó ( 1 ); // Fogja meg az alkatrészt robot -> mozgat_to ( 235 , 34 , 47 , 262 , 673 , 74 ); //Alkatrész áthelyezése az 1. pozícióba rendszer . alvás ( 15000 ); //Várja meg a részleges mérési időt az 1. pozícióban if ( some_check ()) { //A robot markolatát a minőségi alkatrészeket tartalmazó konténerre helyezzük robot -> mozgat_to ( 35 , 63 , 23 , 25 , -48 , 245 ); robot -> markoló ( 0 ); //Rész kiadása } másik { //Vigye a robot markolatát a hulladékkal együtt lévő tartályba robot -> mozgat_to ( 568 , 778 , 346 , -54 , 2 , 34 ); robot -> markoló ( 0 ); //Rész kiadása } }robot_heavyEbben az esetben a mozgatási és ellenőrzési algoritmus mind a robotosztályt, mind a robotosztályt képes végrehajtani robot_light, bár az RCML-szinten eltérő API -kkal rendelkeznek.
| Programozási nyelvek | |
|---|---|
| |