Tutorial sobre RobotStudio i Introducció a RAPID

1. Introducció a RobotStudio

RobotStudio és un entorn de simulació i programació fora de línia per a robots industrials ABB. Permet crear, provar, i optimitzar els programes de robots en un entorn virtual abans de desplegar-los en un robot físic. Això redueix el temps d'inactivitat i els costos associats amb la programació i configuració directa en el robot.

2. Possibilitats de RobotStudio

Simulació de Moviments: Crea i simula trajectòries per als robots sense necessitat de parar la producció real.
Programació Offline: Escriu programes de control de robots que després poden ser carregats en el robot físic.
Verificació de Col·lisions: Verifica que les trajectòries dels robots no col·lideixin amb altres objectes o robots en l'entorn.
Optimització de Cicles: Optimitza el temps dels cicles de treball per augmentar l'eficiència.

3. Primer Codi RAPID

A continuació es presenta un exemple bàsic de codi RAPID que mou un robot entre dos punts definits en l'espai 3D. Cada instrucció s'explica amb relació a conceptes matemàtics.


MODULE MainModule
    VAR robtarget p1:=[[500,0,600],[1,0,0,0],[0,0,1,0],[0,0,0,0]];
    VAR robtarget p2:=[[700,0,600],[1,0,0,0],[0,0,1,0],[0,0,0,0]];

    PROC Main()
        MoveL p1, v500, z10, tool0;
        MoveL p2, v500, z10, tool0;
    ENDPROC
ENDMODULE

Explicació del codi

MODULE MainModule: Aquesta línia defineix un mòdul (una agrupació de codi). Cada programa RAPID comença amb un mòdul.
VAR robtarget p1:=[[500,0,600],[1,0,0,0],[0,0,1,0],[0,0,0,0]];:
- robtarget: És un tipus de variable que defineix una posició i orientació del robot en l'espai 3D.
- [500,0,600]: Representa la posició cartesiana (x, y, z) en mil·límetres. Matemàticament, es tracta d'un vector de posició en l'espai 3D.
- [1,0,0,0]: Defineix l'orientació del robot mitjançant un quaternion, una estructura matemàtica per a representar rotacions sense problemes de singularitat.
- [0,0,1,0] i [0,0,0,0]: Representen la configuració del robot i les dades d'eixos externs, respectivament.
MoveL p1, v500, z10, tool0;:
- MoveL: Instrucció que mou el robot en una línia recta (trajectòria lineal) cap a la posició p1. Matemàticament, implica la interpolació lineal entre la posició actual i la posició objectiu.
- v500: Velocitat del moviment en mm/s.
- z10: Zona de precisió de 10 mm. Aquesta és la tolerància al voltant de la posició objectiu en la qual el robot pot començar el següent moviment. Matemàticament, això implica definir una esfera de radi 10 mm al voltant de p1.
- tool0: Defineix l'eina que el robot utilitza durant el moviment. Aquí, tool0 és l'eina per defecte, sovint la posició central o neutra del robot.
MoveL p2, v500, z10, tool0;: Aquesta instrucció repeteix el moviment, però cap a la posició p2, amb els mateixos paràmetres de velocitat, zona i eina.
PROC Main(): Defineix el procés principal on es descriuen les accions que el robot ha de seguir. En aquest cas, es mou primer a p1 i després a p2.
ENDPROC: Finalitza el procés.
ENDMODULE: Finalitza el mòdul.

4. Relació amb les Matemàtiques

En aquest exemple, les matemàtiques es troben en diversos elements clau:

Vectors i Coordenades: Les posicions p1 i p2 es defineixen com vectors de posició en un sistema de coordenades cartesiana 3D.
Quaternions: Els quaternions es fan servir per definir rotacions sense problemes de gimbal lock, un concepte matemàtic crucial en robòtica.
Interpolació Lineal: La instrucció MoveL realitza una interpolació lineal entre la posició actual del robot i la posició objectiu.
Zones de Precisió: Les zones de precisió defineixen esferes al voltant dels punts objectiu, que representen marges de tolerància per al moviment.

Tutorial: Cinemàtica Directa, Inversa i Matrius de Transformació per a Robots ABB

1. Introducció

Aquest tutorial està dissenyat per guiar a l'estudiant en l'aprenentatge de la cinemàtica directa i inversa per a robots ABB, utilitzant el model IRB 120 com a exemple. L'estudiant també aprendrà com utilitzar matrius de transformació per entendre millor els moviments i posicions del robot en l'espai tridimensional.

2. Cinemàtica Directa

2.1 Què és la Cinemàtica Directa?

La cinemàtica directa consisteix en determinar la posició i orientació de l'extrem final (efector final) del robot a partir dels valors dels angles de les seves juntes. En termes matemàtics, això implica calcular la transformació total des de la base del robot fins a l'extrem final.

2.2 Matrius de Transformació

Una matriu de transformació homogènia T es defineix com:


    T = | R  d |
        | 0  1 |

On R és la matriu de rotació 3x3 i d és el vector de translació 3x1. Aquestes matrius es multipliquen per obtenir la posició i orientació finals de l'efector.

2.3 Exemple de Codi RAPID per a Cinemàtica Directa

