Manipulation n˚1 : GENERATION DE MOUVEMENT ET SYSTEME

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 asservissements 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 programme 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
2
3
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
4.1
Génération de mouvements
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 position 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 .
˙
˙ ) = 0, permet d’assurer un
La fonction d(t) ainsi choisie, avec d(0) = d(0)
= d(T ) = d(T
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 pouvoir 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
4
TP Génération de mouvement et système de commande
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, connaissant 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
Function
From
Workspace
Inv Jacobien
10
1
s
Qt
To Workspace
MATLAB
Function
MGD
Exemples de programmes à compléter
function dQ = InvJacob(u)
function X = MGD(Q)
% Calcul du modèle géométrique direct % Inversion du modèle cinématique
global re
global re
dX=u(1:3); Q=u(4:6);
Theta1 = Q(1); R2 = Q(2); Theta3 = Q(3);
theta1=Q(1); r2=Q(2); theta3=Q(3);
xe = R2*cos(Theta1)+....;
J=[-r2*sin(theta1) -...
....;
ye = ... ;
....
.....
....;
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)