manual irl – robÒtica - fibrob/protegit/manuals/manualirl.pdfmanual irl – robÒtica - fib 1...

Manual IRL – ROBÒTICA - FIB

1

INDEX 1. EL PROGRAMA I LES SEVES PARTS 3

1.1. Especificació del sistema 3 1.2. Parts declaratives del programa 4

1.2.1. Part declarativa 4 1.2.1.1. Definició de Constants 4

1.2.2. Importació i exportació de declaracions 6 1.2.3. Data Lists 8

1.3. Procediments 8 1.4. Funcions 9 1.5. Processos 9 1.6. Paràmetres formals 10

2. INSTRUCCIONS 11

2.1. Assignació 11 2.2. Program Flow 12 2.3. Instruccions de moviment 14 2.4. Instruccions d’entrada i sortida (I/O Statements) 20 2.5. Instruccions de processos paral·lels 21

2.5.1. Control del processos paral·lels 21 2.5.2. Obtenir l’estat d’un procés 22 2.5.3. Sincronització de processos en paral·lel usant semàfors 22

2.6. Aturades i pauses de programes 24 2.6.1 Instruccions de Pausa 24 2.6.2. Instrucció d’aturada del programa 24 2.6.3. Instruccions d’espera 24

3. TIPUS DE DADES 26

3.1. Tipus de dades estàndard (Standard Data Types) 26 3.2. Tipus simple (Simple Type) 26 3.3. Tipus Array (Array Types) 26 3.4. Tipus de dades de sistema (System Data Types) 27 3.5. Tipus senyal (Signal Types) 27 3.6. Tipus semàfor 27 3.7. Tipus especificació del Robot (Robot Specification Type) 28 3.8. Tipus Record 28 3.9. Tipus definits per l’usuari (User Defined Data Types) 29 3.10. Tipus de dades geomètriques 29

3.10.1 Tipus Pose 29 3.10.2. Tipus posició (Position Data Type) 30 3.10.3. Tipus Orientació (Orientation Data Types) 30 3.10.4. Robot Target 34 3.10.5. Tipus Teach 35 3.10.6. Joints 35


2

4. EXPRESSIONS I OPERACIONS 36 5. IDENTIFICADORS PREDEFINITS 38

5.1. Variables predefinides 38 5.2. Constants predefinides 38 5.3. Funcions predefinides pel tractament de strings 40 5.4. Funcions predefinides per operacions matemàtiques 40 5.5. Altres funcions predefinides 41

6. OBSERVACIONS 42

6.1. Unitats 42 6.2. Convencions 42

7. EXEMPLE 44


3

1. EL PROGRAMA I LES SEVES PARTS Un programa està compost per: ProgramHead: "PROGRAM" ProgramIdentifier ";" CompilerDirective. SystemSpecification ProgramDeclarationPart RoutineList:

{ ProcedureDeclaration [ ";" ] | ExternalProcedureDeclaration ";" | FunctionDeclaration [ ";" ] | ExternalFunctionDeclaration ";" | ProcessDeclaration [";"] }

[ "BEGIN" StatementBlock ] "ENDPROGRAM" [ ";" ] Les declaracions poden incloure declaracions de variables i/o de funcions i procediments (també externs). Els valors de les variables “teach/permanent” es prendran de la llista/llistes associades de dades. Exemple: PROGRAM test; { procedures "moveto" and "operation" for testing} PROCEDURE moveto (); BEGIN { procedure statements } ENDPROC;{ end procedure "moveto" } PROCEDURE operation (); BEGIN { procedure statements } ENDPROC;{ end procedure "operation" } BEGIN operation();{ test of procedure "operation" } moveto();{ test procedure "moveto" } WRITELN('end of test'); ENDPROGRAM; 1.1. Especificació del sistema SystemSpecification:

[ "SYSTEM_SPECIFICATION" Expression ";" ]


4

A “Expression” s’ha de posar la ruta de l’arxiu on estan les especificacions del sistema, per tant ha de ser de tipus ARRAY OF CHAR o STRING

COSIMIR per defecte ja utilitza les especificacions predefinides, que estan instal·lades als arxius SYSTEM.IRL i SYSTEM.ROB als subdirectoris IRL4AXIS, IRL5AXIS i IRL6AXIS del directori on està instal·lat. 1.2. Parts declaratives del programa

Les instruccions INTERRUPT, STANDARD_IN i STANDARD_OUT no són suportades per COSIMIR i PCROB. ProgramDeclarationPart:

{ DeclarationPart | ImportDeclaration | ExportDeclaration | DataListSpecification | RobotSpecification | "INTERRUPT" { InterruptDeclaration } | "STANDARD_IN" ":=" Identifier ";" | "STANDARD_OUT" ":=" Identifier ";" }

1.2.1. Part declarativa La part declarativa conté la definició de les constants, declaració de tipus i de variables incloent senyals i canals. Qualsevol declaració de funció o procediment pot incloure una part declarativa per definicions locals i declaracions. DeclarationPart:

( "CONST" { ConstantDefinition } | "TYPE" { TypeDeclaration } | "VAR" { VariableDeclaration } ) { "CONST" { ConstantDefinition } | "TYPE" { TypeDeclaration } | "VAR" { VariableDeclaration } }

STANDARD_IN i STANDARD_OUT defineixen el fitxer o canal declarats per ésser usat com entrada i sortida com el per defecte 1.2.1.1. Definició de Constants ConstantDefiniton:

TeachConstantDefinition | UsualConstantDefinition


5

Hi ha dos tipus de constants: “Teach Constant” i “Usual Constant”, per tant tenim dos maneres de definir: Usual Constant Definition: La definició de constants introdueix un nom constant que representa un valor fix. UsualConstantDefinition:

Type ":" ConstantIdList ":=" Expression ";". ConstantIdList:

ConstantIdentifier { "," ConstantIdentifier }. Expression i Type han de ser del mateix tipus. Exemple: REAL : pi := 3.1415926; Teach Constant Definition: TeachConstantDefinition:

TeachType ":" TeachConstantIdList ";". TeachConstantIdList:

TeachConstantIdentifier { "," TeachConstantIdentifier }.

Els valors de “Teach Constants” s’extreuen de la llista del fitxer de dades. Les constants queden com no definides (“undef”) a no ser que la llista del fitxer de dades especifiqui el contingut de les constants. Qualsevol aplicació amb una constant indefinida causarà un error al executar del tipus run time error. Cadascuna de les “Teach Constants” és d’àmbit global, per tant no estan permeses les definicions locals de “Teach Constants”. Constants: IntegerConstant:

DecimalConstant | BinaryConstant | OctalConstant | HexadecimalConstant

DecimalConstant:

Digit { Digit } BinaryConstant:

"2#" ( "0" | "1" | "_" ) { "0" | "1" | "_" }


6

OctalConstant: "8#" ( "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "_" ) { "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "_" }

HexadecimalConstant:

"16#" ( Digit | "A" | "B" | "C" | "D" | "E" | "F" | "_" ) { Digit | "A" | "B" | "C" | "D" | "E" | "F" | "_" }

RealConstant:

DecimalConstant Exponent | DecimalConstant "." { Digit } [ Exponent ] | "." DecimalConstant [ Exponent ].

Exponent:

( "E" | "e" ) ["+" | "-"] DecimalConstant CharacterString:

"'" { Any-Character-Except-"'" | "''" } "'" CallOrRecord:

Object "(" [ ValueList ] ")" ValueList:

Expression { "," Expression } BooleanConstant: "TRUE" | "FALSE" 1.2.2. Importació i exportació de declaracions ImportDeclaration:

"FROM" ProgramIdentifier "IMPORT" ( "ALL" | ImportIdList ) ";".

ImportIdList:

Identifier { "," Identifier }. ExportDeclaration:

"EXPORT" ( "ALL" | ExportIdList ) [ "TO" ProgramIdList ] ";".

ExportIdList:

Identifier { "," Identifier }. ProgramIdList:

ProgramIdentifier { "," ProgramIdentifier }. Les declaracions importades i exportades introdueixen els objectes d’un programa des de/fins altres programes o parts de programes i només estan permeses a la part declarativa del programa.


7

