Université Paul Sabatier

Systeme linéaire Invariant II

- TP4 : Moteur -

Auteurs :
BEZIA Ayoub Pr
Encadrant :
Yann LABIT
TALEB Zahira

13 décembre 2017
Table des matières

Introduction 1

1 présentation du TP 2
1.1 But de travail : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.2 Présentation du procéde : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
2 IDENTIFICATION ET ANALYSE DU PROCÉDÉ : 3

3 Mise en place d'un retour d'état : 4

4 implémentation des observateurs : 5

4.1 observatuer identité : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
4.2 observateur minimal identité : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
4.3 observateur fonctionnel : . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
5 Implémentation Sur la procédé : 9

6 Conclusion 11

Annexes 13
Annexe 1 - code Matlab 13
Introduction

En automatique, la commande par retour d'état est un moyen de modier le comportement en boucle fermée
d'un système dynamique donné par une représentation d'état. Cette approche suppose l'état connu. Quand ce
n'est pas le cas, on peut utiliser un observateur d'état de manière à reconstruire l'état à partir des mesures
disponibles. Une nalité de la commande par retour d'état peut être de minimiser (ou maximiser) un indice de
performance . Ce peut être aussi d'obtenir un système en boucle fermée dont les pôles, c'est-à-dire les valeurs
propres de la matrice d'état, soient placés de manière appropriée. Ces pôles, en eet, déterminent le comporte-
ment du système.

un observateur d'état est une extension d'un modèle représenté sous forme de représentation d'état. Lorsque
l'état d'un système n'est pas mesurable, on conçoit un observateur qui permet de reconstruire l'état à partir
d'un modèle du système dynamique et des mesures d'autres grandeurs.

La théorie de l' observateur d'état a tout d'abord été introduite par Kalman et Bucy pour un système linéaire
dans un environnement stochastique (Filtre de Kalman-Bucy). Puis Luenberger (en) a fait une théorie générale
des observateurs pour les systèmes linéaires déterministes, introduisant notamment les notions d'observateur
réduit et d'observateur minima.

1
1 | présentation du TP

1.1 But de travail :

L'identication des paramètre et l'asservissement de la position d'un moteur a courant continue en utilisant
une commande par retour d'état basé observateur et un pré-compensateur de gain statique. et l'implémentation
de 3 type d'observateur identité, minimale et fonctionnelle.

1.2 Présentation du procéde :

- Figure 1 : schéma générale simplié du procédé -

- Figure 2 : schéma Bloc du procédé. -

vm (t) est la tension d'entrée du moteur.

θs (t) est la position de l'axe secondaire du moteur.

2
2 | IDENTIFICATION ET ANALYSE DU

PROCÉDÉ :

Comme Tm est le constant du temp du système Donc applique une entrée echlon d'amplitude 2 et on calcule
le temps reponce

- Figure 3 : La réponse du système réel-

Le temps de montée à 63% avec un signal d'entrée échelon (2 dans notre cas) .
Nous avons obtenu expérimentalement :
Tm = 0.28s.
Et on a Km* Kg = 1.18 donc km=1.18/kg=11.23.

2. la représentation d'état du système :

       
. Ks

 x 1 (t) 0 9Kg   x 1 (t) 0

  = +  u(t)
 . Km Kg
0 T−1

 x2 (t) x 2 (t) Tm
 m 

 h i x1 (t)
y(t) = 0 1 

 


 x2 (t)
2. les propriétés du système : la commandabilité :

