ESPRIT Année universitaire 2021/2022

TP 1 - Transformations homogènes
et modèle géométrique d'un robot
Le but de ce TP est de développer des fonctions sous Matlab qui permettent de définir des
transformations homogènes et de calculer le modèle géométrique direct (MGD) d’un
manipulateur. Le modèle géométrique inverse (MGI) d’un simple manipulateur à 2 DDL sera
aussi consideré.
Un compte rendu avec les méthodes proposées ainsi que les résultats intermédiaires est à rendre
à la fin de la séance par chaque étudiant. Il est à noter que du simple code n’est pas un compte
rendu: commentez vos fonctions et motivez vos choix dans votre rapport final.
Attention: Sélectionner la version à 64 bits au démarrage de Windows.
Une brève introduction à Matlab
Le logiciel Matlab est un logiciel de manipulation de données numériques et de programmation
dont le champ d’application est essentiellement les sciences appliquées. Son objectif, par
rapport aux autres langages, est de simplifier au maximum la transcription en langage
informatique d’un problème mathématique, en utilisant une écriture la plus proche possible du
langage naturel scientifique.
Matlab est un logiciel interprété (donc sans phase préliminaire de compilation) qui exécute les
opérations demandées séquentiellement, avec possibilité de boucle, test et saut. Il ne manipule
que des données numériques et ne sait effectuer aucun calcul formel à priori.
L'écran de base comprend l'écran de contrôle, le Command Window, ainsi que des fenêtres
complémentaires permettant de suivre le fonctionnement général d'une application. Les
instructions frappées (ou collées) dans la Command Windows s'exécutent directement.
Les commandes peuvent être relancées dans la fenêtre Matlab simplement en remontant la liste
par ↑ et en validant la ligne par Return.
L'exécution d'une ligne provoque automatiquement l'affichage des résultats sous forme d'une
liste de données numériques. Cette fonctionnalité peut être bloquée en mettant un ";" à la fin de
chaque ligne de programme (préférable lorsque le calcul concerne une matrice de grande
dimension).
Tout programme enregistré sous l'extension ".m" peut être lancé depuis la Commande Windows
de Matlab, en frappant son nom (sous réserve que le chemin d'accès au fichier soit déclaré sous
Matlab, voir la commande Set Path du menu Fichiers.
La commande "help" ou "help nom-de-fonction" permet d'obtenir une aide sur le logiciel en
général, un Toolbox (ou boîte à outils) ou une fonction particulière. Toute variable utilisée est
rangée dans l'espace mémoire appelé workspace et y reste à moins d'effacer le workspace par
la commande "clear all". Le contenu du workspace peut être affiché par l'instruction "who"
(nom seul des variables) ou "whos" (noms avec description du type).
1. Ajouter l'entête suivant au texte :
function [sortie1, sorite2,...] = nom_fonction(par_entree1,par_entree2,...)
Instruction 1 % Commentaire à l'instruction 1

1
Maher MKHININI & Talel Zouari
ESPRIT Année universitaire 2021/2022

Instruction 2
...
End
Exemple :
Par exemple, si on souhaite faire une fonction produit, qui calcule et renvoie en sortie le produit
de deux scalaires pass´es en param`etre, on ´ecrira dans le fichier produit.m :

>>function x=produit(a,b)
>>x=a*b
>>end
Pour tester cette fonction, placez-vous (`a l’aide de l’explorateur de fichiers Matlab) dans le
r´epertoire qui contient le fichier produit.m et on ´ecrira dans la fenˆetre de commande :
>> produit(2,3)

2.Sauvegarder le texte avec comme nom de fichier le nom ma_fonction.m (l'extension ".m" est
obligatoire pour être reconnue comme fonction) dans un répertoire accessible à Matlab. Une
fois sauvegardée, la fonction est utilisable dans tout programme, comme toute autre fonction
du noyau Matlab.
Pratique :
Créer un fichier.m qui s’intitule TP1AtelierRobotique.m
Rotations et transformations de matrices
Cet exemple montre comment effectuer des rotations et des transformations en 3D à l'aide de
Symbolic Math Toolbox™ et des matrices.
Définir et tracer une surface paramétrique
Définissez la surface paramétrique x(u,v), y(u,v), z(u,v) comme suit.

>>syms u v
>>x = cos(u)*sin(v);
>>y = sin(u)*sin(v);
>>z = cos(v)*sin(v);

Créer des matrices de rotation

