| RCML ( Robot Control Meta Language ) Metajazyk pro roboty | |
|---|---|
| Jazyková třída | procesní |
| Typ provedení | sestaven |
| Objevil se v | 2014 |
| Autor | Technologie řízení robotů |
| Přípona souboru | .rcml |
| Uvolnění | 1.0.6 (18. 12. 2015) |
| Typový systém | staticky slabé |
| ovlivnil | Jazyk pro sestavení robota |
| webová stránka | Oficiální stránky vývojáře |
RCML ( Robot Control M eta L jazyk , vyslovováno [ ar -si-em-el ] je na vysoké úrovni kompilovaný staticky typovaný programovací jazyk . Navržený tak, aby získal stejný výsledek bez ohledu na provedení robota [1] . Umožňuje vytvořit podmínky pro spolupráci práce několika robotů Používá se k popisu akcí robota nebo skupiny robotů [2] .Zahrnuje řadu vizuálních aspektů prezentace kódu ve vztahu ke třídám a objektům z programovacích jazyků, které implementují paradigma objektově orientovaného programování [3] .
Syntaxe RCML je blízká programovacím jazykům C , Java a JavaScript . Syntaktická podobnost je nezbytná pro zajištění snadného přechodu pro programátory z jiných jazyků [4] .
RCML se zaměřuje na robotiku a má jako programovací jazyk spíše skrovnou složku, protože není určen k vytváření univerzálního aplikačního softwaru a je zaměřen na interakci s robotikou, což umožňuje v tomto ohledu dosahovat nových výsledků.
Robot v RCML je prezentován jako druh výkonného zdroje, který může být použit k provedení konkrétního úkolu (funkce) a poté uvolněn k opětovné aktivaci, ale například v jiném úkolu.
Modul robota poskytuje prostředí RCML popis k němu přiřazené třídy robota , předpokládá se, že lokálně v objektovém světě, kde se používá RCML, může být k jednomu modulu robota přiřazen jeden nebo více robotů stejné třídy. Navíc v prostředí RCML v rámci robotického modulu existují dva klíčové typy objektů, podle obrázku:
Je třeba poznamenat, že může být připojeno mnoho tříd robotů současně, to znamená mnoho modulů robotů, a každý z nich může poskytnout přístup k několika robotům své třídy najednou. Roboti ve stejné třídě musí být zcela identičtí, a to jak ve fyzické reprezentaci, tak ve funkční reprezentaci.
Robotické moduly zaujímají v RCML jednu z klíčových pozic, protože právě přes ně probíhá komunikace a přenos příkazů fyzickému robotu.
Modul robota je zodpovědný za předávání příkazů z interpretu RCML jednomu nebo více robotům stejné třídy (nebo typu), které jsou seskupeny pod tímto modulem. Pro každou třídu nebo typ robota se doporučuje používat samostatný modul. Interpret RCML prostřednictvím deklarovaného API naváže spojení s modulem robota, který zase naváže spojení s každým robotem, který je mu přiřazen. Prostřednictvím modulu robota je tak implementace komunikace a ovládání robota skryta před interpretem, což vám umožňuje připojit k němu různé roboty.
Prostřednictvím funkčních modulů je možné do RCML přidávat nové funkce, které není vhodné nebo nemožné implementovat v tomto jazyce, například jakékoli složité výpočty. Funkční moduly tak prostřednictvím samostatného API umožňují implementovat propojení RCML se softwarem jiných výrobců.
Řídicí moduly slouží k propojení různých řídicích zařízení s prostředím RCML za účelem využití těchto zařízení při ručním ovládání robotů, jejichž moduly takovou možnost poskytují. Tento typ modulu je podobný robotickým modulům v tom smyslu, že prostřednictvím daného API se přerušují závislosti mezi řídicím zařízením a robotem. Je tedy možné ovládat stejného robota různými zařízeními, stejně jako možnost použití stejného ovládacího zařízení pro různé roboty. Samozřejmě se tím dosáhne stejného efektu skrytí implementace komunikace řídicího zařízení z prostředí RCML a je dosaženo možnosti připojení široké škály řídicích zařízení.
Chcete-li robota v programu používat, musíte zadat jeho třídu a funkci, kterou musí vykonávat. Pojmenování třídy robota je stejné jako pojmenování modulu robota v souboru config.ini, ale třída robota v programu RCML musí být specifikována pomocí klíčového slova robot a podtržítka.
Například musíte zavolat robota z testovacího modulu, pak bude označení jeho třídy vypadat takto:
robot_test
Po splnění názvu třídy robota v textu programu odešle RCML požadavek na příslušný modul robota a zastaví provádění programu, dokud nebude nalezen volný robot požadované třídy.
Funkce robota jsou programovány vývojářem robota spolu s modulem robota a jsou popsány v dokumentaci modulu robota.
Volání funkce je vizuálně podobné volání objektové metody v programovacích jazycích podobných C. Následuje třída robota, pak je požadovaná funkce označena znakem ukazatele , ->v závorkách ( )je pak uveden seznam argumentů této funkce .
Syntaxe volání funkce robota:
robot_класс_робота->функция_робота(аргументы);
Příklad volání funkce do_something z modulu testovacího robotaNapříklad z robota testovací třídy musíte zavolat funkci do_something s jedním argumentem 1000:
robot_test->do_something(1000);
Při setkání s takovou konstrukcí si tlumočník zarezervuje robota zadané třídy, počká, až se zapojí skutečný fyzický robot, a poté dá reprezentaci robota pokyn, aby provedla zadanou funkci se zadanými parametry. Po provedení funkce bude robot automaticky uvolněn a převeden do volného stavu.
Je třeba poznamenat, že při takové indikaci volání funkce robota bude interpret čekat na potvrzení provedení funkce z reprezentace robota a teprve poté bude pokračovat ve vykonávání zbytku programu.
Často je nutné volat ne jednu funkci robota, ale několik najednou a jeden robot je musí provést jako danou sekvenci akcí. Pokud zavoláte požadovanou sekvenci funkcí, pak v přítomnosti několika robotů stejné třídy je pravděpodobné, že zadané funkce budou provádět různé roboty. Pokud existuje pouze jeden robot dané třídy, pak pro každou funkci bude pokaždé aktivován a uvolněn.
Nejúčinnější a nejracionálnější je použít robota jednou a posílat mu příkazy podle potřeby a poté jej uvolnit, čímž dojde k realizaci robotické relace. K tomu je potřeba použít robota požadované třídy a zapamatovat si spojení s konkrétním zapojeným robotem. To lze provést uložením robota do speciálního typu proměnné , kterému musí předcházet symbol @. Například aktivace třídního robota testa uložení odkazu na konkrétní instanci přijaté v proměnné @r:
@r = robot_test;
Chcete-li zavolat funkci na daném zúčastněném robotu, musíte funkci zavolat přístupem k dané proměnné, nikoli k třídě robota. Například volání použitého robota stejné funkce do_somethings parametry:
@r->do_something(1000);
Po provedení funkce zůstane robot také aktivní a v této instanci můžete volat další funkci.
Robot uložený ve variabilním typu @lze v případě deletepotřeby uvolnit pomocí speciálního operátora. Tento příkaz musí být doprovázen speciální proměnnou, která ukládá ukazatel na robota, který má být uvolněn. Příklad uvolnění robota, jehož ukazatel byl dříve přiřazen k proměnné @r:
delete @r;
Všichni roboti, kteří jsou zapojeni a nejsou uvolněni prostřednictvím prohlášení delete, budou uvolněni až poté, co skončí funkce, do které byli zapojeni. Toto prohlášení se nevztahuje na funkce robota napsané v RCML, protože tyto funkce běží v kontextu instance robota a nelze je vyvolat instancí robota.
Jednou z funkcí RCML je automatický výběr robota pro úkol. Chcete-li použít tuto funkci, musíte místo konkrétní třídy robota zadat pouze klíčové slovo robot na těch místech, kde je třeba zadat třídu robota: volání funkcí robota nebo přiřazení robota k proměnné. Například:
robot -> něco udělat ( 1000 ); @ r = robot ; @r - > něco udělat ();Použití pouze klíčového slova namísto plně kvalifikovaného názvu třídy robota bude od nynějška robotoznačováno jako abstraktní robot.
V případě použití speciální proměnné @pro komunikaci s abstraktním robotem RCML analyzuje každé volání funkce s ohledem na tuto proměnnou a sestaví seznam kandidátů pouze z těch typů robotů, které mají všechny volatelné funkce s ohledem na tuto proměnnou.
Funkce napsané v RCML lze provádět ve dvou hlavních režimech:
Pokud je funkce vykonávána „bez čekání“, lze vytvořené vlákno pomocí nástrojů OS přenést do samostatného výpočetního jádra a dosáhnout tak efektu paralelního provádění RCML kódu.
Ve výchozím nastavení jsou všechny funkce volány v režimu čekání na provedení funkce. Tento režim je výchozím režimem.
Existuje několik způsobů, jak změnit režim provádění funkcí:Program využívá dva roboty. V tomto případě jsou roboty reprezentovány testovacím modulem, který simuluje práci abstraktního robota.
Ve výchozím nastavení režim provádění funkcí čeká.
funkce main() { @rt_1=test_robota; @rt_2=test_robota; @rt_1->udělej_něco(1000); @rt_2->print("Ahoj světe!\n", 0); }V důsledku provedení programu testovací robot @rt_1provede funkci do_somethinga teprve poté se aktivuje druhý robot @rt_2, který zobrazí řetězec na obrazovce Hello world!.
Pokud však příznak použijete bez čekání ~a předáte jej funkci provedené prvním robotem @rt_1.
funkce main() { @rt_1=test_robota; @rt_2=test_robota; ~@rt_1->udělej něco(1000); @rt_2->print("Ahoj světe!\n", 0); }Program poběží následovně. Po předání příkazu dojde @rt_1k dalšímu provádění programu. Testovací robot mezitím @rt_2zobrazí Hello world!a poté @rt_1dokončí funkci.
RCML umožňuje zpracování výjimek podobným způsobem jako programovací jazyky C , Java a JavaScript .
V RCML však operátor trymůže převzít parametry, které naznačují, jak by to mělo fungovat. Prvním parametrem je řetězcová konstanta udávající provozní režim, v závislosti na zadaném režimu lze zadat druhý parametr reálného datového typu.
Celkem má operátor trytři provozní režimy:
Přestože operátor trymůže přebírat parametry, není to funkce a nevrací hodnotu.
Příklad použití uvedených režimůPříklad použití těchto režimů ke zpracování úspěšnosti robota vykonávajícího svou funkci, přičemž má tři pokusy s časovým limitem 2 sekund pro každý:
function main () { try ( "error_try_count" , 3 ) { zkuste ( " error_time_limit " , 2000 ) { robot -> něco udělat (); } catch { //pokud vypršel čas throw ; //pak vyvolá výjimku, aby se vyčerpával pokus } } chytit { //tento blok bude proveden, když budou vyčerpány všechny pokusy, //a výsledek nebude přijat } }Prostřednictvím operátora throws výjimkou můžete předat hodnotu výjimky.
Prostředí RCML může poskytnout možnost ručního ovládání konkrétní instance robota prostřednictvím konkrétního řídicího zařízení voláním systémové funkce hand_controls příslušnými parametry.
Hlavním principem prostředí RCML při přepnutí do režimu ručního ovládání je propojit osy robota, po kterých se může nějak pohybovat, s osami ovládacího zařízení, podél kterých toto zařízení může opravovat změny.
Na obrázku je pásový robot (vyobrazený vlevo), který se může pohybovat do své nové absolutní polohy v rovině řadou změn své polohy podél dvou os: osa pohybu R(dopředu nebo vzad) a osa rotace A(doleva nebo doprava). A existuje jednoduché ovládací zařízení typu joystick (zobrazeno vpravo), které se může v rovině odchýlit ze své výchozí polohy podél dvou os Xa Y. V souladu s tím je prostřednictvím RCML možné propojit osy joysticku a robota tak, že vychýlení joysticku vede k pohybu robota. Například pohyb joysticku podél osy Yv kladném směru vedl k pohybu vpřed a odchylka joysticku podél osy Xv záporném směru způsobila, že se robot otočil doleva. Předpokládejme, že tento robot je v prostředí RCML reprezentován modulem robota parrota joystickem řídicím modulem joy, pak bude kód RCML pro jejich připojení v režimu ručního ovládání k získání efektu znázorněného v příkladu následující:
@ r = robot_tarakan ; hand_control ( @r , „ radost “ , „ R “ , „ Y “ , „ A “ , „ X “ ) ;Pohled robota v prostředí RCML má frontu příkazů , která se plní příkazy voláním funkcí robota z kódu RCML. Když příkaz dorazí do prázdné fronty, příkaz bude předán robotovi k provedení. Během provádění prvního příkazu jsou všechny nově přijaté příkazy zařazeny do fronty. Robot vykonává funkci v hmotném světě, obvykle pomaleji, než RCML interpret zvládne provést další RCML kód a dosáhnout dalšího volání funkce robota, tzn. obvykle jsou akce robota „pomalejší“ než akce výpočetního procesoru.
Existuje však i jiná situace, kdy robot potřebuje provést sérii rychlých pohybů bez zastavení a výpočet parametrů těchto pohybů zabere více času, než je pohyb vykonán. Pak je efektivnější předem vypočítat parametry pohybu a rovnou poslat robotovi balíček příkazů s vypočtenými parametry, aby robot nezpomalil při čekání na další příkaz. Existují situace, kdy je samotný mechanismus volání funkcí pomalejší, než robot provádí příkazy, a dochází ke zpoždění v rychlé sérii pohybů.
Pro kompenzaci tohoto efektu byl zaveden mechanismus pro dávkový přenos příkazů do robota. Příkazy přijaté voláním funkcí robota lze sbalit a předat jako celek reprezentaci robota. Chcete-li odeslat příkaz do dávky, před volání funkce uveďte symbol >. Chcete-li odeslat dávku k provedení, musíte zavolat systémovou funkci send_package().
Příklad odeslání příkazu v dávce //odeslat příkaz do balíčku >test_robota->udělej něco(1000); //odeslání balíčku ke spuštění system.send_package();V tomto příkladu bude nejprve odeslán požadavek na bezplatného robota třídy testa teprve když bude robot nalezen, bude funkce předána balíčku a poté bude balíček odeslán. Stejně jako při volání funkcí robota jsou při odesílání příkazů v dávkách předem rezervováni vykonavatelé robotů. Po zavolání funkce je send_packagemožné vytvořit nový balíček, a to i bez čekání na provedení předchozího balíčku pomocí ~příznaku provádění funkce.
Je možné vytvořit balíček pro dva roboty najednou, příkazy z tohoto balíčku se přenesou do dvou reprezentací robotů najednou, navíc můžete kombinovat typy volání funkcí.
Příklad sestavení balíčku příkazů pro dva roboty > test_robota -> něco udělat ( 1000 ); > test_robota -> něco udělat ( 1000 ); systém . odeslat_balíček ();Podle tohoto příkladu budou aktivováni dva roboti současně a ne tentýž dvakrát za sebou. V tomto případě začne provádění prvních příkazů ve frontě každé reprezentace robota současně. Tento mechanismus umožňuje synchronizovat začátek provádění jejich příkazů různými roboty.
Nejjednodušší program RCML vypadá takto:
function main () { vrátit se ; }Program se ihned po spuštění ukončí.
Prostřednictvím testovacího modulu robota zadejte do konzole řetězec „ Ahoj světe! “.
function main () { robot_test -> print ( "Ahoj světe! \n " , 0 ); }Jak již bylo zmíněno dříve, RCML je zaměřeno na práci s poolem (setem) robotů, z nichž jsou alokováni exekutoři pro řešení dynamicky vznikajících úkolů.
Nechť existuje skupina robotů , někteří roboti z této skupiny jsou schopni vykonávat požadovanou technologickou funkci do_something(). Potřeba provedení této funkce je určena nějakým externím senzorem, pak program pro dynamickou distribuci úloh pro provádění této funkce bude vypadat takto:
function main () { smyčka { have_new_task = get_data_from_sensor (); if ( have_new_task ) { ~ robot -> něco udělat (); } systém . spánek ( 300 ); } }V tomto programu je v cyklu s intervalem 300 ms dotazován externí senzor pomocí funkce get_data_from_sensor(), řádek 3. Pokud bude nutné funkci provést, pak bude první volný robot z bazénu schopný provést funkci aktivováno do_something(), řádek 5. V tomto případě program nebude čekat na provedení funkcí robotem, protože je nastaven příznak pro provedení funkce bez čekání ~. To umožní programu nezpomalit, když robot vykonává svou funkci, a pokračovat v dotazování senzoru v určeném intervalu.
Pokud je po dalších 300 ms potřeba funkci provést znovu a první zúčastněný robot ještě nedokončil svou práci, pak RCML aktivuje druhého robota z bazénu a tak dále. Po dokončení zadané funkce budou roboti automaticky uvolněni a vráceni do společného fondu. Pokud jsou zapojeni všichni roboti, program počká na uvolnění robota.
Tato technika vám umožňuje dynamicky rozdělovat úkoly z fronty mezi roboty a používat několik robotů najednou.
Předpokládejme, že je úkolem přesunout díly o hmotnosti od 1 do 15 kg, díly dorazí postupně, ale musí se přesunout co nejrychleji. Existuje skupina různých typů robotů, mezi nimiž jsou roboti s robot_heavyvyšší užitečnou hmotností (do 10 kg) a robot_lightnižší užitečnou hmotností (do 5 kg). Současně robot_heavyposune součást za 10 sekund a robot_lightza 5 sekund. Úlohy prováděné roboty jsou tedy parametrizovány a na základě dostupného parametru (hmotnosti dílu) je nutné učinit co nejracionálnější rozhodnutí, jaký typ robota použít, aby byly zajištěny minimální prostoje a maximální produktivitu webu. Abychom v tomto příkladu ukázali použití příkazových balíků, předpokládejme, že součást o hmotnosti více než 10 kg mohou nést dva roboti současně.
function main () { smyčka { detail_weight = get_weight_from_sensor (); //Získejte hmotnost součásti if ( detail_weight < 5 ) { //Pokud je hmotnost do 5 kg ~ robot -> move_detail (); //Můžete použít jakéhokoli robota } if (( detail_weight >= 5 ) && ( detail_weight < 10 )) { //Pokud je hmotnost mezi 5 a 10 kg ~ robot_heavy -> move_detail (); //Můžete použít pouze větší zvedací robot } if ( detail_weight >= 10 ) { //Pokud je hmotnost od 10 kg > robot_heavy -> move_detail (); //Jeden robot musí být nosnější > robot -> move_detail (); //Druhý robot může být cokoli ~ systém . odeslat_balíček (); //Odeslání balíčku příkazů pro roboty, které mají být provedeny } systém . spánek ( 300 ); } }Je-li hmotnost dílu menší než 5 kg, pak díl může nést robot libovolné třídy, řádek 5. RCML však nejprve vyzve všechny roboty dané třídy robot_lighta pokud mezi nimi nejsou žádní volní roboti, pak budou roboti dané třídy dotazováni robot_heavy(Priorita tříd dotazovacích robotů je nastavena v konfiguračním RCML interpretu). První volný robot bude použit k pohybu, podobně jako v předchozím příkladu, aniž by se čekalo, až hlavní program vykoná robotem svou funkci – pohyb součásti. RCML se tedy nejprve pokusí aktivovat robota nejvhodnější třídy robot_light, a pokud není volný robot této třídy, bude použit robot méně vhodné třídy, robot_heavyaby se zabránilo prodlevě.
Pokud je však hmotnost dílu od 5 do 10 kg, lze použít pouze větší zvedací robot, řada 7.
Pokud je hmotnost dílu od 10 kg, musí být zapojeni dva roboti, z nichž jeden musí být více zvedací a druhý libovolný. Je třeba poznamenat, že v tomto případě je příkaz k přesunutí součásti předán dvěma robotům současně prostřednictvím mechanismu pro kompilaci příkazových paketů (řádky 11-15).
Je třeba poznamenat, že tento příklad předpokládá, že díly přicházejí přísně sekvenčně, tzn. další díl dorazí, až když robot vezme ten předchozí a nějakou dobu ho nese. Fronta úloh pro roboty je tedy také sekvenční a pokud dorazí několik těžkých dílů a poté lehký, lehký díl se přesune pouze tehdy, když byly přesunuty všechny těžké díly, z tohoto důvodu jsou možné roboty nečinné třídy robot_light.
Zkomplikujme předchozí příklad. Nechte díly náhodně vstoupit do určitého kontejneru, systém počítačového vidění kontejner pozoruje a rozpozná díly v něm, obdrží souřadnice a typ dílu a určí jeho hmotnost podle typu. Při rozpoznávání dalšího dílu je potřeba nastavit robotům úkol, aby díl přesunuli. Při rozpoznávání dílů určitá funkce get_new_detail_index()vrátí unikátní index rozpoznaného dílu, ze kterého později získáte souřadnice a váhu dílu nutné pro rozhodnutí o zapojení robotů a pohybu, resp.
function executeMoveTask ( detail_index ) { detail_weight = get_weight_by_index ( detail_index ); //Získejte hmotnost součásti detail_coords = get_coords_by_index ( detail_index ); if ( detail_weight < 5 ) { //Pokud je hmotnost do 5 kg ~ robot -> move_detail ( detail_coords ); //Můžete použít jakéhokoli robota } if (( detail_weight >= 5 ) && ( detail_weight < 10 )) { //Pokud je hmotnost mezi 5 a 10 kg ~ robot_heavy -> move_detail ( detail_coords ); //Můžete použít pouze větší zvedací robot } if ( detail_weight >= 10 ) { //Pokud je hmotnost od 10 kg > robot_heavy -> move_detail ( detail_coords ); //Jeden robot musí být nosnější > robot -> move_detail ( detail_coords ); //Druhý robot může být cokoli ~ systém . odeslat_balíček (); //Odeslání balíčku příkazů pro roboty, které mají být provedeny } } function main () { smyčka { new_detail_index = get_new_detail_index (); //Získání indexu další části if ( new_detail_index ) { // Přišel nový díl ~ vykonatMoveTask ( new_detail_index ); //Proveďte úlohu přesunu } systém . spánek ( 300 ); } }V tomto příkladu, když do kontejneru dorazí nový díl, získá se jeho jedinečný index (řádek 19), který bude předán funkci executeMoveTask(řádek 21), ve které jsou roboti aktivováni, tzn. ve skutečnosti jde o vytváření požadavků na skupinu robotů. Za zmínku stojí, že tato funkce se volá s příznakem no wait ~.
V součtu to dává následující efekt: pokud do kontejneru vstoupilo velké množství těžkých dílů o hmotnosti do 10 kg a všechny zvedací roboty byly použity ze skupiny volných robotů robot_heavy, a poté určité množství lehkých dílů o hmotnosti do 5 kg vstoupilo do kontejneru, pak bude RCML moci používat dříve nečinné roboty třídy, robot_lightnež roboti třídy robot_heavypřesunou všechny těžké díly. Přesunutím aktivace robota na samostatnou funkci, která se provádí bez čekání, jsme ve skutečnosti získali možnost tvořit různé fronty úkolů pro různé třídy robotů. Tím se minimalizují prostoje robotů, pokud existují pro ně vhodné úlohy, což v předchozím příkladu při striktním pořadí úloh nebylo možné.
RCML umožňuje programátorovi explicitně specifikovat, že někteří roboti mohou vykonávat stejnou funkci stejným způsobem, a proto je lze považovat za zaměnitelné při provádění této funkce, ačkoli roboti mají na úrovni RCML poskytnuto programátorovi odlišné API .
Ve výše uvedených příkladech jsou řádky formuláře robot->move_detail(), používající klíčové slovo robot. Toto klíčové slovo říká RCML, že k provedení této funkce může být použit jakýkoli robot z fondu, který má požadovanou funkci move_detail().
Nechte třídy robotů robot_heavymít robot_lightsadu funkcí pro ovládání uchopení a pohybu uchopení, ale funkce v těchto sadách mají různé názvy a různé parametry.
Následující příklad ukazuje, jak sjednotit API robota v rámci konkrétního programu, aby různé třídy robotů mohly vykonávat stejnou funkci.
function robot_heavy::move_to ( x , y , z , w , p , r ) { //Další je kód pro přesun do daného bodu, //voláním funkcí specifických pro roboty třídy robot_heavy 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-specifický řídicí kód zachycení if ( s ) { robot -> set_gripper_pos ( 124 , 25 ); } jinak { robot -> set_gripper_pos ( 350 , 50 ); } } function robot_light::move_to ( x , y , z , w , p , r ) { //Kód pohybu chapadla specifického pro robota robot -> move_to ( x , y , z ); robot -> nastavit_uhel ( w , p , r ); } function robot_light::gripper ( s ) { // Řídicí kód zachycení specifický pro Robot_light if ( s ) { robot -> pump_on (); } jinak { robot -> pump_off (); } } function main () { //Univerzální kód pro pohyb součásti robotem libovolné třídy robot -> move_to ( 46 , 76 , 73 , 235 , -34 , 23 ); //Přesun na obrobek robot -> chapadlo ( 1 ); // Uchopte část robot -> move_to ( 235 , 34 , 47 , 262 , 673 , 74 ); //Přesuňte díl na pozici 1 systém . spánek ( 15000 ); //Počkejte na dobu měření dílu na pozici 1 if ( some_check ()) { //Přesuňte rukojeť robota ke kontejneru s kvalitními díly robot -> move_to ( 35 , 63 , 23 , 25 , -48 , 245 ); robot -> chapadlo ( 0 ); //Uvolněte část } jinak { //Přesuňte rukojeť robota ke kontejneru se šrotem robot -> move_to ( 568 , 778 , 346 , -54 , 2 , 34 ); robot -> chapadlo ( 0 ); //Uvolněte část } }V tomto případě bude algoritmus pohybu a kontroly schopen provést robot_heavytřídu robota i třídu robota robot_light, ačkoli mají na úrovni RCML k dispozici různá rozhraní API .
| Programovací jazyky | |
|---|---|
| |