Chapitre 01
Introduction & contexte automate

1. Cinématique : de quoi parle-t-on ?

Un robot manipulateur série est une chaîne de corps rigides (segments) reliés par des liaisons motorisées — le plus souvent rotoïdes (rotation) ou prismatiques (translation). La cinématique est l'étude du mouvement de cette chaîne sans se soucier des forces qui le produisent : elle relie les variables des liaisons à la position et à l'orientation de l'outil.

On distingue deux problèmes symétriques :

• La cinématique directe (forward kinematics, FK) : connaissant les variables articulaires, où est l'effecteur et comment est-il orienté ? C'est un calcul déterministe, unique, sans singularité de résolution — le cœur de ce cours.
• La cinématique inverse (inverse kinematics, IK) : quelle configuration articulaire atteint une pose cartésienne donnée ? Problème inverse, parfois sans solution, parfois multiple. Nous ne l'abordons ici qu'au travers du Jacobien (chapitre 6), qui en est la porte d'entrée.

La cinématique directe est la brique de base de presque tout le reste : suivi de trajectoire, transformation d'un point outil, détection de collision, et surtout calibration (chapitre 7), qui identifie les paramètres géométriques réels du robot à partir de mesures. La maîtriser proprement, c'est se donner un socle fiable pour tout l'atelier logiciel du robot.

2. Repères, pose et espaces

À chaque corps du robot on attache un repère orthonormé direct. Le repère R₀ est la base (le monde, fixe) ; le repère R_n est l'effecteur (l'outil). La pose d'un repère par rapport à un autre, c'est le couple :

où SO(3) est le groupe des matrices de rotation 3×3 (R^TR = I, det R = +1), et l'ensemble des poses forme le groupe SE(3) des déplacements rigides. Une pose se code de façon compacte par une matrice homogène 4×4 (chapitre 2).

Deux espaces cohabitent en permanence, et tout le métier consiste à passer de l'un à l'autre :

3. Conventions de notation du cours

Ces conventions sont tenues dans tous les chapitres. En cas de doute, revenez ici.

4. Pourquoi de la cinématique sur un automate ?