Aquí tens un exemple de codi RAPID per calcular la posició de l'efector final del robot IRB 120 utilitzant la cinemàtica directa:


MODULE MainModule
    CONST robtarget home := [[0,0,0],[1,0,0,0],[0,0,0,0],[0,0,0,0]];
    
    PROC Main()
        ! Moviment del robot a la posició inicial
        MoveJ home, v100, z10, tool0;

        ! Definir angles de les juntes (en graus)
        VAR num q1 := 30;
        VAR num q2 := 45;
        VAR num q3 := 60;
        VAR num q4 := 0;
        VAR num q5 := 0;
        VAR num q6 := 0;

        ! Convertir angles a radians
        q1 := DegToRad(q1);
        q2 := DegToRad(q2);
        q3 := DegToRad(q3);

        ! Matriu de transformació per la junta 1
        VAR matrix4x4 T01 := CalcT01(q1);

        ! Matriu de transformació per la junta 2
        VAR matrix4x4 T12 := CalcT12(q2);

        ! Matriu de transformació per la junta 3
        VAR matrix4x4 T23 := CalcT23(q3);

        ! Transformació total
        VAR matrix4x4 T03 := T01*T12*T23;

        ! Mostrar resultat
        PrintTrans(T03);
    ENDPROC

    FUNC matrix4x4 CalcT01(num q1)
        ! Calcula la transformació per la primera junta
        RETURN [[Cos(q1), -Sin(q1), 0, 0],
                [Sin(q1),  Cos(q1), 0, 0],
                [0,        0,       1, 0],
                [0,        0,       0, 1]];
    ENDFUNC

    FUNC matrix4x4 CalcT12(num q2)
        ! Calcula la transformació per la segona junta
        RETURN [[Cos(q2), 0,  Sin(q2), 0],
                [0,       1,  0,       0],
                [-Sin(q2),0,  Cos(q2), 400],
                [0,       0,  0,       1]];
    ENDFUNC

    FUNC matrix4x4 CalcT23(num q3)
        ! Calcula la transformació per la tercera junta
        RETURN [[Cos(q3), -Sin(q3), 0, 0],
                [Sin(q3),  Cos(q3), 0, 0],
                [0,        0,       1, 600],
                [0,        0,       0, 1]];
    ENDFUNC

    PROC PrintTrans(matrix4x4 T)
        ! Imprimeix la matriu de transformació
        Write 'Transformació T03:';
        Write T;
    ENDPROC
ENDMODULE

Explicació del Codi:

CalcT01, CalcT12, CalcT23: Són funcions que calculen les matrius de transformació per a cada junta. Aquestes matrius es deriven de les equacions de rotació i translació.
T03: És la matriu de transformació resultant, que multiplica les matrius individuals per obtenir la posició i orientació final de l'efector.
PrintTrans: Aquesta funció imprimeix la matriu resultant, permetent veure la posició final calculada del robot.

3. Cinemàtica Inversa

3.1 Què és la Cinemàtica Inversa?

La cinemàtica inversa es refereix al procés de determinar els valors dels angles de les juntes que posicionen l'efector final en una posició i orientació específiques. Aquest és un problema més complex que la cinemàtica directa i sovint té múltiples solucions.

3.2 Exemple de Codi RAPID per a Cinemàtica Inversa

Aquí tens un codi bàsic per implementar la cinemàtica inversa en el robot IRB 120:


MODULE MainModule
    PROC Main()
        ! Definir posició objectiu per a l'efector final
        VAR robtarget target := [[600,0,500],[1,0,0,0],[0,0,0,0],[0,0,0,0]];

        ! Resoldre la cinemàtica inversa per trobar els angles de les juntes
        VAR num q1, q2, q3;
        CalcInverseKinematics(target, q1, q2, q3);

        ! Moure el robot a la posició calculada
        MoveAbsJ [[q1,q2,q3,0,0,0]], v100, z10, tool0;
    ENDPROC

    PROC CalcInverseKinematics(robtarget target, VAR num q1, VAR num q2, VAR num q3)
        ! Resoldre la cinemàtica inversa per calcular els angles de les juntes
        ! Aquí s'implementaria la fórmula matemàtica per trobar q1, q2 i q3
        q1 := ATan2(target.trans.y, target.trans.x);
        q2 := SomeComplexMath(target);
        q3 := AnotherComplexCalculation(target);
    ENDPROC
ENDMODULE

Explicació del Codi:

CalcInverseKinematics: Aquesta funció calcula els angles necessaris de les juntes per moure l'efector final a la posició objectiu. Conté una implementació simplificada per a propòsits didàctics.
MoveAbsJ: Mou el robot als angles de les juntes especificades.
q1, q2, q3: Són els angles de les tres primeres juntes calculats mitjançant cinemàtica inversa.

4. Resum i Conclusions

En aquest tutorial, hem introduït els conceptes de cinemàtica directa i inversa, i hem explorat com calcular matrius de transformació per al robot ABB IRB 120. Aquestes tècniques són fonamentals per a la programació de robots industrials, ja que permeten controlar precisament la posició i orientació dels efectors finals.

Per aprofundir en aquests conceptes, és recomanable practicar amb diferents posicions i orientacions objectiu, així com explorar les solucions múltiples que sovint existeixen en cinemàtica inversa.