La matrice C est de rang plein (rang=2 = nombre d'états) donc le système est commandable. Le fait que le
système soit commandable signie qu'il existe une commande U(t) dénie sur un intervalle ni Permettant de
faire évoluer (en un temps ni) le système d'un état initial quelconque a un état désire quelconque .
l'observabilité :    
C 1 0
O= = 
Ks
CA 0 9Kg

La matrice O est de rang plein (rang=2 = nombre d'états) donc le système est observable. Le fait qu'il soit
observable signie que l'on est capable d'estimer les états x1 et x2 à partir des variables de sortie y mesurées et
la commande u.

3
3 | Mise en place d'un retour d'état :

1 . vu que le système est observable et commandable on peut mise on place un retour d'état basé observateur.
et a l'aide des gain K on peut assurer une dynamique désiré au système et le gain N compense le gain statique
du système en boucle ferme.

2. calcule des gain K et N :

pour obtenir le gain K on qu'a imposé les valeurs propres désirés du système on boucle fermée A-BK et
ressoudes l'équation linéaire Vp(A-BK)=Vp(désiré) et l'aide de la commande acker() ou place() on peut la ré-
soudre.
et on a trouvé K=[0.8102 0.3492]

pour calculer le gain pré-compensateur N on doit calculer le gain statique du système on boucle fermé l'aide
de l'aide de la commande dcgain() ou applique la la formule suivante :
 
−1
Gs = − C ∗ (A − B ∗ K) ∗ B

et on pose N l'inverse de ce gain.

1
N=  
−1
− C ∗ (A − B ∗ K) ∗B

et on a trouvé N = 0.8081

3. la représentation d'etat du système on boucle fermé :

le model du systeme :

d'ou la représentation d'état :

 
h i x1
y= 0 1  
x2
- vu qu'on a supposé qu' on peut pas accéder a toute les états on doit construire un observateur.

4
4 | implémentation des observateurs :

4.1 observatuer identité :

1. on construit un observateur d'ordre 2 qui estime les deux états x1 (t) et x2 (t) a partir la connaissance de
la sortie y(s) et la commande u(t) :
les équations d'observateur identité :
.
z(t) = F z(t) + Gy(t) + Hu(t)

x
b = M z(t) + N y(t)
pour cet observateur on a :
M = I, N = 0, H=B et F = A − GC
pour déterminer le gain G on qu'a imposé les valeurs propres désirés V pdes de la matrice F=A-GC d'ob-
servateur et ressoudes l'équation linéaire V p(A − GC) = V pdes et l'aide de la commande acker() ou place() on
peut la résoudre.

2. on a posé des valeurs propre 2, 4 et 8 fois plus rapide que la dynamique de la boucle fermé et on a trouvé :

G2 = [−4.7714 − 1.1112]
G4 = [−5.9714 − 8.8710]
G8 = [−8.3714 − 40.7202].

3.implémentation sous Simulink :

Pour extraire les états réel sous Simulink on utilise un bloc `state space' et on met aux champs de la matrice
C la matrice identité puis on multiplie les états par la matrice C du système pour retrouver la sortie y

- Figure 4 : schéma bloc du système sous Simulink -

5
 on varie la valeurs du gain G calculés et on simule en posant des valeurs initiale non nulle pour le système,
et on compare la réponse du système avec la réponse d'un retour d'états basé sur les états réel du système :
résultat de simulation :
la sortie y(t) avec l'observateur 2 fois plus rapide :

la sortie y(t) avec l'observateur 4 fois plus rapide :

la sortie y(t) avec l'observateur 8 fois plus rapide :

on remarque que la sortie converge toujours vers la consigne désiré quelque soit les conditions initiales de
l'observateur et l'erreur entre l'états estimés et les états réel converge vers zéro .

on constat que si l'observateur est rapide l'erreur entre les états estimé et les états réel du système tend
rapidement vers zéro et la réponse ressemble parfaitement au réponse du système commandé par un retour
d'états basé sur les états réel du système.

on vois bien l'eet des conditions initiales sur le régime transitoire.ou ils changes la dynamique du système
désiré

6
4.2 observateur minimal identité :

vu que la sortie du système y(t) est l'état x1(t),on a pas besoin de l'estimé donc on construit un observateur
minimal qu' estime juste la deuxième état x2(t).

1. les équations de l'observateur minimal :

si on pose :

les équation d'observateur sont données comme suit :

avec : F = A22 − GA12

2. pour déterminer le gain G on qu'a imposé les valeurs propres désirés V pdes de la matrice F = A22 − GA12
d'observateur et ressoudes l'équation linéaire V p(A22 − GA12 ) = V pdes et l'aide de la commande acker() ou
place() on peut la résoudre

3. les valeurs de la boucle fermes sont les valeurs propres imposé par le retour d'état plus le valeur propre
d'observateur.
4. implémentation sous Simulink :

- Figure 5 : schéma bloc du système sous Simulink -

résultat de simulation :

on remarque pas un grand diérence entre la réponse du système commandé a l'aide d'observateur identité
et d'observateur minimal mais la réponse du minimal est plus proche de la sortie commandé par le retour d'état
calculé par les état réel.
c'est toute aect car normale l'état x1 n'est estimé et le calcule du retour d'états est basé sur l'états x1 réel,
donc on aura moins d'erreur et on évite l'eet des condition intaillais sur x1.

7
4.3 observateur fonctionnel :

1. les équations de l'observateur fonctionnel :

si on pose :

.
z(t) = F z(t) + Gy(t) + Hu(t)
x
b = M z(t) + N y(t)
pour cet observateur on a :
M = K2 , N = K1 − K2 ∗ T1 , H =T ∗B et F = A22 + T1 ∗ A12

pour déterminer le gain T1 on qu'a imposé les valeurs propres désirés V pdes de la matrice F = A22 + T1 ∗ A12
d'observateur et ressoudes l'équation linéaire V p(F = A22 + T1 ∗ A12 ) = V pdes et l'aide de la commande acker()
ou place() on peut la résoudre.

2. on a posé des valeurs propre 8 fois plus rapide que la dynamique de la boucle fermé .

3. les valeurs propres du systeme sont les valeurs propres imposé par le retour états plus le valeur propre de
l'observateur.
4.implémentation sous Simulink :

- Figure 4 : schéma bloc du système sous Simulink -

résultat de simulation :

on remarque q'on a eu un réponse identique au celle donné par l'observateur minimal avec un pole 8 fois
plus rapide de boucle fermé.

8
5 | Implémentation Sur la procédé :

1. on choisit l'observateur identité avec des pôles 8 fois rapide de la boucle fermé car c'est lui qui donne un
erreur minimal converge rapidement vers zéro.
2. implémentation sous Simulink :

- Figure 5 : schéma bloc du système sous Simulink -

réponse du systeme réel :

- Figure 5 : réponse du systeme reel avec observateur -

9
 - Figure 5 : réponse du systeme reel sans observateur -
3. on remarque que le système réel comporte d'une façon très proche du systeme simulé et le sortie du
système réel congre vers la consigne désiré mais avec un erreur de position.
4. pour éliminé l'erreur de positon on propose implémenter un commande retour d'états avec un intégrateur
qu est un commande très robuste permet d'élimer l'erreur de position.

10
6 | Conclusion

Dans ce TP on a arrivé a identier les paramètres et commandé la procédé du moteur avec un contrôleur
de type retour d'état et un pré-compensateur.
et pour estimé les états du moteur on a utilisé plusieurs type observateur, un observateur identité, un ob-
servateur identité minimal et enn un observateur fonctionnel qu estime directement la commande Kx.

avant l'implémentation sur le procédé on simulé sur simulink et apres l'implémentation on a eu des très bons
résultat qui ressemble au systeme simulé mais a on a remarqué un erreur de position et proposé un contrôleur
retour d'états avec un intégrateur pour le corrigé.

11
Annexes

12
 Annexe 1 - code Matla

1 clc
2 clear all
3 close all
4
5 Ks = 10;
6 Kg = .105;
7 Ke = 10;
8 Tm = .3;
9 Km = 7;
10
11 A = [0 Ks /(9* Kg ) ;0 -1/ Tm ];
12 B = [0; Kg * Km / Tm ];
13 C = [1 0];
14 T = ss (A ,B ,C ,0) ;
15 Pd = [ -2.4+5.5 i -2.4 -5.5 i ];
16
17 K = acker (A ,B , Pd ) ;
18 Tdes = ss (A - B *K ,B ,C ,0) ;
19 N = 1/ dcgain ( Tdes ) ;
20
21 % observateur identite :
22 k = 2;
23 Pobs = k *[ -2.4 -2.4];
24 % Pobs = k * Pd ;
25
26 G = acker (A ' ,C ' , Pobs ) '
27 F = A-G*C;
28 H = B;
29 M = eye (2) ;
30 Aid = F ;
31 Bid = [ G H ];
32 Cid = M ;
33 Did = [0 0;0 0];
34 % observateur minimale
35 A11 = 0;
36 A12 = 10.5820;
37 A21 = 0;
38 A22 = -3.3333;
39 B1 = B (1) ;
40 B2 = B (2) ;
41
42
43 Pmin = k *( -2.4) ;
44 G_min = acker ( A22 ' , A12 ' , Pmin )
45 Fmin = A22 - G_min * A12 ;
46 Gt = Fmin * G_min - G_min * A11 + A21 ;
47 Ht = B2 - G_min * B1 ;
48
49 Amin = Fmin ;

13
50 Bmin = [ Gt Ht ];
51 Cmin = 1;
52 Dmin = [ G_min 0];
53
54 % observateur fonctionnel
55 T1 = acker ( A22 ' , - A12 ' , Pmin ) ';
56 Ffc = A22 + T1 * A12 ;
57 Gfc = A21 + T1 * A11 - Ffc * T1 ;
58 Nfc = K (1) - K (2) * T1 ;
59 M = K (2) ;
60 T = [ T1 1];
61 Hfc = T * B ;
62 Afc = Ffc ;
63 Bfc = [ Gfc Hfc ];
64 Cfc = M ;
65 Dfc = [ Nfc 0];

14