Exemple: PROGRAM discharge; FROM magazin IMPORT ALL; { all objects of program "magazin" can be imported } FROM parts IMPORT start,partnumber; { two objects of "parts" } FROM seek IMPORT x; { write "x" in every statement } EXPORT f1; { "f1" exported } EXPORT discharge_x TO charge; { "discharge_x" exported to "charge"} VAR { Declarations of program "discharge": } POSE: f1; INT: i,discharge_x; PROCEDURE schedule(); VAR INT: local_x; BEGIN local_x := 3;{ assignment to local "x" } x := 17;{ assignment to "x" in program "seek" } ENDPROC; BEGIN discharge_x := 99; { assignment to "x" of program "discharge" } MOVE PTP mag1; { "mag1" of program "magazin" } x := 0; { assignment to "x" in program "seek" } schedule(); { overwriting of "x" in program "seek" by "schedule()" } WRITE(x); ENDPROGRAM. Modular Programming and Testing Amb IRL is possible dividir els programes en parts que es poden compilar i provar de forma separada. Més tard les diferents parts es poden linkar en un programa complet. Les parts poden ser usades en diferents programes


8

Exemple: PROGRAM dummy; FROM test IMPORT operation; BEGIN { ... } operation(); { ... } ENDPROGRAM; 1.2.3. Data Lists DataListSpecification:

"IMPORT" "DATALIST" Expression ";" “Expression” descriu la ruta de l’arxiu, llavors ha de ser del tipus ARRAY OF CHAR o STRING

Les Data Lists de IRL són les Position Lists del COSIMIR. Totes les llistes de posicions poden ser utilitzades directament com llistes de dades IRL. A aquesta taula tenim la correspondència entre els tipus de les llistes de posició i els de dades IRL.

POSITION TYPE IRL DATA TYPE World Coordinates+Configuration ROBTARGET

World Coordinates POSE MRL 5 axis coordinates

Joint Coordinates MAIN_JOINT Add. Axis ADD_JOINT Boolean BOOL Integer INT Real REAL

Position without Orientation POSITION Text STRING

1.3. Procediments Declaració de procediments: ProcedureDeclaration:

"PROCEDURE" ProcedureIdentifier "(" [ FormalParameter ] ")" ";" [ DeclarationPart ] "BEGIN" StatementBlock "ENDPROC".

Els procediments externs no són suportats per COSIMIR i PCROB. Podem

aconseguir una funcionalitat similar usant codi IRDATA als procediments IRL. Crida a procediments: Procedure Call:

ProcedureIdentifier "(" [ ValueList ] ")"


9

1.4. Funcions Declaració de funcions: FunctionDeclaration:

"FUNCTION" FunctionIdentifier "(" [ FormalParameter ] ")" ":" PredefinedType ";" [ DeclarationPart ] "BEGIN" StatementBlock "ENDFCT"

Les funcions, al contrari dels procediments, retornen un valor que després pot ser utilitzat. Exemple: FUNCTION sign (IN REAL: x ): INT; ... RETURN 0; ENDFCT;

Les funcions externes no són suportats per COSIMIR i PCROB. Podem aconseguir una funcionalitat similar usant codi IRDATA a les funcions IRL. Crida a funcions: CallOrRecord:

Object "(" [ ValueList ] ")". ValueList :

Expression { "," Expression }. La crida a funcions comença l’execució d’una funció. Els parèntesis són necessaris tot i que no hi hagi paràmetres per passar. En aquest cas “Object” defineix l’identificador de la funció. Les expressions de ValueList representen els paràmetres actuals. Exemple: a:=SIN(X); b:=DISTANCE(point_1,point_2); c:=init(); 1.5. Processos ProcessDeclaration:

"PROCESS" ProcessIdentifier "(" [ FormalParameter ] ")" [ IntegerConstant ] ";" DeclarationPart "BEGIN" StatementBlock "ENDPROCESS"


10

IRL permet la definició i ús de processos que s’executen de forma paral·lela amb altres processos definits al programa. El paràmetre opcional IntegerConstant defineix la prioritat del procés, de menor prioritat (0) a major (255). Problemes a resoldre:

• Accés a variables compartides: Les variables compartides han de ser definides com SHARED. L’accés a aquestes s’ha de controlar mitjançant les instruccions LOCK i UNLOCK. Quan un procés fa un LOCK a una variable, cap altre procés hi pot accedir i es queda esperant fins que el procés que està utilitzant la variable va un UNLOCK. Si diversos processos volen accedir a una variable compartida ho faran per ordre de petició.

LOCK i UNLOCK no és suportat per COSIMIR I PCROB, per tant en lloc d’això s’han d’utilitzar els semàfors

• Sincronització: Per resoldre aquest problemes s’utilitzen els Semàfors. 1.6. Paràmetres formals FormalParameter:

[ "IN" | "OUT" | "INOUT" ] ParameterSpecification { ";" [ "IN" | "OUT" | "INOUT" ] ParameterSpecification }

ParameterSpecification:

ParameterType ":" ParameterIdList | ConformantScheme ":" Identifier.

ParameterType: Type | TeachType | SignalType | SemaphoreType .

ParameterIdList:

Identifier { "," Identifier }.

ConformantScheme: "ARRAY" "[" IndexTypeSpecList "]" "OF" Type.

IndexTypeSpecList:

IndexTypeSpecification { "," IndexTypeSpecification }.

IndexTypeSpecification: TypeIdentifier ":" Identifier ".." Identifier

Els paràmetres poden ser IN, OUT i INOUT, si no s’especifica per defecte són INOUT Hi ha tres mecanismes per passar els paràmetres:

• Per referència • Per valor • “Conformant scheme”


11

2. INSTRUCCIONS Construcció de les instruccions (Construction of Statements) Statement:

[ Assignment | ProcedureCall | ProgramflowStatement | MovementStatement | I_O_Statement | ListControlStatement | ParallelProcessStatement ]

Una seqüència d’instruccions es anomenada “block”, els blocs poden estar buits StatementBlock:

{ LabelIdentifier ":" | Statement ";" }. 2.1. Assignació Assignment:

Object ":=" Expression. L’expressió assignada ha de ser compatible amb la part esquerra. Si els tipus de dades dels dos costats són diferents, la conversió del tipus de dada del Object es fa automàticament en funció de la taula de la dreta. simple data type of object REALBOOLINTCHAR of expressionREAL=--- BOOL-=x- INTxx=x CHARx-x= geometric data type of object POSITIONORIENTAT.POSEROBTARGET of expressionPOSITION=-x2x2 ORIENTAT.-=x2x2 POSEx1x1=x2 ROBTARGETx1x1x1= No hi ha possibilitat de conversió entre dades simples i tipus geomètrics de dades.

SIMBOLS SIGNIFICAT = = no type conversion x = Type conversion - = not allowed


12

2.2. Program Flow ProgramflowStatement:

GotoStatement | ConditionalBranchStatement | CaseStatement | LoopStatement | WaitStatement | PauseStatement | ReturnStatement | ProgramHaltStatement | InterruptStatement | ResumeStatement | SynactStatement.

GotoStatement:

"GOTO" LabelIdentifier. ForStatement:

"FOR" Object ":=" Expression "TO" Expression [ "STEP" Expression ]

StatementBlock "ENDFOR". STEP és opcional, per defecte incrementa en una unitat. Increments negatius estan permesos. Totes les expressions han de ser aritmètiques, aquestes i els objectes han de ser del tipus INT.

Exemple:

FOR i := 1 TO 10 MOVE LIN palette [i];

ENDFOR; CaseStatement:

"CASE" Expression "OF" CaseList [ "DEFAULT" [ ":" ] StatementBlock ] "ENDCASE".

CaseList :

Case { ( "|" | "WHEN" ) Case }.

Case: [ CaseConstantList ":" StatementBlock ].

CaseConstantList:

CaseConstant { "," CaseConstant }.

CaseConstant: Expression.


13

L’expressió i “CaseConstants” han de ser del tipus INT o CHAR

Exemple:

CASE workpiece OF WHEN 0:length := 1; WHEN 1,6:length := 5; DEFAULT: length := 0;

ENDCASE; ConditionalBranchStatement:

"IF" Expression "THEN" StatementBlock

[ "ELSE" StatementBlock ] "ENDIF".

Cada IF necessita un ENDIF

Exemple:

IF x > 1 THEN y := 50; z := 20;

ELSE y := 30;

ENDIF;

IF x < 25 THEN y := 30; z := 10; ELSE z := 2*y; ENDIF; ProcedureCall:

Veure punt 1.3. Procediments WhileStatement:

"WHILE" Expression StatementBlock "ENDWHILE". Cada WHILE necessita un ENDWHILE

Exemple:

i := 1; WHILE i<=10

MOVE LIN palette[i]; i := i+1;

ENDWHILE; RepeatStatement:

"REPEAT" StatementBlock "UNTIL" Expression. Cada REPEAT necessita un UNTIL


14

Exemple:

i := 1; REPEAT

MOVE LIN palette[i]; i := i+1;

UNTIL i>10; ResumeStatement: "RESUME" Interrupcions i la instrucció RESUME no són suportades per COSIMIR i PCROB ReturnStatement:

"RETURN" [ Expression ] 2.3. Instruccions de moviment MovementStatement:

