| RCML ( Robot Control Meta Language ) Metasprog til robotter | |
|---|---|
| Sprog klasse | proceduremæssige |
| Udførelsestype | kompileret |
| Dukkede op i | 2014 |
| Forfatter | Robotkontrolteknologier |
| Filtypenavn _ | .rcml |
| Frigøre | 1.0.6 (18/12/2015) |
| Type system | statisk svag |
| påvirket | Robotbyggesprog |
| Internet side | Udviklerens officielle hjemmeside |
RCML ( Robot Control M eta L anguage , udtales [ ar -si-em-el ] er et kompileret , statisk maskinskrevet programmeringssprog på højt niveau . Designet til at opnå det samme resultat uanset udførelse af robotten [1] . Giver dig mulighed for at skabe betingelser for samarbejde flere robotters arbejde Bruges til at beskrive en robots eller en gruppe af robotters handlinger [2] . Omfatter en række visuelle aspekter af præsentationen af kode i forhold til klasser og objekter fra programmeringssprog, der implementerer det objektorienterede programmeringsparadigme [3] .
RCML- syntaksen er tæt på programmeringssprogene C , Java og JavaScript . Syntaks-lighed er nødvendig for at sikre nem overgang for programmører fra andre sprog [4] .
RCML er fokuseret på robotteknologi og har en ret sparsom komponent som programmeringssprog, da det ikke er beregnet til at skabe generel applikationssoftware og er rettet mod at interagere med robotteknologi, hvilket gør det muligt at opnå nye resultater i denne henseende.
En robot i RCML præsenteres som en slags executive ressource, der kan bruges til at udføre en specifik opgave (funktion), og derefter frigives til genaktivering, men for eksempel i en anden opgave.
Robotmodulet forsyner RCML-miljøet med en beskrivelse af den robotklasse , der er tildelt det, det antages, at der lokalt i den objektverden, hvor RCML anvendes, kan være enten en eller flere robotter af samme klasse tildelt et robotmodul. Desuden er der i RCML-miljøet inden for rammerne af robotmodulet to nøgletyper af objekter i overensstemmelse med figuren:
Det skal bemærkes, at mange klasser af robotter kan forbindes på samme tid, det vil sige mange robotmoduler, og hver af dem kan give adgang til flere robotter af sin klasse på én gang. Robotter inden for samme klasse skal være fuldstændig identiske, både i den fysiske repræsentation og i den funktionelle.
Robotmoduler indtager en af nøglepositionerne i RCML, da det er gennem dem, at kommunikation og transmission af kommandoer til en fysisk robot udføres.
Robotmodulet er ansvarlig for at videregive kommandoer fra RCML-tolken til en eller flere robotter af samme klasse (eller type), som er grupperet under dette modul. Det anbefales at bruge et separat modul for hver klasse eller type robot. RCML-fortolkeren etablerer via det erklærede API en forbindelse med robotmodulet , som igen etablerer en forbindelse med hver robot, der er tildelt det. Gennem robotmodulet er implementeringen af kommunikation og styring af robotten således skjult for tolken, som giver dig mulighed for at forbinde en række robotter til den.
Gennem funktionsmoduler er det muligt at tilføje nye funktioner til RCML, som ikke er tilrådelige eller umulige at implementere på dette sprog, for eksempel eventuelle komplekse beregninger. Gennem en separat API giver funktionsmoduler dig således mulighed for at implementere forbindelsen af RCML med software fra andre producenter.
Styremoduler bruges til at forbinde forskellige styreenheder med RCML-miljøet for at bruge disse enheder til manuel styring af robotter, hvis moduler giver en sådan mulighed. Denne type modul ligner robotmoduler i den forstand, at gennem en given API brydes afhængigheder mellem styreenheden og robotten. Det er således muligt at styre den samme robot med forskellige enheder, samt muligheden for at bruge den samme styreenhed til forskellige robotter. Dette opnår naturligvis den samme effekt som at skjule kontrolenhedskommunikationsimplementeringen fra RCML-miljøet, og muligheden for at forbinde en lang række kontrolenheder opnås.
For at bruge robotten i programmet skal du angive dens klasse og den funktion, den skal udføre. Navngivningen af robotklassen er den samme som navngivningen af robotmodulet i filen config.ini, men robotklassen i et RCML-program skal angives ved hjælp af robotnøgleordet og en understregning.
For eksempel skal du ringe til robotten fra testmodulet, så vil indikationen af dens klasse se sådan ud:
robot_test
Efter at have opfyldt navnet på robotklassen i programteksten, sender RCML en anmodning til det tilsvarende robotmodul og stopper programafviklingen, indtil en ledig robot af den påkrævede klasse er fundet.
Robotfunktioner programmeres af robotudvikleren sammen med robotmodulet og er beskrevet i robotmoduldokumentationen.
Kaldning af en funktion svarer visuelt til at kalde en objektmetode i C-lignende programmeringssprog . Robottens klasse følger, derefter angives den påkrævede funktion gennem markørtegnet , derefter er listen over argumenter for denne funktion anført ->i parentes .( )
Syntaks for robotfunktionskald:
robot_класс_робота->функция_робота(аргументы);
Et eksempel på at kalde funktionen do_something fra testrobotmoduletFor eksempel skal du fra testklasserobotten kalde funktionen do_something med et argument 1000:
robot_test->do_something(1000);
Når tolken støder på en sådan konstruktion, vil tolken reservere en robot af den specificerede klasse, vente, indtil en rigtig fysisk robot er involveret, og derefter instruere robotrepræsentationen om at udføre den specificerede funktion med de specificerede parametre. Efter udførelse af funktionen frigives robotten automatisk og overføres til den frie status.
Det skal bemærkes, at med en sådan indikation af at kalde en robotfunktion, vil tolken vente på bekræftelse af udførelsen af funktionen fra repræsentationen af robotten og først derefter fortsætte udførelsen af resten af programmet.
Ofte er det nødvendigt at kalde ikke én funktion af robotten, men flere på én gang, og én robot skal udføre dem som en given rækkefølge af handlinger. Hvis du kalder den nødvendige sekvens af funktioner, er det sandsynligt, at de angivne funktioner udføres af forskellige robotter i nærværelse af flere robotter af samme klasse. Hvis der kun er én robot af en given klasse, vil den for hver funktion blive aktiveret og frigivet hver gang.
Det er mest effektivt og rationelt at bruge robotten én gang og sende kommandoer til den efter behov, og derefter slippe den og dermed realisere robotsessionen. For at gøre dette skal du bruge robotten i den ønskede klasse og huske forbindelsen med den specifikke robot, der er involveret. Dette kan gøres ved at opbevare robotten i en speciel variabeltype , som skal stå foran et symbol @. For eksempel aktivering af en klasserobot testog lagring af et link til en specifik instans modtaget i en variabel @r:
@r = robot_test;
For at kalde en funktion på en given involveret robot, skal du kalde funktionen ved at få adgang til den givne variabel, ikke robotklassen. For eksempel et kald til den brugte robot med samme funktion do_somethingmed parametre:
@r->do_something(1000);
Efter at have udført funktionen, vil robotten også forblive aktiv, og du kan kalde den næste funktion på denne instans.
En robot lagret i en variabel type @kan frigives ved hjælp af en speciel operatør, deletenår det er nødvendigt. Denne erklæring skal ledsages af en speciel variabel, der gemmer en pegepind til robotten, der skal frigøres. Et eksempel på frigørelse af en robot, hvis markør tidligere var tildelt en variabel @r:
delete @r;
Alle robotter, der er involveret og ikke frigivet via erklæringen delete, frigives først, når den funktion, de var involveret i, slutter. Denne erklæring gælder ikke robotfunktioner skrevet i RCML, fordi disse funktioner udføres i sammenhæng med en robotinstans og kan ikke påkaldes af en robotinstans.
En af funktionerne ved RCML er det automatiske valg af en robot til en opgave. For at bruge denne funktion skal du kun angive robotnøgleordet i stedet for en specifik robotklasse på de steder, hvor du skal angive en robotklasse: Kald til robotfunktioner eller tildeling af en robot til en variabel. For eksempel:
robot -> gør_noget ( 1000 ); @ r = robot ; @r - > gør_noget ();Brugen af kun nøgleordet roboti stedet for det fuldt kvalificerede robotklassenavn vil fra nu af blive omtalt som en abstrakt robot.
I tilfælde af at bruge en speciel variabel @til at kommunikere med en abstrakt robot, vil RCML analysere hvert funktionskald med hensyn til denne variabel og kompilere en liste over kandidater kun fra de typer robotter, der har alle kaldbare funktioner med hensyn til denne variabel.
Funktioner skrevet i RCML kan udføres i to hovedtilstande:
Hvis funktionen udføres "uden at vente", kan den oprettede tråd overføres til en separat computerkerne ved hjælp af OS -værktøjer , og dermed kan effekten af parallel eksekvering af RCML-kode opnås.
Som standard kaldes alle funktioner i afventende funktionsudførelsestilstand. Denne tilstand er standardtilstanden.
Der er flere måder at ændre udførelsen af funktioner på:Programmet bruger to robotter. I dette tilfælde er robotterne repræsenteret af et testmodul, der simulerer arbejdet i en abstrakt robot.
Som standard venter funktionernes udførelsestilstand.
funktion hoved() { @rt_1=robottest; @rt_2=robottest; @rt_1->gør_noget(1000); @rt_2->print("Hej verden!\n", 0); }Som et resultat af programafviklingen @rt_1vil testrobotten udføre funktionen do_something, og først derefter aktiveres den anden robot @rt_2, som viser strengen på skærmen Hello world!.
Men hvis du bruger flaget uden at vente ~og sender det til den funktion, der udføres af den første robot @rt_1.
funktion hoved() { @rt_1=robottest; @rt_2=robottest; ~@rt_1->gøre_noget(1000); @rt_2->print("Hej verden!\n", 0); }Programmet vil køre som følger. Efter kommandoen er bestået @rt_1, udføres yderligere programudførelse. Testrobotten vil i mellemtiden @rt_2vise Hello world!og derefter @rt_1fuldføre funktionen.
RCML tillader undtagelseshåndtering på en måde, der ligner programmeringssprogene C , Java og JavaScript .
Men i RCML kan en operatør trytage parametre, der angiver, hvordan det skal fungere. Den første parameter er en strengkonstant, der angiver driftstilstanden; afhængigt af den specificerede tilstand kan den anden parameter for en reel datatype specificeres.
I alt har operatøren trytre driftsformer:
Selvom operatøren trykan tage parametre, er det ikke en funktion og returnerer ikke en værdi.
Et eksempel på brug af de angivne tilstandeEt eksempel på at bruge disse tilstande til at behandle succesen med robotten, der udfører sin funktion, hvilket giver den tre forsøg med en tidsbegrænsning på 2 sekunder for hver:
funktion hoved () { prøv ( "error_try_count" , 3 ) { prøv ( " error_time_limit " , 2000 ) { robot -> gør_noget (); } catch { //hvis tiden er gået kaste ; //smid derefter en undtagelse for at udtømme forsøget } } fange { //denne blok vil blive udført, når alle forsøg er opbrugt, //og resultatet ikke er modtaget } }Gennem operatøren throwmed en undtagelse kan du videregive værdien af undtagelsen.
RCML-miljøet kan give mulighed for manuelt at styre en specifik robotinstans gennem en specifik kontrolenhed ved at kalde en systemfunktion hand_controlmed de relevante parametre.
Hovedprincippet i RCML-miljøet, når der skiftes til manuel kontroltilstand, er at forbinde robottens akser, langs hvilke den på en eller anden måde kan bevæge sig, med kontrolenhedens akser, langs hvilken denne enhed kan rette ændringer.
På figuren er der en sporrobot (afbildet til venstre), der kan bevæge sig til sin nye absolutte position på planet gennem en række ændringer i sin position langs to akser: bevægelsesaksen R(fremad eller tilbage) og aksen for rotation A(venstre eller højre). Og der er en simpel styreenhed af joystick-typen (vist til højre), som kan afvige i planet fra sin udgangsposition langs de to akser Xog Y. Derfor er det gennem RCML muligt at forbinde joystickets og robottens akser, så joystickets afbøjning fører til robottens bevægelse. For eksempel Yførte bevægelse af joysticket langs aksen i positiv retning til fremadgående bevægelse, og afvigelse af joysticket langs aksen Xi negativ retning fik robotten til at dreje til venstre. Antag, at denne robot er repræsenteret i RCML-miljøet af henholdsvis robotmodulet parrotog joysticket af kontrolmodulet joy, så vil RCML-koden for deres forbindelse i manuel kontroltilstand for at opnå effekten vist i eksemplet være som følger:
@ r = robot_tarakan ; hand_control ( @ r , " glæde " , " R " , " Y " , " A " , " X " );Robotvisningen i RCML-miljøet har en kommandokø , som er fyldt med kommandoer ved at kalde robotfunktionerne fra RCML-koden. Når en kommando ankommer i en tom kø, vil kommandoen blive overført til robotten til udførelse. Mens den første kommando udføres, sættes alle nyligt modtagne kommandoer i kø. Robotten udfører en funktion i den materielle verden, normalt langsommere end RCML-tolken formår at udføre den næste RCML-kode og nå det næste robotfunktionskald, dvs. normalt er robottens handlinger "langsommere" end computerprocessorens handlinger.
Der er dog en anden situation, hvor robotten skal udføre en række hurtige bevægelser uden at stoppe, og beregningen af parametrene for disse bevægelser tager længere tid, end bevægelsen udføres. Så er det mere effektivt at beregne bevægelsesparametrene på forhånd og straks sende robotten en pakke kommandoer med de beregnede parametre, så robotten ikke sænker farten, mens den venter på den næste kommando. Der er situationer, hvor selve funktionsopkaldsmekanismen er langsommere, end robotten udfører kommandoer, og der er en forsinkelse i en hurtig række af bevægelser.
For at kompensere for denne effekt blev der indført en mekanisme til batch-transmission af kommandoer til robotten. Kommandoer modtaget ved at kalde robotfunktioner kan pakkes og videregives som en helhed til robotrepræsentationen. For at sende en kommando til en batch, skal du gå foran funktionskaldet med symbolet >. For at sende en batch til udførelse skal du kalde systemfunktionen send_package().
Eksempel på afsendelse af en kommando i en batch //send kommando til pakken >robottest->gør_noget(1000); //sende pakken til eksekvering system.send_package();I dette eksempel vil en anmodning om en gratis robot af klassen blive sendt først test, og først når robotten er fundet, vil funktionen blive videregivet til pakken, og derefter sendes pakken. Som ved kaldende af robotfunktioner, reserveres roboteksekutorer på forhånd, når kommandoer sendes i batcher. Efter at have kaldt funktionen , er det send_packagemuligt at danne en ny pakke, herunder uden at vente på udførelsen af den forrige pakke ved at bruge ~funktionsudførelsesflaget.
Det er muligt at oprette en pakke til to robotter på én gang, kommandoerne fra denne pakke vil blive overført til to repræsentationer af robotter på én gang, derudover kan du kombinere typerne af funktionskald.
Et eksempel på kompilering af en kommandopakke til to robotter > robot_test -> gør_noget ( 1000 ); > robot_test -> gør_noget ( 1000 ); system . send_pakke ();Ifølge dette eksempel vil to robotter blive aktiveret på samme tid, og ikke den samme to gange i træk. I dette tilfælde vil udførelsen af de første kommandoer i køen af hver repræsentation af robotten begynde på samme tid. Denne mekanisme giver dig mulighed for at synkronisere starten på udførelsen af deres kommandoer af forskellige robotter.
Det enkleste RCML-program ser sådan ud:
funktion hoved () { returnere ; }Programmet afsluttes umiddelbart efter lancering.
Output til konsollen strengen " Hej verden! ", gennem testrobotmodulet.
funktion hoved () { robot_test -> print ( "Hej verden! \n " , 0 ); }Som nævnt tidligere er RCML fokuseret på at arbejde med en pulje (sæt) af robotter, hvorfra eksekutører allokeres til at løse dynamisk opståede opgaver.
Lad der være en pulje af robotter, nogle robotter fra denne pulje er i stand til at udføre den nødvendige teknologiske funktion do_something(). Behovet for at udføre denne funktion bestemmes af en ekstern sensor, så vil programmet til dynamisk fordeling af opgaver til at udføre denne funktion se sådan ud:
funktion hoved () { sløjfe { have_new_task = get_data_from_sensor (); if ( har_ny_opgave ) { ~ robot -> gør_noget (); } system . søvn ( 300 ); } }I dette program, i en cyklus med et interval på 300 ms, bliver en ekstern sensor pollet ved hjælp af funktionen get_data_from_sensor(), linie 3. Hvis det bliver nødvendigt at udføre funktionen, vil den første ledige robot fra poolen, der er i stand til at udføre funktionen, være aktiveret do_something(), linje 5. I dette tilfælde vil programmet ikke vente på udførelsesfunktioner af robotten, fordi flaget for at udføre funktionen uden at vente er sat ~. Dette vil tillade programmet ikke at bremse, mens robotten udfører sin funktion, og fortsætte med at polle sensoren med et specificeret interval.
Hvis funktionen efter de næste 300 ms skal udføres igen, og den første involverede robot endnu ikke har afsluttet sit arbejde, vil RCML aktivere den anden robot fra poolen, og så videre. Efter at den angivne funktion er fuldført, frigives robotterne automatisk og returneres til den fælles pool. Hvis alle robotterne er involveret, vil programmet vente på, at robotten bliver frigivet.
Denne teknik giver dig mulighed for dynamisk at fordele opgaver fra køen blandt robotter og bruge flere robotter på én gang.
Antag, at der er en opgave med bevægelige dele, der vejer fra 1 til 15 kg, ankommer delene sekventielt, men de skal flyttes så hurtigt som muligt. Der er en pulje af forskellige typer robotter, blandt hvilke robotter med robot_heavyhøjere nyttelast (op til 10 kg) og robot_lightlavere nyttelast (op til 5 kg). Samtidig robot_heavyflytter den delen på 10 sekunder og robot_lightpå 5 sekunder. Således parametreres de opgaver, robotterne udfører, og ud fra den tilgængelige parameter (delens vægt) er det nødvendigt at træffe den mest rationelle beslutning om, hvilken type robot der skal bruges for at sikre minimum nedetid og maksimum webstedets produktivitet. For at vise brugen af kommandopakker i dette eksempel, lad os antage, at en del, der vejer mere end 10 kg, kan bæres af to robotter på samme tid.
funktion hoved () { sløjfe { detail_weight = get_weight_from_sensor (); //Få vægten af delen if ( detail_weight < 5 ) { //Hvis vægten er op til 5 kg ~ robot -> move_detail (); //Du kan bruge enhver robot } if (( detail_weight >= 5 ) && ( detail_weight < 10 )) { //Hvis vægten er mellem 5 og 10 kg ~ robot_heavy -> move_detail (); //Du kan kun bruge en større løfterobot } if ( detail_weight >= 10 ) { //Hvis vægten er fra 10 kg > robot_heavy -> move_detail (); //En robot skal være mere bærende > robot -> move_detail (); //Anden robot kan være hvad som helst ~ system . send_pakke (); //Sender en pakke med kommandoer til robotter, der skal udføres } system . søvn ( 300 ); } }Hvis delens vægt er mindre end 5 kg, kan delen bæres af en robot af enhver klasse, linje 5. RCML vil dog først polle alle klassens robotter, robot_lightog hvis der ikke er nogen gratis robotter blandt dem, så vil klassens robotter blive pollet robot_heavy(Prioriteten for pollingrobotklasser er indstillet i konfigurationen af RCML-fortolkeren). Den første gratis robot vil blive brugt til at bevæge sig, på samme måde som i det foregående eksempel, uden at vente på, at hovedprogrammet udfører sin funktion af robotten - at flytte delen. Således vil RCML forsøge at aktivere robotten af den bedst egnede klasse først robot_light, og hvis der ikke er nogen gratis robot af denne klasse, vil en robot af en mindre egnet klasse blive brugt robot_heavytil at forhindre inaktiv tid.
Men hvis delens vægt er fra 5 til 10 kg, kan der kun bruges en større løfterobot, linje 7.
Hvis vægten af delen er fra 10 kg, så skal to robotter være involveret, blandt hvilke den ene skal være mere løftende, og den anden evt. Det skal bemærkes, at i dette tilfælde sendes kommandoen til at flytte delen til to robotter samtidigt gennem mekanismen til kompilering af kommandopakker (linje 11-15).
Det skal bemærkes, at dette eksempel antager, at delene ankommer strengt sekventielt, dvs. den næste del kommer først, når robotten har taget den forrige og bærer den i nogen tid. Jobkøen for robotter er således også sekventiel, og hvis der kommer flere tunge dele, og så en let, så flyttes den lette del først, når alle de tunge dele er flyttet, derfor er robotter i tomgangsklasse mulige robot_light.
Lad os komplicere det foregående eksempel. Lad delene komme ind i en bestemt beholder tilfældigt, synssystemet observerer beholderen og genkender delene i den, modtager delens koordinater og type og bestemmer dens vægt efter type. Når du genkender den næste del, skal du indstille opgaven for robotterne til at flytte delen. Ved genkendelse af dele vil en bestemt funktion get_new_detail_index()returnere et unikt indeks over den genkendte del, hvorfra man senere kan få koordinater og vægt af delen, der er nødvendig for at træffe en beslutning om involvering af henholdsvis robotter og bevægelse.
funktion executeMoveTask ( detaljeindeks ) { detail_weight = get_weight_by_index ( detail_index ); //Få vægten af delen detail_coords = get_coords_by_index ( detail_index ); if ( detail_weight < 5 ) { //Hvis vægten er op til 5 kg ~ robot -> move_detail ( detail_coords ); //Du kan bruge enhver robot } if (( detail_weight >= 5 ) && ( detail_weight < 10 )) { //Hvis vægten er mellem 5 og 10 kg ~ robot_heavy -> move_detail ( detail_coords ); //Du kan kun bruge en større løfterobot } if ( detail_weight >= 10 ) { //Hvis vægten er fra 10 kg > robot_heavy -> move_detail ( detail_coords ); //En robot skal være mere bærende > robot -> move_detail ( detail_coords ); //Anden robot kan være hvad som helst ~ system . send_pakke (); //Sender en pakke med kommandoer til robotter, der skal udføres } } funktion hoved () { sløjfe { new_detail_index = get_new_detail_index (); //Hent det næste delindeks if ( new_detail_index ) { // Ny del ankom ~ executeMoveTask ( new_detail_index ); //Udfør flytteopgaven } system . søvn ( 300 ); } }I dette eksempel, når en ny del ankommer i containeren, vil dens unikke indeks blive opnået (linje 19), som vil blive videregivet til funktionen executeMoveTask(linje 21), hvor robotterne aktiveres, dvs. faktisk dannelsen af anmodninger til puljen af robotter. Særligt bemærkelsesværdigt er, at denne funktion kaldes med no wait-flaget ~.
Sammenfattende giver dette følgende effekt: hvis et stort antal tunge dele, der vejer op til 10 kg, kom ind i containeren, og alle løfterobotter blev brugt fra poolen af gratis robotter robot_heavy, og derefter en vis mængde lette dele, der vejede op til 5 kg kom ind i containeren, så vil RCML kunne bruge tidligere ledige klasserobotter, før klasserobotter robot_lightflytter robot_heavyalle tunge dele. Ved at flytte aktiveringen af robotten til en separat funktion, der udføres uden at vente, fik vi faktisk mulighed for at danne forskellige opgavekøer for forskellige klasser af robotter. Således vil nedetiden for robotter, hvis der er opgaver, der passer til dem, blive minimeret, hvilket var umuligt i det foregående eksempel med en streng rækkefølge af opgaver.
RCML giver programmøren mulighed for eksplicit at specificere, at nogle robotter kan udføre den samme funktion på samme måde, og de kan derfor betragtes som udskiftelige i udførelsen af denne funktion, selvom robotterne har en anden API , der leveres til programmøren på RCML-niveau.
I ovenstående eksempler er der linjer i formularen robot->move_detail(), der bruger søgeordet robot. Dette nøgleord fortæller RCML, at enhver robot fra poolen, der har den ønskede funktion, kan bruges til at udføre denne funktion move_detail().
Lad robotklasserne robot_heavyhave robot_lightet sæt funktioner til at styre grebet og bevægelsen af grebet, men funktionerne i disse sæt har forskellige navne og forskellige parametre.
Følgende eksempel viser, hvordan man forener robot- API'en i et bestemt program, så forskellige klasser af robotter kan udføre den samme funktion.
function robot_heavy::move_to ( x , y , z , w , p , r ) { //Næste er koden for at flytte til et givet punkt, //ved at kalde funktioner, der er specifikke for robotter af klassen 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-specifik optagelseskontrolkode hvis ( s ) { robot -> set_gripper_pos ( 124 , 25 ); } andet { robot -> set_gripper_pos ( 350 , 50 ); } } function robot_light::move_to ( x , y , z , w , p , r ) { //Robot_light-specifik griberbevægelseskode robot -> move_to ( x , y , z ); robot -> sæt_vinkel ( w , p , r ); } function robot_light::gripper ( s ) { // Robot_lys-specifik optagelseskontrolkode hvis ( s ) { robot -> pump_on (); } andet { robot -> pump_off (); } } funktion hoved () { //Universal kode til at flytte en del af en robot af enhver klasse robot -> move_to ( 46 , 76 , 73 , 235 , -34 , 23 ); //Flyt til emnet robot -> griber ( 1 ); // Grib detaljen robot -> move_to ( 235 , 34 , 47 , 262 , 673 , 74 ); //Flyt delen til position 1 system . søvn ( 15000 ); //Vent på delmåletid ved position 1 if ( some_check ()) { //Flyt robottens greb til beholderen med kvalitetsdele robot -> move_to ( 35 , 63 , 23 , 25 , -48 , 245 ); robot -> griber ( 0 ); //Release del } andet { //Flyt robottens greb til beholderen med skrotet robot -> move_to ( 568 , 778 , 346 , -54 , 2 , 34 ); robot -> griber ( 0 ); //Release del } }I dette tilfælde vil flyt- og kontrolalgoritmen være i stand til at udføre både robotklassen og robot_heavyrobotklassen robot_light, selvom de har forskellige API'er på RCML-niveau.
| Programmeringssprog | |
|---|---|
| |