Historiquement, la cinématique vit dans la baie de commande propriétaire du robot (KUKA, ABB, Fanuc…). Mais de plus en plus de machines sont pilotées par un automate programmable industriel (PLC) — Beckhoff TwinCAT, CODESYS, Siemens, Omron… — qui orchestre déjà les convoyeurs, la sécurité et les E/S. Y intégrer la cinématique du robot (ou d'un axe cartésien « maison ») apporte :

• une synchronisation parfaite avec le reste de la machine (même horloge de tâche) ;
• un déterminisme dur : le calcul s'exécute dans une tâche cyclique à période fixe (250 µs, 1 ms…) ;
• l'ouverture : on maîtrise le modèle, on peut le calibrer et l'adapter, sans boîte noire.

La norme IEC 61131-3 définit les langages de programmation des automates. Cinq langages coexistent (LD à contacts, FBD blocs, SFC grafcet, IL liste d'instructions, et ST — Structured Text). Pour du calcul mathématique matriciel, Structured Text s'impose : c'est un langage textuel proche du Pascal, avec boucles FOR, tableaux, structures et flottants. Tout le code de ce cours est en ST.

5. Structures de données Structured Text

Un automate n'a pas de tas (pas de malloc) : toute la mémoire est allouée statiquement. On travaille donc avec des tableaux de taille fixe, ce qui tombe bien pour la cinématique où les dimensions (3, 4, nombre d'axes) sont connues à la compilation. Voici les types réutilisés dans tout le cours ; placez-les dans une liste de types global (GVL de types / DUT).

// ---- Types de base réutilisés dans tout le cours ----

TYPE T_VEC3 : ARRAY[0..2] OF LREAL; END_TYPE            // vecteur 3×1  (m ou sans dim.)
TYPE T_MAT3 : ARRAY[0..2, 0..2] OF LREAL; END_TYPE      // rotation 3×3
TYPE T_MAT4 : ARRAY[0..3, 0..3] OF LREAL; END_TYPE      // transformation homogène 4×4

// Une pose = position + orientation. Deux représentations pratiques :
TYPE T_POSE :
STRUCT
    x   : LREAL;   // position (m)
    y   : LREAL;
    z   : LREAL;
    R   : T_MAT3;  // orientation (matrice de rotation)
END_STRUCT
END_TYPE

// Paramètres de Denavit-Hartenberg d'une liaison (voir chapitre 3).
// theta et d contiennent les OFFSETS constants ; la variable articulaire
// est ajoutée à part lors de la cinématique directe.
TYPE T_DH :
STRUCT
    theta       : LREAL;  // rad — offset (souvent 0)
    d           : LREAL;  // m
    a           : LREAL;  // m
    alpha       : LREAL;  // rad
    isPrismatic : BOOL;   // TRUE = liaison prismatique, FALSE = rotoïde
END_STRUCT
END_TYPE

Deux briques d'algèbre linéaire reviennent sans cesse : la matrice identité et le produit de deux matrices 4×4. On les code une fois pour toutes. Notez le passage par VAR_IN_OUT pour éviter toute copie inutile de la matrice résultat — un réflexe temps réel.

// Remplit M avec la matrice identité 4×4.
FUNCTION Mat4Identity : BOOL
VAR_IN_OUT
    M : T_MAT4;
END_VAR
VAR
    i, j : INT;
END_VAR
    FOR i := 0 TO 3 DO
        FOR j := 0 TO 3 DO
            IF i = j THEN M[i, j] := 1.0; ELSE M[i, j] := 0.0; END_IF
        END_FOR
    END_FOR
    Mat4Identity := TRUE;
END_FUNCTION

// Produit matriciel C := A * B  (4×4). C doit être DISTINCT de A et B.
FUNCTION Mat4Mul : BOOL
VAR_IN_OUT
    A : T_MAT4;
    B : T_MAT4;
    C : T_MAT4;   // résultat
END_VAR
VAR
    i, j, k : INT;
    acc     : LREAL;
END_VAR
    FOR i := 0 TO 3 DO
        FOR j := 0 TO 3 DO
            acc := 0.0;
            FOR k := 0 TO 3 DO
                acc := acc + A[i, k] * B[k, j];
            END_FOR
            C[i, j] := acc;
        END_FOR
    END_FOR
    Mat4Mul := TRUE;
END_FUNCTION

6. Le modèle mental temps réel du PLC

Un automate exécute son programme dans une tâche cyclique : à chaque période T_cycle (p. ex. 1 ms), il lit les entrées, exécute tout le code, écrit les sorties — puis attend la période suivante. Deux règles d'or en découlent pour notre calcul :

• Budget de temps borné. Tout le code doit tenir largement dans T_cycle, dans le pire cas. Pas de boucle de longueur inconnue, pas d'attente. La cinématique directe d'un bras 6 axes, c'est quelques centaines de multiplications flottantes : quelques microsecondes, parfaitement borné.
• Zéro allocation, zéro récursion non bornée. Tout est en tableaux fixes sur la mémoire statique. On précalcule hors boucle tout ce qui est constant (offsets, cos α qui ne dépendent pas de q).

Exercices

FUNCTION DegToRad : LREAL
VAR_INPUT
    deg : LREAL;
END_VAR
    DegToRad := deg * 3.14159265358979 / 180.0;
END_FUNCTION

FUNCTION RadToDeg : LREAL
VAR_INPUT
    rad : LREAL;
END_VAR
    RadToDeg := rad * 180.0 / 3.14159265358979;
END_FUNCTION

PROGRAM P_TestIdentite
VAR
    I1, I2, R : T_MAT4;
    i, j      : INT;
    ok        : BOOL := TRUE;
    attendu   : LREAL;
END_VAR

// --- corps ---
Mat4Identity(M := I1);
Mat4Identity(M := I2);
Mat4Mul(A := I1, B := I2, C := R);   // R := I * I

FOR i := 0 TO 3 DO
    FOR j := 0 TO 3 DO
        IF i = j THEN attendu := 1.0; ELSE attendu := 0.0; END_IF
        IF ABS(R[i, j] - attendu) > 1E-12 THEN ok := FALSE; END_IF
    END_FOR
END_FOR
// ok = TRUE si I*I = I

TYPE T_ROBOT6 :
STRUCT
    dh : ARRAY[0..5] OF T_DH;    // table Denavit-Hartenberg (6 liaisons)
    q  : ARRAY[0..5] OF LREAL;   // variables articulaires (rad ou m)
END_STRUCT
END_TYPE

Récapitulatif