LinearMovement | PointToPointMovement | CircleMovement | BrakeStatement.

Camí i instruccions PTP: LinearMovement:

( "MOVE" | "MOVE_INC" ) "LIN" ToPoint ContinuePathParameter. PointToPointMovement:

( "MOVE" | "MOVE_INC" ) "PTP" ToPoint PointToPointParameter. CircleMovement:

( "MOVE" | "MOVE_INC" ) "CIRCLE" Circle ContinuePathParameter. ToPoint:

Expression | Path. Circle:

Expression "," Expression | Path. Path:

"PATH" [ Expression ":" ] ( Object "[" [ IndexBound ] "]" | "(" ValueList ")" ).

Totes les expressions, arrays o llistes d’elements han de ser expressions geomètriques. El “Tool Center Point” (TCP) del robot industrial es mou en funció de la interpolació donada. En les instruccions de moviment, els valors de les expressions geomètriques i dels arrays són interpretades com coordenades absolutes.


15

La instrucció MOVE_INC, els valors de les expressions geomètriques o dels elements dels arrays són interpretats com increments. Els components POSITION, ORIENTATION o POSE seran tractats tal i com estan definits al @-operation. Els components MAIN_JOINT or ADD_JOINT seran afegits als valors actuals dels eixos. Instruccions sense camí (Statement without PATH): Als moviments LIN i PTP, l’expressió geomètrica defineix la posició final. Al moviment CIRCLE la segona expressió geomètrica és la que defineix la posició final i les coordenades X, Y, Z de la primera expressió s’utilitzen com a punt intermig. Instruccions amb camí (Statement with PATH): Normalment el camí desitjat es defineix a una llista o en un array de dades de tipus geomètric: ORIENTATION, POSITION, POSE, MAIN_JOINT, ADD_JOINT, JOINT o ROBTARGET. També pot venir donat per una llista de valors separats per comes. En el cas dels tipus de dades ORIENTATION o POSITION, els components que manquen s’agafen de la posició actual (R_ROBTARGET_ACT.PSE). Els punts intermitjos són tractats de la mateixa forma que a les instruccions sense camí. La conversió del tipus es fa de POSE a ROBTARGET. En el cas de LIN o PTP, el camí és interpolat en funció de la instrucció. Són vàlids les variables de sistema i els paràmetres. En el cas dels CIRCLE, els elements amb índexs senars defineixen les coordenades X, Y, Z dels punts intermitjos, i els elements amb índexs parells defineixen les coordenades de la posició final. El numero de punts ha de ser parell. El primer array o llista d’elements és el primer punt del camí Path smoothing: Normalment el robot s’atura a la posició final però si un paràmetre amb “path smoothing” està definit, el robot no s’aturarà. El tipus de “path smoothing” depèn del paràmetre addicional definit. Paràmetres addicionals: Els paràmetres addicionals només són vàlids per les instruccions de moviment en les quals estan definits (a diferència de les variables de sistema) Paràmetres addicionals PTP:

Els paràmetres addicional PTP actualment no són suportats per COSIMIR i PCROB. Utilitzarem variables de sistema (R_C_PTP, ...)


16

PointToPointParameter:

[ "ACT_ROB" ":=" Expression ] { "C_PTP" [ ":=" Expression] | "C_PASS" | "SPEED_PTP" [ ":=" Expression ] | "ACC_PTP" [ ":=" Expression ] | "TIME" ":=" Expression | "UNTIL" Expression [ "ERROR" StatementBlock "ENDERROR" ] | "ALTER_BY" ProcedureCall }

Descripció de paràmetres: ACT_ROB: Especificació del robot escollit. L’expressió ha de ser la identificació corresponent al robot especificat. Si no és així hi haurà un error.

Default: system variable R_ACT_ROB. C_PTP: L’expressió aritmètica representa el factor (%) de la distancia de l’eix amb el punt intermig on comença l’smoothing. Per cada eix existeix un paràmetre de la maquina (path smoothing ON/OFF)

Default: system variable R_C_PTP. C_PASS: Activa l’algoritme “path smoothing” que fa començar la transició quan passa pel següent punt activat. SPEED_PTP: L’expressió aritmètica defineix un array de factors(%) de la velocitat de moviment donada.

Exemple: SPEED_PTP := [ 50.0, 50.0, 100.0, 50.0, 50.0, 50.0, 100.0 ];

Default: system variable R_SPEED_PTP. ACC_PTP: L’expressió aritmètica defineix un array de factors (%) de l’acceleració de moviment donada

Default: system variable R_ACC_PTP. TIME: Temps pel moviment UNTIL: Atura el moviment si l’expressió lògica es fa certa (<>0). En aquest cas s’executa la instrucció “ERROR” si existeix el tractament d’aquest. Només estan permeses les variables SIGNALS


17

ALTER_BY: Especificació d’un procediment extern que controla el moviment actual, per exemple processant senyals d’un sensor. Aquest procediment ha de ser declarat com EXTERNAL. L’ús de procediments IRL ordinaris no és possible. SPEED_PTP i TIME així com C_PTP i C_PASS són d’exclusió mútua. Paràmetres addicionals CP:

Alguns dels paràmetres addicionals CP actualment no són suportats per COSIMIR i PCROB. Utilitzarem variables de sistema (R_C_CP, ...).

Els paràmetres ADAX_CONTROL i DEVICE són suportats per COSIMIR i PCROB. ContinuePathParameter:

[ "ACT_ROB" ":=" Expression ] [ "ADAX_CONTROL" ":=" Expression ] [ "DEVICE" ":=" Expression ] { "C_CP" [ ":=" Expression ] | "C_SPEED" [ ":=" Expression ] | "SPEED_ORI" [ ":=" Expression ] | "C_PASS" | "SPEED" [ ":=" Expression ] | "ACC" [ ":=" Expression ] | "TIME" ":=" Expression | "UNTIL" Expression [ "ERROR" StatementBlock "ENDERROR" ] | "WOBBLE" | "ALTER_BY" ProcedureCall }

Descripció de paràmetres: ACT_ROB: Especificació del robot escollit. L’expressió ha de ser la identificació corresponent al robot especificat. L’expressió ha de ser del tipus ARRAY OF CHAR o STRING i ha de contenir el nom del robot. Si el nom no correspon amb el del robot especificat a l’Especificació del Sistema, es produirà un error del tipus “runtime error”.

Default: system variable R_ACT_ROB.

ADAX_CONTROL: Especificació de les coordenades de moviment respecte al eixos addicionals. L’expressió descriu el tipus de coordenades de moviment. Els possibles valors són:

• NO_ADAX_CONTROL: Moviment típic, sense una coordinació especial dels eixos addicionals.

• TCP_KEEP: Es manté la posició i orientació actual del TCP en coordenades mundials. Només el component ADD_JOINT de ToPoint o Circle és considerat pel moviment.


18

• TCP_KEEP_REL: Es manté a posició i orientació actual de TCP relativa al sistema de coordenades del dispositiu donat per DEVICE:=Expression. Només el component ADD_JOINT de ToPoint o Circle és considerat pel moviment.

• DEVICE_REL: El moviment s’executa en relació al sistema de coordenades (amb possibilitat de moviment) del dispositiu donat per DEVICE:=Expression.

Default: NO_ADAX_CONTROL

DEVICE: Definició del sistema de coordenades del dispositiu per moviments relatiu als eixos addicionals. La definició ve donada per la identificació del dispositiu (D_NO del tipus D_SPEC_TYPE). L’expressió ha de ser del tipus INT. Aquest paràmetre només pot ser utilitzat amb el paràmetre ADAX_CONTROL.

Default: 1 (ha de ser definit en cada cas) C_CP: L’expressió aritmètica és la distancia al punt intermig on comença l’smoothing. (path smoothing ON/OFF).

Default: system variable R_C_CP.

C_SPEED: Valor de la velocitat del “path smoothing” en % de la velocitat programada (path smoothing ON/OFF)

Default: system variable R_C_SPEED.

SPEED_ORI: Orientació de la velocitat. La longitud del camí ha de ser zero

Default: system variable R_SPEED_ORI.

C_PASS: Activa l’algoritme “path smoothing” que fa començar la transició quan passa pel següent punt activat. SPEED: L’expressió aritmètica defineix la velocitat del moviment (path)

Exemple: SPEED := 350.0; Default: system variable R_SPEED.

ACC: L’expressió aritmètica defineix l’acceleració del moviment (path)

Default: system variable R_ACC.

TIME: Temps pel moviment UNTIL: Atura el moviment si l’expressió lògica es fa certa (<>0). En aquest cas s’executa la instrucció “ERROR” si existeix el tractament d’aquest. Només estan permeses les variables SIGNALS WOBBLE: Moviment super-imposed