Créez des matrices 3x3 Rx, Ry et Rz représentant les rotations du plan d'un angle t autour des
axes x, y et z, respectivement.
>>syms t

>>Rx = [1 0 0; 0 cos(t) -sin(t); 0 sin(t) cos(t)]

>>Ry = [cos(t) 0 sin(t); 0 1 0; -sin(t) 0 cos(t)]
>>Rz = [cos(t) -sin(t) 0; sin(t) cos(t) 0; 0 0 1]

Tracez la surface en utilisant fsurf.

2
Maher MKHININI & Talel Zouari
ESPRIT Année universitaire 2021/2022

>>fsurf(x,y,z)
>>axis equal
fsurf(f) crée un graphique de surface de la fonction z = f(x,y) sur l'intervalle par défaut [-5 5]
pour x et y.
Rotation autour de chaque axe en trois dimensions
Tout d'abord, faites pivoter la surface autour de l'axe des x de 45 degrés dans le sens inverse
des aiguilles d'une montre.
>>xyzRx = Rx*[x;y;z];
>>Rx45 = subs(xyzRx, t, pi/4);

>>fsurf(Rx45(1), Rx45(2), Rx45(3))

>>title('Rotating by \pi/4 about x, counterclockwise')
>>axis equal

snew = subs(s,old,new) retourne une copie de s, en remplaçant toutes les occurrences de old par
new, puis évalue s
Faites une rotation autour de l'axe z de 90 degrés dans le sens des aiguilles d'une montre.
>>xyzRz = Rz*Rx45;
>>Rx45Rz90 = subs(xyzRz, t, -pi/2);

>>fsurf(Rx45Rz90(1), Rx45Rz90(2), Rx45Rz90(3))

>>title('Rotating by \pi/2 about z, clockwise')
>>axis equal

Faites une rotation autour de l'axe des y de 45 degrés dans le sens des aiguilles
d'une montre.
>>xyzRy = Ry*Rx45Rz90;
>>Rx45Rz90Ry45 = subs(xyzRy, t, -pi/4);

>>fsurf(Rx45Rz90Ry45(1), Rx45Rz90Ry45(2), Rx45Rz90Ry45(3))

>>title('Rotating by \pi/4 about y, clockwise')
>>axis equal
Mise à l'échelle et rotation
Mettez la surface à l'échelle par le facteur 3 le long de l'axe z. Vous pouvez
multiplier l'expression pour z par 3, z = 3*z. L'approche la plus générale
consiste à créer une matrice d'échelle, puis à multiplier la matrice d'échelle par
le vecteur de coordonnées.
>>S = [1 0 0; 0 1 0; 0 0 3];
>>xyzScaled = S*[x; y; z]
>>fsurf(xyzScaled(1), xyzScaled(2), xyzScaled(3))
>>title('Scaling by 3 along z')
>>axis equal
Faites pivoter la surface mise à l'échelle autour des axes x, y et z de 45 degrés
dans le sens des aiguilles d'une montre, dans l'ordre z, puis y, puis x. La
matrice de rotation pour cette transformation est la suivante.
>>R = Rx*Ry*Rz
Utilisez la matrice de rotation pour trouver les nouvelles coordonnées.
>>xyzScaledRotated = R*xyzScaled;
>>xyzSR45 = subs(xyzScaledRotated, t, -pi/4);
Tracez la surface.
>>fsurf(xyzSR45(1), xyzSR45(2), xyzSR45(3))
>>title('Rotating by \pi/4 about x, y, and z, clockwise')
>>axis equal

3
Maher MKHININI & Talel Zouari
ESPRIT Année universitaire 2021/2022

Vérifier les propriétés de la matrice de rotation R

Les matrices de rotation sont des matrices orthogonales. Ainsi, la transposée de R
est aussi son inverse, et le déterminant de R est 1.
>>simplify(R.'*R)

Exercice 1 : Rotations et transformations homogènes

1) Définir sous Matlab les matrices de rotation élémentaires 3x3 suivantes :

Rx(π), Ry(π), Rz(π).
 Vérifier que Rx(-π) = RTx(π) et Rz(-π) = RTz(π) où RT indique la
transposée de la matrice R.
 Vérifier que les colonnes des trois matrices Rx(π), Ry(π), Rz(π) ont norme
équale à 1 (tapez "help norm" sous Matlab) et qu’elles sont orthogonales à deux
à deux (pour le produit scalaire, tapez "help dot"sous Matlab).

2) Écrire trois fonctions Matlab, appelées Rx = Rot_x(), Ry = Rot_y() et Rz =

