Vous êtes sur la page 1sur 3

Manipulation n˚1 :

GENERATION DE MOUVEMENT
ET SYSTEME DE COMMANDE

1 Introduction
Le but de ce TP est d’étudier quelques modes de génération de mouvement à effectuer par un
robot. L’exemple considéré est celui du robot plan RPR représenté ci-dessous. La situation
X de l’effecteur est décrite par ses coordonnées cartésiennes (x, y) ainsi par l’angle α du
dernier segment avec l’horizontale, à savoir X = (x, y, α)T . Les coordonnées articulaires
sont données par Q = (θ1 , r2 , θ3 )T .

y0
E α
re

θ3

r2

θ1
x0

Figure 1: Représentation filaire du robot.

L’objet de cette manipulation est la génération des consignes Q(t) à envoyer aux asservisse-
ments des actionneurs afin de réaliser un déplacement de l’effecteur entre une position initiale
et une position finale, positions décrites dans l’espace opérationnel respectivement par Xi et
Xf . Deux options sont proposées:
Les fonctions Q(t) sont générées par interpolation sur la seule base des configurations
initiale et finale du robot (trajectoire libre dans l’espace opérationnel),
Les fonctions Q(t) sont déduites d’une trajectoire établie dans l’espace opérationnel,
et ce en procédant à une inversion numérique du Jacobien.

Programmation et Simulation graphique


La programmation est réalisée sous MATLAB/Simulink. Les données pour la simulation
sont fixées comme suit:
Position initiale et finale: Xi = [1.5, −0.4, 0], Xf = [1, 0.4, 0],
Durée de la simulation et pas de calcul: T = 5s, te = 0.1s,
Donnée géométrique: re = 0.35
Une fonction nommée Trace(Qt,Xf) permet de réaliser une animation graphique du pro-
gramme réalisé. L’argument Qt est une matrice de taille 3xNT (NT=nombre de points de
calculs), et Xf un vecteur de taille 1x3 donnant les coordonnées de Xf.
TP Génération de mouvement et système de commande 3

2 Etude préalable
1. Donner l’expression du modèle géométrique direct X = f (Q).
2. Donner l’expression du modèle géométrique inverse Q = f −1 (X)
3. Donner l’expression du jacobien J du robot

3 Programmation des modèles


Dans cette première phase, des fonctions Matlab décrivant les différents modèles précédents
sont crées. Nous y ferons appel lors des générations de trajectoire souhaitées.

1. Ecrire une fonction Matlab X=MGD(Q) dont le rôle est de calculer le modèle géométrique
direct du robot.
2. Ecrire une fonction Matlab Q=MGI(X) dont le rôle est de calculer le modèle géométrique
inverse du robot. On utilisera les commandes sqrt et atan2 pour calculer les racines
et arc tangentes.
3. A l’aide de l’expression du Jacobien, écrire une fonction Matlab dQ=InvJacob(u) dont
le rôle est de calculer les accroissements dQ en fonction de dX et de Q. le vecteur u
de dimension 6 de cette fonction aura respectivement dX et Q pour trois premières et
trois dernières composantes (c’est à dire dX=u(1:3); et Q=u(4:6);).

4 Génération de mouvements
4.1 Interpolation
D’une manière générale, pour définir une trajectoire en fonction du temps t ∈ (0, T ), disons
Z(t) (qui pourra être selon le cas X(t) ou Q(t)), entre une position initiale Zi et une posi-
tion finale Zf , une loi possible consiste à utiliser une interpolation polynomiale de degré 3.
L’équation définissant Z(t) s’écrit alors:
Z(t) = Zi + d(t) (Zf − Zi ) avec d(t) = 3 (t/T )2 − 2 (t/T )3 .
˙
La fonction d(t) ainsi choisie, avec d(0) = d(0) = d(T ) = d(T ˙ ) = 0, permet d’assurer un
déplacement avec des vitesses nulles au départ et à l’arrivée.

4.2 Trajectoire libre dans l’espace opérationnel


Dans cette approche, la connaissance des positions initiale Xi et finale Xf , suffit à générer
une lois Q(t) qui servira de consigne aux actionneurs du robot. Elle a pour avantage de pou-
voir exploiter les capacités des actionneurs en terme de vitesses et accélérations admissibles.
La trajectoire dans l’espace de travail (opérationnel) n’est par contre pas maı̂trisée.

1. Ecrire un programme Matlab basé sur la fonction MGI et permettant de calculer la


trajectoire Q(t) selon la règle établie au paragraphe 4.1. Utiliser la fonction Trace
pour visualiser le déplacement du robot.

4.3 Trajectoire imposée dans l’espace opérationnel


Lorsque la maı̂trise du déplacement du robot entre ses point de départ et arrivée s’avère
nécessaire, par exemple pour éviter un obstacle ou mieux connaı̂tre la position de l’effecteur
TP Génération de mouvement et système de commande 4

durant tout son déplacement, une génération de trajectoire dans l’espace opérationnel (c’est
à dire l’élaboration d’une loi X(t)) s’avère nécessaire. L’objet de ce paragraphe est, con-
naissant la loi X(t), de générer la consigne des actionneurs (Q(t)) par inversion en ligne du
Jacobien précédemment calculé.

1. Sous Simulink, réaliser le schéma de simulation de la figure 1 ci dessous et utilisant les


fonctions MGD et InvJacob precedemment crées.
2. Ecrire un programme Matlab permettant d’exécuter le schéma Simulink précédent
après avoir défini la trajectoire dans l’espace opérationnel X(t) selon le paragraphe
4.1. On utilisera la fonction sim pour exécuter depuis Matlab le programme Similink
ci-dessus. On veillera à initialiser l’intégrateur du schéma à la valeur Qi. Utiliser la
fonction Trace pour visualiser le déplacement.

[t',Xt]
MATLAB 1
10 Qt
From Function s
Workspace
Inv Jacobien To Workspace

MATLAB
Function
MGD
Exemples de programmes à compléter

function X = MGD(Q) function dQ = InvJacob(u)


% Calcul du modèle géométrique direct % Inversion du modèle cinématique
global re global re
Theta1 = Q(1); R2 = Q(2); Theta3 = Q(3); dX=u(1:3); Q=u(4:6);
theta1=Q(1); r2=Q(2); theta3=Q(3);
xe = R2*cos(Theta1)+....;
ye = ... ; J=[-r2*sin(theta1) -... ....;
alpha =....; .... ..... ....;
.... .... ....];
X = [xe ye alpha]’;
dQ=J\dX;

%Génération de trajectoire Q(t) libre


clear;
global re NT
T=5; te=0.1; t=0:te:T;
NT=length(t);re=.35;

%%Configurations initilale et finale


X_i=[1.5 -0.4 0]; Q_i=mgi(X_i);
X_f=....; Q_f=...;

%% Calcul de Q(t) (à faire)


.....
%%Animation du déplacement du robot
Trace(Qt,X_f)