19

ALTER_BY: Especificació d’un procediment extern que controla el moviment actual, per exemple processant senyals d’un sensor. Aquest procediment ha de ser declarat com EXTERNAL. L’ús de procediments IRL ordinaris no és possible. SPEED i TIME així com C_CP, C_SPEED i C_PASS són d’exclusió mútua. Exemples: - Instruccions de moviment: VAR INPUT BOOL: alarm AT 1; ROBTARGET: p1 := ( ( (100.0, 1000.0, 0.0), ORIRS(90.0, 0.0, 90.0) ), 4, 100, 0); {The last but two entry represents the RecordComponent Status, this describes the robot configuration; the last two values represent additional axes, there is no TURNS component} ROBTARGET:p2 := ( ( (200.0, 200.0, 10.0), ORIXYZ(90.0, 0.0, 90.0) ), 8, 200, 0); {the meaning of status is system dependent. For example number 4 means elbow left and number 8 means elbow right} BEGIN MOVE LIN p1; { linear movement to P1 } p1.status := 8; { change of the configuration: elbow left to elbow right } MOVE PTP p1; MOVE LIN p2 UNTIL alarm; { move to P2, stop movement, when signal 'alarm' becomes true } MOVE_INC PTP POSITION(10,30,0); MOVE PTP R_ROBTARGET_ACT @ POSITION(10,30,0); { both commands have the same meaning, shifting the robot TCP position according as local coordinates related to the TCP system itself } MOVE PTP POSITION(20,20,-100) @ R_ROBTARGET_ACT; { shifting the robot TCP position according as global coordinates related to the world coordinate system } ENDPROGRAM; - Moviment amb camí: DECLOFF; VAR ARRAY[1..10] OF ROBTARGET: path1; LIST OF ROBTARGET: listpath := [p1,p2]; POSE:p3, p4; BEGIN MOVE PTP PATH (p1, p2, p3, p4);{ implicit declaration of p1, p2 as ROBTARGET } MOVE LIN PATH path1[]; LISTADD p4 TO listpath; LISTINS p3 INTO listpath AT 3; MOVE PTP PATH listpath;{results in the same movement as the first statement of that block} MOVE CIRCLE PATH path1[3..8];


20

- Programació de la velocitat: R_SPEED := 100.0; { Assumed an overridefactor for the velocity is equal to 1.0 (100%). } { An overridefeature of a robot controller is outside the scope of this standard. } MOVE LIN corner;{ velocity = 100.0 mm/s } MOVE LIN home SPEED := 200.0;{ velocity = 200.0 mm/s } MOVE LIN start_pos;{ velocity = 100.0 mm/s } { Assumed an overridefactor for the velocity changed to 0.8 (80%). } MOVE LIN corner;{ velocity = 80.0 mm/s } MOVE LIN home SPEED := 200.0;{ velocity = 160.0 mm/s } MOVE LIN start_pos;{ velocity = 80.0 mm/s } 2.4. Instruccions d’entrada i sortida (I/O Statements) Signals Els identificadors SIGNALS són tractats com variables. Poden ser comprovats utilitzant expressions i poden ser activats mitjançant assignació de valors

I/O per canals i arxius només són suportats a COSIMIR i PCROB per la consola (CONSOLE) WriteStatement:

( "WRITE" | "WRITELN" ) "(" FormatList ")" | "WRITERAC" "(" Expression "," ElementNumber "," ValueList ")".

FormatList:

[ OutputValue [ ":" Expression [ ":" Expression [ ":" Expression ] ] ] { "," OutputValue [ ":" Expression [ ":" Expression [ ":" Expression ] ] ] } ]

OutputValue: Expression.

ElementNumber: Expression.

Les dades de sortida són sempre ASCII. El primer element de OutputValues, a FormatList, ha de ser un Object que definiria el FileType. Si no es posa res la sortida estàndard (STANDARD_OUT) és la utilitzada per defecte.


21

Els altres elements de FormatList serien: • El primer d’ells a OutputValue defineix el valor que ha de ser escrit • Les altres 3 expressions (Fieldwidth, Precision i OriMode) especifiquen com

s’ha d’escriure l’OutputValue ReadStatement:

( "READ" | "READLN" ) "(" ObjectList ")" | "READRAC" "(" Expression "," ElementNumber "," ObjectList ")".

ObjectList: Object { "," Object }.

La instrucció de READ llegeix dades de l’arxiu o del canal (en el cas del COSIMIR ho farà de la consola) i aquests són assignats a objectes. 2.5. Instruccions de processos paral·lels ParallelProcessStatement:

ProcessControlStatement | VariableControlStatement | GetStatusStatement | SemaphoreControlStatement.

IRL permet la definició i ús de processos que s’executen de forma paral·lela amb altres processos definits al programa. Hi ha instruccions que controlen els processos paral·lels, les instruccions controlen les variables declarades i compartides i els semàfors, els quals serveixen per sincronitzar el paral·lelisme de processos 2.5.1. Control del processos paral·lels ProcessControlStatement:

StartStatement | StopStatement | ContinueStatement | CancelStatement.

Començar un procés: Un procés comença amb “StartStatement”. Si el procés no ha sigut llançat abans, es carrega i es llença al començament. Si ha començat però s’està executant o està aturat per “StopStatement”, “StartStatement” no tindrà efecte. Si el procés ha acabat per si mateix (amb ReturnStatement o ENDPROCESS) o ha sigut finalitzat per CancelStatement, el procés serà també llançat al principi. “ValueList” conté els paràmetres actuals pel procés. StartStatement:

"START" ProcessIdentifier "(" ValueList ")". Aturar un procés:


22

“StopStatement” atura l’execució del procés donat i de tots el processos llançats pel procés aturat (processos fills). Si cap “ProcessIdentifier” és especificat, el procés o el programa que crida la instrucció d’aturada és aturat. Un procés aturat pot ser continuat pel “ContinueStatement” en qualsevol moment i al mateix punt on s’havia aturat StopStatement:

"STOP" [ ProcessIdentifier ]. Continuar un procés: Un procés aturat pot continuar amb “ContinueStatement”. Si el procés s’està executant o ha acabat, “ContinueStatement” no tindrà efecte ContinueStatement:

"CONTINUE" ProcessIdentifier. Acabar un procés: Un procés pot ser acabat amb “CancelStatement”. Un procés acabat no pot continuar al punt on s’ha aturat. Tots els processos fills també s’acabaran. El procés s’esborra completament, totes les variables locals es perden i hauria de ser recarregat per executar-se un altre cop (StarStatement ho fa automàticament). Si no es dóna cap ”ProcessIdentifier”, tots els processos seran acabats. CancelStatement:

"CANCEL" [ ProcessIdentifier ] 2.5.2. Obtenir l’estat d’un procés GetStatusStatement

"GETSTATUS" "(" ProcessIdentifier "," Object ")". GetStatusStatement retorna l’estat actual del procés que ve donat. Constants enteres han de ser declarades un per cada estat de procés com a part de l’especificació de sistema (System Specification). Els possibles estats són:

0 = R_PROCESS_READY: el procés està preparat. 1 = R_PROCESS_RUNNING: el procés s’està executant. 2 = R_PROCESS_STOPPED: el procés està aturat. 3 = R_PROCESS_BLOCKED: el procés està bloquejat.

2.5.3. Sincronització de processos en paral·lel usant semàfors SemaphoreControlStatement:

SemaphoreWaitStatement | SemaphoreSignalStatement.

SemaphoreWaitStatement:

"SEMA_WAIT" "(" Object ["," Expression] ")".


23

SemaphoreSignalStatement: "SEMA_SIGNAL" "(" Object ["," Expression] ")".

IRL suporta l’ús de semàfors per sincronitzar processos en paral·lel. Aquests han de ser inicialitzats en la seva declaració. Cada semàfor té una cua de processos associada esperant pel aquest. Aquesta cua pot estar buida. Els processos es van sortint per la norma first-in first-out. Hi ha dues operacions associades als semàfors: SemaphoreWaitStatement i the SemaphoreSignalStatement. L’objecte a cada instrucció ha de ser del tipus SemaphoreType. L’argument opcional “Expression” només pot ser donat per semàfors del tipus enter, no per binaris, i han de tenir un valor més gran de 0. Semàfors binaris Un procés que sol·licita un semàfor binari utilitzant “SemaphoreWaitStatement” continua l’execució si el valor del semàfor és CERT(<>0). Amb “SemaphoreWaitStatement” el valor del semàfor passa a ser FALS (=0) i només pot tornar a passar a CERT amb “SemaphoreSignalStatement”. Si el valor del semàfor és FALS mentre s’executa SemaphoreWaitStatement, el procés passa a l’estat BLOCKED i s’afegeix al final de la cua del semàfor. Quan SemaphoreSignalStatement s’executa mentre hi ha processos que estan esperant a la cua, el primer procés que està a la cua passa a l’estat RUNNING i s’esborra de la cua, però el valor del semàfor continua a FALS. El valor del semàfor canviarà a CERT quan SemaphoreSignalStatement i la cua estigui buida. Exemple: ... VAR SEMAPHORE BOOL: a := FALSE, b := FALSE; POSE: p; SENSORDATA: sendata; ... { Task A: Sensor-Data processing } ... WHILE TRUE { Read sensor data } read_sensor_data(sendata); { Process sensor data } p := pos_from_data(sendata); { calculated position available for task B } SEMA_SIGNAL a; { wait for position reached } SEMA_WAIT b; ENDWHILE; ...