Rot_z(θ), qui prennent en entrée les angles , et θ respectivement (en radians), et
renvoient les matrices de rotation élémentaires Rx, Ry et Rz autour des axes x, y et z,
respectivement.

3) Écrire une fonction Matlab, appelée A = TransHom(Rt), qui prend en entrée la

matrice de rotation 3x3, R, et le vecteur de translation 3x1, t, et renvoie la matrice de
transformation homogène 4x4, A.

4) Utiliser les fonctions développées aux points b) et c) pour déterminer la matrice de

transformation homogène Ah correspondant à une rotation autour de l’axe y d’un angle
= π, suivie d'une translation le long de l’axe x et le long de l’axe z d’une longueur
dx = 2 m et dz = 1 m, respectivement.

5) Soit𝑝 = [0 0 1 1] 𝑇 un vecteur écrit en coordonnées homogènes. Déterminer le

vecteur transformé à travers la matrice Ah trouvée au point 4).
Exercice 2 : Modèle géométrique direct d'un robot planaire à 2 DDL

a) Développer une fonction Matlab, appelée P = MGD_2R(q), qui:

 Calcule le MGD d’un robot planaire à deux articulations rotoïdes (RR), et dont les
longueurs des segments sont a1 = 0.6 m, a2 = 0.4 m (voir la Fig. 1).
 La fonction fournit les coordonnées [px, py]T du point terminal P en fonction des
variables articulaires θ1 et θ2.
b) Tester cette fonction pour les valeurs des variables articulaires θ1 et θ2 suivantes :
[0, π/2]T, [0, 0]T, [-π/2, π/2]T, [π/2, 0]T.

4
Maher MKHININI & Talel Zouari
ESPRIT Année universitaire 2021/2022

Figure 1 : Robot planaire à 2 DDL (RR).

Exercice 3 :Modèle géométrique direct d’un robot quelconque

1) Écrire une fonction Matlab, appelée T = MGD_gen(a, alpha, d, theta), qui:

a. Calcule le MGD d’un robot (à chaîne simple ouverte) quelconque.
b. Les entrées a, alpha, d, theta, sont les vecteurs nx1 des paramètres de Denavit-
Hartenberg (DH) du robot (les unités de mesure sont mètres et radians).
c. La sortie T est la matrice de transformation homogène Tn0(q) qui donne la pose de
l’effecteur par rapport à sa base.
2) Tester la fonction « MGD_gen » sur:
a. Le manipulateur anthropomorphe (a2 = a3 = 0.6 m) pour les valeurs des
variables articulaires suivantes: [0, 0, 0]T et [-π/4, π/6, π/6]T.
b. Le manipulateur cylindrique (d1 = 0.4 m) pour les valeurs des variables
articulaires suivantes: [0, 0.25, 0.25]T et [π/3, 0, 0.4]T.
3) Ajouter les entrées qinf, qsup à la fonction « MGD_gen ». qinf, qsup sont les
vecteurs nx1 des butées articulaires du robot. Si les paramètres fournis par l'utilisateur ne
respectent pas les butées articulaires du robot, un message d'erreur
doit être affiché.
Exercice 4 :Modèle géométrique inverse d'un robot planaire à 2 DDL

Problème géométrique inverse: déterminer le vecteur des variables articulaires q d'un robot
permettant d'obtenir une situation désirée pour l’effecteur.
Le modèle géométrique direct du robot planaire en Fig. 2 est:
𝑃𝑥 = 𝑑2 𝑐𝑜𝑠𝜃1
𝑃𝑦 = 𝑑2 𝑠𝑖𝑛𝜃1

5
Maher MKHININI & Talel Zouari
ESPRIT Année universitaire 2021/2022

Une démarche analytique simple permet de déterminer le modèle géométrique

inverse du robot. En effet, nous avons :

𝑃𝑦
𝜃1 = arctan( )
𝑃𝑥
𝑑2 = √𝑝𝑥2 + 𝑝𝑦2

Écrire une fonction Matlab, appelée [theta1, d2] = MGI_RP(px, py), qui prend en entrée les
coordonnées du point P (voir la Fig. 2) et renvoie les variables articulaires du robot.
Remarque: Pour plus de robustesse dans le calcul de θ1, la fonction arc tangente à
2 arguments (tapez "help atan2" sous Matlab) est à préférer.

Figure 2 : Robot planaire à 2 DDL (RP).

6
Maher MKHININI & Talel Zouari