{ Task B: Robot movements } ... WHILE TRUE . . { wait for position } SEMA_WAIT a; { move to position } MOVE LIN p; { we are there } SEMA_SIGNAL b; . . ENDWHILE; ...


24

Semàfors enters: Els semàfors enters són tractats d’una forma una mica diferent als booleans. Quan un procés sol·licita un semàfor usant SemaphoreWaitStatement, la expressió serà avaluada com un valor enter. Si no hi ha “Expression”, el valor per defecte serà 1. El valor de l’expressió serà restat al valor del semàfor i el resultat serà el nou valor d’aquest. Si el resultat és major o igual a 0, el procés continuarà, en canvi, si el valor és menor que 0 el procés passarà a estat BLOCKED i s’afegirà al final de la cua de processos que esperen. Quan el procés executa SemaphoreSignalStatement, si existeix “Expression” serà avaluada con un valor enter. Si no existeix l’expressió el valor per defecte serà 1. El resultat serà afegit al valor del semàfor. Si hi ha processos a la cua, passaran a l’estat RUNNING tants processos com el nou valor del semàfor i per cada procés el valor del semàfor disminuirà un altre cop. Tot això es fa de forma transparent. 2.6. Aturades i pauses de programes 2.6.1 Instruccions de Pausa PauseStatement:

"PAUSE" [ Expression ]. El programa s’atura fins que s’activa el senyal “START” del sistema de control del robot. “Expression” ha de ser del tipus ARRAY OF CHAR o STRING. Si ve donada una expressió, aquesta serà escrita a la línia de missatges del sistema de control i serà esborrada després de que s’activi el senyal “START”. Si no existeix cap línia de missatges, l’expressió s’escriurà a la sortida estàndard del dispositiu (STANDARD_OUT). Exemple: PAUSE 'Please change palette'; 2.6.2. Instrucció d’aturada del programa ProgramHaltStatement:

"HALT" Aquesta instrucció atura l’execució del programa 2.6.3. Instruccions d’espera WaitStatement:

"WAIT" ( Expression "SEC" | "FOR" Expression [ "TIMEOUT" Expression "SEC" [ "ERROR" StatementBlock "ENDERROR" ]])


25

WAIT SEC: El programa és aturat durant els segons que indica l’expressió aritmètica WAIT FOR: El programa continuarà quan l’expressió lògica prengui el valor CERT (<>0). Si es dóna un temps addicional i l’expressió lògica és fa certa abans que el període de timeout acabi, el programa continuarà immediatament. En cas contrari, el bloc d’instrucció de “ERROR” serà executat abans de que l’execució del programa continuï.

Només WAIT SEC i WAIT FOR són actualment suportats per COSIMIR i PCROB. Exemple: WAIT 2.4 SEC;{wait 2.4 sec }


26

3. TIPUS DE DADES Declaració de tipus TypeDeclaration:

StructuredTypeDeclaration | TeachTypeDeclaration | SignalTypeDeclaration | SemaphoreTypeDeclaration.

Descripció i identificador del tipus: Type :

PredefinedType | StructuredTypeIdentifier | StructuredTypeDescription.

PredefinedType:

SimpleType | StandardType | SystemType.

3.1. Tipus de dades estàndard (Standard Data Types) StandardType: StandardTypeIdentifier. Hi ha 5 tipus de dades predefinits amb 5 identificadors predefinits: STRING, TEXT, POSITION, ORIENTATION i POSE. STRING: Descriu objectes que es poden representar amb caràcters ASCII. El tamany màxim de STRING és 255. El primer element d’un string està referenciat amb l’índex 1. TEXT: Aquest tipus s’utilitza per tractar fitxer seqüencials de text i canals 3.2. Tipus simple (Simple Type) SimpleType: SimpleTypeIdentifier. Hi ha 4 tipus de dades simples predefinits amb els identificadors predefinits: BOOL, CHAR, INT i REAL. 3.3. Tipus Array (Array Types) ArrayTypeDescription:

"ARRAY" "[" IndexBoundList "]" "OF" Type.

IndexBoundList: IndexBound { "," IndexBound }


27

IndexBound: Expression ".." Expression.

Les expressions només poden ser del tipus INT o CHAR Exemple: TYPE ARRAY [4..10] OF ROBTARGET = p_type; {one dimensional array, with elements of type ROBTARGET} ARRAY [1..100,1..80] OF CHAR = text_type; {two dimensional array, elements of type CHAR} 3.4. Tipus de dades de sistema (System Data Types) SystemType: SystemTypeIdentifier. Hi ha 6 tipus de dades de sistema predefinits amb els identificadors predefinits: MAIN_JOINT, ADD_JOINT, JOINT, ROBTARGET, D_SPEC_TYPE i R_SPEC_TYPE. Han de ser definits a l’especificació de sistema. 3.5. Tipus senyal (Signal Types) SignalTypeDeclaration:

SignalTypeDescription ":" SignalTypeIdentifier. SignalTypeDescription:

( "INPUT" | "OUTPUT" ) SimpleType. SignalType:

SignalTypeIdentifier | SignalTypeDescription.

3.6. Tipus semàfor

En COSIMIR i PCROB la descripció del tipus semàfor es fa així: SemaphoreTypeDescription:

"SEMA" Identifier

En IRL fora de COSIMIR i PCROB es fa de la següent forma: SemaphoreTypeDeclaration:

SemaphoreTypeDescription ":" SemaphoreTypeIdentifier. SemaphoreTypeDescription:

"SEMAPHORE" SimpleType. En IRL, el tipus de dada semàfor està dedicat a la sincronització de múltiples processos


28

Hi ha dos tipus de semàfors en IRL: - Booleans: Només poden tenir els valors CERT o FALS - Integer: El rang és del tipus de dada enter.

SemaphoreType:

SemaphoreTypeIdentifier | SemaphoreTypeDescription

3.7. Tipus especificació del Robot (Robot Specification Type) El tipus R_SPEC_TYPE és l’utilitzat per les variables de sistema predefinides específiques del robot. Ha de ser declarat a l’especificació del sistema (System Specification). Per cada robot usat en un programa IRL, un record d’aquest tipus ha de ser inicialitzat a la especificació del robot (Robot Specification). Exemple: TYPE RECORD REAL:R_ACC; ARRAY[1..R_NJ] OF REAL:R_ACC_PTP; REAL:R_C_PTP; REAL:R_C_CP; REAL:R_C_SPEED; ARRAY[1..R_DEVICE_NUMBER] OF INT : R_DEVICES; JOINT:R_JOINT_ACT; ROBTARGET:R_ROBTARGET_ACT; ROBTARGET:R_ROBTARGET_START; ROBTARGET:R_ROBTARGET_END; ROBTARGET:R_ROBTARGET_INTER; REAL:R_SPEED_ACT; REAL:R_SPEED; ARRAY[1..R_NJ] OF REAL:R_SPEED_PTP; REAL:R_SPEED_ORI; POSE:R_BASE; POSE:R_TOOL; ENDRECORD = R_SPEC_TYPE; 3.8. Tipus Record RecordTypeDescription :

"RECORD" ComponentList "ENDRECORD".

ComponentList: Type ":" ComponentIdList { ";" Type ":" ComponentIdList }.

ComponentIdList:

ComponentIdentifier { "," ComponentIdentifier }.


29

El tipus Record és una sèrie de objectes, anomenats components, que poden ser de diferents tipus de dades. Cada component té un identificador únic per accedir-hi, aquest identificador i el tipus de dada del component es descriu a la definició del Record. Exemple: TYPE RECORD position_type: p1, p2; REAL: current; ENDRECORD = test_type; 3.9. Tipus definits per l’usuari (User Defined Data Types) Restringit a tipus “structured”, “teach”, “signal” o “semaphore” Structured Data Types StructuredTypeDeclaration:

StructuredTypeDescription ":" StructuredTypeIdentifier StructuredTypeDescription:

RecordTypeDescription | ArrayTypeDescription | ListTypeDescription | FileTypeDescription.

3.10. Tipus de dades geomètriques El tipus de dades geomètriques s’utilitza per descriure la posició i l’orientació i per fer-ho s’utilitza el sistema les coordenades cartesianes (també anomenat “world coordinate system”, sistema de coordenades mundials). El punt d’origen i l’orientació es defineix durant la instal·lació del sistema de control del robot. 3.10.1 Tipus Pose El tipus POSE està compost pels POSITION i ORIENTATION, exemple:

TYPE RECORD POSITION: POS; ORIENTATION: ORI ENDRECORD = POSE;

Assignació a una variable POSE, exemple:

VAR POSITION: first_pos, next_pos; ORIENTATION: ori; POSE: f,g;


30

BEGIN f.POS := first_pos; f.ORI := ori; g := POSE (next_pos,f.ORI);

Selecció d’un component de POSE, exemple:

next_pos := f.POS; ori := g.ORI;

3.10.2. Tipus posició (Position Data Type) El tipus de dada predefinit POSITION es dóna amb 3 nombres reals que descriuen els valors de les coordenades de direcció X-, Y- i Z-.

TYPE RECORD REAL: X,Y,Z ENDRECORD = POSITION;

Assignació a la variable de posició, exemple:

VAR POSITION: p; REAL: x := -10.5; BEGIN p.X := x; p.Y := p.Y * 0.5; p.Z := 2.01; p := (x,p.y*0.5,2.01); p := POSITION(100.0,150.0,200.0);

Selecció del component de POSITION, exemple:

x := p.X;

3.10.3. Tipus Orientació (Orientation Data Types)

Les funcions d’orientació quaternàries no són suportades per COSIMIR i PCROB Aquest tipus descriu la direcció del sistema de coordenades a l’espai en relació a el sistema de referència. Per representar l’orientació s’utilitza una matriu de rotació. Si una orientació descriu la direcció del sistema de coordenades R1 en relació al sistema de referència R, la matriu de rotació corresponent M = ( Rn Ro Ra ) consistirà en 3 columnes que representaran les coordenades de R dels vectors bàsics Rn, Ro i Ra del sistema de coordenades R1. Per cada orientació ori hi ha només una única matriu de rotació M = M(ori), i per les propietats dels vectors bàsics del sistema de coordenades cartesianes, M-1 = MT és cert per tot M


31

Una variable del tipus Orientation pot especificar la rotació o la direcció del sistema de coordenades descrivint una transformació:

• Rotació: Rp' = M(Rori) * Rp Rp i Rp' representen el vector p abans i

després de la rotació representada per Rori. • Transformació: Rp = M(Rori) * R1p R1p representa les coordenades

locals del punt P en relació al sistema de coordenades R1. Riri descriu la direcció de R1 en relació a R. El resultat Rp representa les coordenades del mateix punt P en relació a R.

Funcions d’assignació a una variable d’orientació: VAR ORIENTATION: ori; POSITION: n1,o1,a1,v; REAL: a,b,c,d; BEGIN ori := ORIRS(a,b,c); Primer “a” rota sobre l’eix X del sistema de referència, després “b” sobre l’eix Y del sistema de referència original i per últim “c” rota sobre el Z del sistema de referència original ori := ORIXYZ(a,b,c); “a” rota sobre l’eix X del sistema de referència, després “b” sobre el nou eix Y del sistema de referència rotat i per últim “c” rota sobre l’eix Z del sistema de referència rotat 2 vegades ori := ORIYXZ(a,b,c); “a” rota sobre l’eix Y del sistema de referència, després “b” sobre el nou eix X del sistema de referència rotat i per últim “c” rota sobre l’eix Z del sistema de referència rotat 2 vegades ori := ORIZYX(a,b,c); “a” rota sobre l’eix Z del sistema de referència, després “b” sobre el nou eix Y del sistema de referència rotat i per últim “c” rota sobre l’eix X del sistema de referència rotat 2 vegades. Això seria el mateix que fer ORIRS(c,b,a) ori := ORIZYZ2(a,b,c); “a” rota sobre l’eix Z del sistema de referència, després “b” sobre el nou eix Y del sistema de referència rotat i per últim “c” rota sobre l’eix Z del sistema de referència rotat 2 vegades. ori := ORIVANG(v,a); “a” rota sobre l’eix “v”, descrit al sistema de referència ori := ORIQUAT(a,b,c,d); “a”, “b” i “c" són paràmetres de l’especificació quaternària ori := ORIMAT(n1,o1,a1); n1, o1 i a1 són vectors unitaris que representen les 3 columnes d’una matriu de rotació, aquests construeixen un sistema de coordenades “rigth-handed"


32

Funcions de selecció d’un component d’orientació: VAR ORIENTATION: ori; POSITION: n1,o1,a1,v; REAL: r; BEGIN r := ANGLEX(RS,ori); Resultat: Rotació sobre l’eix X sota la definició de ORIRS r := ANGLEX(XYZ,ori); Resultat: Rotació sobre l’eix X sota la definició de ORIXYZ r := ANGLEX(YXZ,ori); Resultat: Rotació sobre l’eix X sota la definició de ORIYXZ r := ANGLEX(ZYX,ori); Resultat: Rotació sobre l’eix X sota la definició de ORIZYX r := ANGLEY(RS,ori); Resultat: Rotació sobre l’eix Y sota la definició de ORIRS r := ANGLEY(XYZ,ori); Resultat: Rotació sobre l’eix Y sota la definició de ORIXYZ r := ANGLEY(YXZ,ori); Resultat: Rotació sobre l’eix Y sota la definició de ORIYXZ r := ANGLEY(ZYZ2,ori); Resultat: Rotació sobre l’eix Y sota la definició de ORIZYZ2 r := ANGLEY(ZYX,ori); Resultat: Rotació sobre l’eix Y sota la definició de ORIZYX r := ANGLEZ(RS,ori); Resultat: Rotació sobre l’eix Z sota la definició de ORIRS r := ANGLEZ(XYZ,ori); Resultat: Rotació sobre l’eix Z sota la definició de ORIXYZ r := ANGLEZ(YXZ,ori); Resultat: Rotació sobre l’eix Z sota la definició de ORIYXZ r := ANGLEZ(ZYZ2,ori); Resultat: Rotació sobre l’eix Z sota la definició de ORIZYZ2 r := ANGLEZ(ZYX,ori); Resultat: Rotació sobre l’eix Z sota la definició de ORIZYX r := ANGLEZ2(ZYZ2,ori); Resultat: Rotació sobre l’eix Z2 sota la definició de ORIZYZ2


33

v := ROTAXIS(ori); Resultat: Vector de rotació sota la definició de ORIVANG r := ROTANGLE(ori); Resultat: Rotació sobre l’eix V sota la definició de ORIVANG r := QUATA(ori); Resultat: Paràmetre “a” de l’especificació quaternària r := QUATB(ori); Resultat: Paràmetre “b” de l’especificació quaternària r := QUATC(ori); Resultat: Paràmetre “c” de l’especificació quaternària r := QUATD(ori); Resultat: Paràmetre “d” de l’especificació quaternària n1 := VECTORN(ori); Resultat: Vector unitari que representa la primera columna de la matriu de rotació o1 := VECTORO(ori); Resultat: Vector unitari que representa la segona columna de la matriu de rotació a1 := VECTORA(ori); Resultat: Vector unitari que representa la tercera columna de la matriu de rotació ENDPROGRAM; És important que la definició d’una orientació pugui tenir valors més grans de 90 o 180 graus, però la selecció d’un component d’orientació sempre produirà valors entre –180 i 180 graus. A més, els resultats d’una operació de selecció poden ser diferents dels valors d’entrada, els quals s’utilitzen per generar l’orientació. Això és degut a l’ambigüitat de les instruccions d’angles al món matemàtic Per solucionar aquests problemes és necessari especificar els resultats detalladament:

• Per a := ANGLEX(RS,ori), b := ANGLEY(RS,ori) i c := ANGLEZ(RS,ori) s’ha de complir que: -180 <= a <=180 primera rotació sobre l’eix X -90 <= b <=90 segona rotació sobre l’eix Y -180 <= c <=180 tercera rotació sobre l’eix Z si b = -90 ó b = 90 llavors a := 0 (no hi ha rotació sobre l’eix X) i el valor de “c" ha de complir que ORIRS(a,b,c) és igual a l’orientació original

• Per a := ANGLEX(XYZ,ori), b := ANGLEY(XYZ,ori) i c := ANGLEZ(XYZ,ori) s’ha de complir que: -180 <= a <=180 primera rotació sobre l’eix X -90 <= b <=90 segona rotació sobre l’eix Y -180 <= c <=180 tercera rotació sobre l’eix Z


34

si b = -90 ó b = 90 llavors a := 0 (no hi ha rotació sobre l’eix X) i el valor de “c" ha de complir que ORIXYZ(a,b,c) és igual a l’orientació original

• Per a := ANGLEY(YXZ,ori), b := ANGLEX(YXZ,ori) i c := ANGLEZ(YXZ,ori) s’ha de complir que: -180 <= a <=180 primera rotació sobre l’eix Y -90 <= b <=90 segona rotació sobre l’eix X -180 <= c <=180 tercera rotació sobre l’eix Z si b = -90 ó b = 90 llavors a := 0 (no hi ha rotació sobre l’eix Y) i el valor de “c" ha de complir que ORIYXZ(a,b,c) és igual a l’orientació original

• Per a := ANGLEZ(ZYZ2,ori), b := ANGLEY(ZYZ2,ori) i c := ANGLEZ2(ZYZ2,ori) s’ha de complir que:

-180 <= a <=180 primera rotació sobre l’eix Z 0 <= b <=180 segona rotació sobre l’eix Y -180 <= c <=180 tercera rotació sobre l’eix Z si b = 0 ó b = 180 llavors a := 0 (no hi ha rotació sobre l’eix Y) i el valor de “c" ha de complir que ORIZYZ2(a,b,c) és igual a l’orientació original

• Per a := ANGLEZ(ZYX,ori), b := ANGLEY(ZYX,ori) i c := ANGLEX(ZYX,ori) s’ha de complir que: -180 <= a <=180 primera rotació sobre l’eix Z -90 <= b <=90 segona rotació sobre l’eix Y -180 <= c <=180 tercera rotació sobre l’eix X si b = -90 ó b = 90 llavors a := 0 (no hi ha rotació sobre l’eix Y) i el valor de “c" ha de complir que ORIZYZ2(a,b,c) és igual a l’orientació original

• Per v := ROTAXIS(ori) i r := ROTANGLE(ori) s’ha de complir que:

”v” ha de ser un vector unitari 0 <= a <=180 rotació sobre l’eix v si r = 0 llavors v := ( 0, 0, 1 ) (paral·lel a l’eix Z) si r = 180 llavors[(v.x > 0) or ((v.x = 0) and (v.y > 0)] o [(v.x = 0) and (v.y = 0) and (v.z = 1))]

3.10.4. Robot Target ROBTARGET descriu la posició i orientació del TCP (Tool Center Point) d’un robot industrial. Esta format per una part del tipus Pose que defineix la posició i l’orientació del TCP, parts del qual descriuen l’estat exacte dels eixos del robot i, si és necessari, la posició d’eixos addicionals


35

Exemple: un robot amb eixos addicionals. En aquest exemple STATUS descriu un grau addicional de llibertat. La relació entre els valors de INT i la configuració del robot dependent del sistema. TURNS descriu el nombre de rotacions de 360 graus fets per alguns eixos. R_NTURNS defineix el nombre màxim de joints en una cèl·lula que pot rotar més de 360 graus:

TYPE RECORD POSE: PSE; INT: STATUS; ARRAY[1..R_NTURNS] OF INT: TURNS; ADD_JOINT: A_JOINT; ENDRECORD = ROBTARGET;

3.10.5. Tipus Teach TeachTypeDeclaration:

TeachTypeDescription ":" TeachTypeIdentifier.

TeachTypeDescription: ( "TEACH" | "PERMANENT" ) PredefinedType.

TeachType:

TeachTypeIdentifier | TeachTypeDescription.

3.10.6. Joints El tipus JOINT descriu la posició del TCP d’un robot industrial en el sistema de coordenades de robot. La seva definició depèn del nombre d’eixos del robot. En funció del tipus de eix, els components poden ser angles o distancies. JOINT està compost pels components M_JOINT i A_JOINT del tipus MAIN_JOIN i ADD_JOINT, respectivament. MAIN_JOINT, ADD_JOINT i JOINT han de ser definits a l’especificació del sistema. Exemple: TYPE RECORD REAL: A1,A2,A3,A4,A5 ENDRECORD = MAIN_JOINT; RECORD REAL: AA1,AA2,AA3 ENDRECORD = ADD_JOINT; RECORD MAIN_JOINT: M_JOINT; ADD_JOINT : A_JOINT ENDRECORD = JOINT;


36

4. EXPRESSIONS I OPERACIONS Expression:

"+" Expression | "-" Expression | "NOT" Expression | Expression Operator Expression | Object | IntegerConstant | RealConstant | BooleanConstant | CharacterString | CallOrRecord | Precedence | ArrayInit.

Precedence:

"(" [ ValueList ] ")".

Object: Identifier | ArrayOrListElement | RecordComponent.

RecordComponent:

Object "." ComponentIdentifier.

ArrayOrListElement: Object "[" ArrayExpressionList "]".

ArrayExpressionList:

Expression { "," Expression }. Per interpretar les expressions tenim els operadors. Els operadors en IRL, de major a menor prioritat, són els següents:

NOT, + , - *, / , MOD, DIV, @ +, - <, >, >=, <= =, <> AND EXOR, OR


37

Aquests es poden dividir en diferents tipus:

OPERADORS DESCRIPCIÓ + Addition - Subtraction & sign operator / division * multiplication

DIV integer division

Aritmètics

MOD modulo function AND logical and OR logical or

NOT logical not Booleà

EXOR exclusive or = equal > greater < less

<> not equal >= greater equal

Lògics

<= less equal + addition - subtraction / division * multiplication

Geomètrics

@ relative trans.& rotat.


38

5. IDENTIFICADORS PREDEFINITS 5.1. Variables predefinides Les variables i constants predefinides no han de ser declarades per l’usuari. Variables protegides d’escriptura:

CONSTANT TIPUS SIGNIFICAT R_ACT_ROB R_SPEC_TYPE Robot actual

R_TARGET_BASE POSE Cèl·lula actual base del sistema de coordenades

R_DEF_ORI STRING Mode d’orientació per defecte Variables de trigger utilitzades a SynactStatements ( No suportat per COSIMIR):

CONSTANT TIPUS SIGNIFICAT

R_MOVE_TIME REAL Temps que passa des del començament del moviment actual del robot

R_SCALE_FORW REAL Factor (%) de la distancia recorreguda pel moviment

R_SCALE_BACK REAL Factor (%) de la distancia que encara queda per recórrer

R_DISTANCE_FORW REAL Distància des del punt de sortida (només a moviments LIN i CIRCLE)

R_DISTANCE_BACK REAL Distància al punt final (només a moviments LIN i CIRCLE)

5.2. Constants predefinides Els valors d’aquestes constants a de ser definit a l’especificació del sistema Constant predefinida

CONSTANT TIPUS SIGNIFICAT

R_NTURNS INT Nombre de joints que poden rotar més de 360 graus

R_NADDJ INT Nombre màxim de joints addicionals R_NJ INT Nombre de joints RS (Fixa: 'RS' ) STRINGXYZ (Fixa: 'XYZ') STRINGYXZ (Fixa: 'YXZ') STRINGZYX (Fixa: 'ZYX') STRINGZYZ2 (Fixa: 'ZYZ2') STRINGVANG (Fixa: 'VANG') STRINGQUAT (Fixa: 'QUAT') STRING

Especifiquen diferents descripcions d’orientacions utilitzats a les funcions de sistema per assignar orientacions, instruccions de write i read

NO_ADAX_CONTROL INT Especifica el tipus de coordenada de moviment per defecte

TCP_KEEP INT La coordenada mundial de posició TCP es manté


39

TCP_KEEP_REL INT La posició TCP relativa al dispositiu es manté

DEVICE_REL INT Especifica l’execució de moviment relativa al dispositiu

R_PROCESS_READY INT Procés preparat (retornada per la funció getstatus)

R_PROCESS_RUNNING INT Procés executant-se (retornada per la funció getstatus)

R_PROCESS_STOPPED INT Procés aturat (retornada per la funció getstatus)

R_PROCESS_BLOCKED INT Procés bloquejat (retornada per la funció getstatus)

R_DEVICE_NUMBER INT Nombre de dispositius en la cèl·lula

AX_NONE INT No hi ha dispositiu en l’especificació de grup de dispositius

AX_MAIN INT Especifica l’eix principal

ADAX_IS INT Especifica l’eix addicional que comença la cadena cinemàtica

ADAX_IE INT Especifica l’eix addicional que acaba la cadena cinemàtica

ADAX_EX INT Especifica l’eix addicional extern Per cada robot definit per la Especificació del Robot existeix un record predefinit amb el nom del robot. Cada record consisteix en els següents components (alguns estan protegits contra escriptura fora del sistema d’especificació):

NOM TIPUS PROT. SIGNIFICAT R_ACC REAL No Acceleració (path)

R_ACC_PTP ARRAY[1..R_NJ] No Factor d’acceleració (eix, %)

R_C_PTP REAL No Path smoothing: distancia de l’eix (factor, %)

R_C_CP REAL No Path smoothing: distancia al punt intermig

R_C_SPEED REAL No (% de la velocitat programada)

R_JOINT_ACTR_AJV JOINT Si Posició actual del robot al sistema de coordenades del robot

R_ROBTARGET_ACT ROBTARGET Si Posició actual del robot R_ROBTARGET_ACT.PSE ROBTARGET Si Posició actual del robot R_CTUP POSE Si Punt actual de l’eina

R_ROBTARGET_START ROBTARGET Si

Posició del robot al començament de la instrucció de moviment actual

R_ROBTARGET_END ROBTARGET Si

Posició del robot que ha de ser aconseguida al final de l’actual instrucció de moviment

R_ROBTARGET_INTER ROBTARGET Si Posició del robot a l’ultima


40

interrupció executada R_SPEED_ACT REAL Si Velocitat actual (path) R_SPEEDR_PSTU REAL No Velocitat (path)

R_SPEED_PTP ARRAY[1..R_NJ] No Factor de velocitat (eixos, %)

R_SPEED_ORI REAL No Velocitat d’orientació

R_BASER_TUB POSE No Actual sistema de coordenades de la base del robot

R_TOOLR_TTM POSE No Correcció actual de l’eina 5.3. Funcions predefinides pel tractament de strings

No totes aquestes funcions són suportades per COSIMIR i PCROB APPENDC(STRING,CHAR) retorna STRING Concatena el caràcter “c” al final del

string s COMPARE(STRING, STRING) retorna INT Compara el string “s1” amb “s2”.

Retorna l’índex del primer caràcter diferent. Si els dos strings són iguals retorna un 0

CONCATS(STRING, STRING) retorna STRING Concatena els caràcters del string “s2” amb els del “s1”

DELETEC(STRING, INT, INT) retorna STRING Esborra els caràcters del string “s” especificats per l’enter “i1” (start index) i l’enter “i2” (final index). Si el segon índex és menor que el primer no s’esborrarà res

EXTRACTS(STRING, INT, INT) retorna STRING Extreu la part del string “s” especificada per l’enter “i1” (start index) i l’enter “i2” (final index). Si el segon índex és menor que el primer retorna un string buit.

GETCHR(STRING, INT) retorna CHAR Pren un caràcter del string “s” indexat per l’enter “i”

LENGTH(STRING) retorna INT Retorna la longitud (nombre de caràcters) del string “s”

LOCATE(STRING, STRING) retorna INT Comprova si la cadena “s2” és una subcadena de “s1”. Si és així retorna el primer índex de “s1” on comença “s2”. Si no, retorna 0

SETCHR(STRING, CHAR, INT) retorna STRING Copia el string “s”, posa al caràcter “c” el caràcter de “s” indexat per “i”

SIZE(STRING) retorna INT Retorna el tamany màxim de “s” 5.4. Funcions predefinides per operacions matemàtiques

No totes aquestes funcions són suportades per COSIMIR i PCROB ABS(REAL) retorna REAL Valor absolut INT(-"-) retorna INT ACOS(REAL) retorna REAL Arc cosinus. Resultat dins de l’interval [0,180] ASIN(REAL) retorna REAL Arc sinus, Resultat dins de l’interval [-90,90] ATAN2(REAL, REAL) retorna REAL Arc tangent 2. Resultats dins de l’interval

(-180,180] són iguals al component arc de les coordenades polars del valor cartesià parell(x,y)


41

COS(REAL) retorna REAL Cosinus (unitat: graus) CROSS(POSITION, POSITION) retorna POSITION Producte vectorial DOT (POSITION, POSITION) retorna REAL Producte escalar FLOAT (INT) retorna REAL Conversió a float INV(POSE) retorna POSE Inversa del Pose ROUND(REAL) retorna INT Retorna el enter més proper SIN(REAL) retorna REAL Sinus (unitat: graus) SQRT(REAL) retorna REAL Arrel quadrada TAN(REAL) retorna REAL Tangent (unitat: graus) TRAFO(JOINT) retorna ROBTARGET Transformació dels eixos en coordenades

cartesianes en funció de la base actual (R_BASE) i la correcció de l’eina (R_TOOL) del robot actual (R_ACT_ROBOT) i en (R_TARGET_BASE)

TRAFOINV(ROBTARGET) retorna JOINT Transformació de les coordenades cartesianes en eixos en funció de la base actual (R_BASE) i la correcció de l’eina (R_TOOL) del robot actual (R_ACT_ROBOT) i en (R_TARGET_BASE)

TRUNC(REAL) retorna INT Conversió a un valor enter ignorant els dígits decimals Les funcions que treballen amb tipus de dades geomètrics estan descrits al punt 3.10.3. Tipus Orientació (Orientation Data Types) 5.5. Altres funcions predefinides EOF (FileType) retorna BOOL Ens diu si hem arribat al final del fitxer EOL(FILE OF CHAR) retorna BOOL Ens diu si hem arribat al final de la línia CHR(INT) retorna CHAR Retorna el caràcter amb el codi ASCII igual al valor del

paràmetre ORD(CHAR) retorna INT Retorna el valor del codi ASCII del caràcter


42

6. OBSERVACIONS Els comentaris de codi es fan així : ''{''Aquest text és un comentari i es fa entre claus''}'' 6.1. Unitats Velocitat (path) [mm/s] Acceleració (path)[mm/(s*s)] Distancia [mm] Angle [graus] Temps [seg] Velocitat (eix) factor real (%) del valor màxim Acceleració (eix) factor real (%) del valor màxim 6.2. Convencions Definició de símbols utilitzats a aquest manual: : definit com | alternatiu [x] cap o una aparició de x {x} cap, una o múltiples aparicions de x (x|y) selecció de x o y "xyz" símbol xyz del terminal " " El que es troba entre cometes és un símbol que s’ha de posar al escriure la instrucció Tot el que està en color gris no és suportat per COSIMIR


43

7. EXEMPLE En aquest exemple consisteix en que el robot desplaça 4 peces des d’una cadena fins una taula. PROGRAM Packaging; {Importació de les posicions} IMPORT DATALIST ‘..\Position List\Packaging.psl’; {--------------- Declaració de variables ----------------} VAR INPUT BOOL: PartAtEnd AT 0; OUTPUT BOOL: CloseGripper AT 0; OUTPUT BOOL: StartBelt AT 1; OUTPUT BOOL: NextPart AT 2; VAR TEACH POSE: GraspPosition, PalletPosition; TEACH MAIN_JOINT:SavePositionLefty, SavePositionRighty; VAR INT: iPackageNr; {número de peça} {---------------- Rutines utilitzades -------------------} PROCEDURE GetNextPart(); {Aparició de les peces a la cadena}

BEGIN NextPart := 0; NextPart := 1; StartBelt := 1; ENDPROC; PROCEDURE MovePart(INOUT INT: posID); {Col.locació de la peça a la taula}

VAR POSE: actposition;

BEGIN actposition := PalletPosition; CASE posID OF | 2 :actposition.pos.x := actposition.pos.x–260; | 3 :actposition.pos.y := actposition.pos.y–260; | 4 :actposition.pos.x := actposition.pos.x–260; actposition.pos.y := actposition.pos.y–260; END CASE; R_SPEED := 30.0; MOVE PTP actposition @ POSITION(0.0, 0.0, -300.0);


44

MOVE PTP actposition; CloseGripper := 0; MOVE PTP actposition @ POSITION(0.0, 0.0, -300.0); ENDPROC; PROCEDURE GraspPart(IN POSE: graspposition); {Tractament a la cadena}

BEGIN MOVE PTP graspposition @ POSITION(0.0, 0.0, -500.0); WAIT FOR PartAtEnd = TRUE; MOVE PTP graspposition; CloseGripper := 1; MOVE PTP graspposition @ POSITION(0.0, 0.0, -500.0); ENDPROC; {-------------------- Bucle principal -------------------} BEGIN GetNextPart(); FOR iPackageNr := 1 to 4 MOVE PTP savePositionRighty; GraspPart(GraspPosition); GetNextPart(); MOVE PTP SavePositionLefty; MovePart(iPackageNr); ENDFOR; MOVE PTP SavePositionRighty; ENDPROGRAM;

manual irl – robÒtica - fibrob/protegit/manuals/manualirl.pdfmanual irl – robÒtica - fib 1...

Documents