I- Introduction :

La commandabilité et l’observabilité sont l’examen de la structure d’un

système, et de trouver, est ce que c’est possible de commander ce système par
ses entrées, et/ou, est ce que c’est possible de déterminer l’état du système par
ses sorties.
Pour effectuer cette opération, c'est-à-dire, pour l’analyse et la synthèse des
systèmes de commande, on apte pour l’utilisation des équations d’états. Est cela se
fait que pour analyser des systèmes exprimer en espace d’état.

II- But de TP :

1. Le premier but de ce TP est d’apprendre à réaliser des

programmes pour des systèmes représenter par ses équations
d’états.
2. Le deuxième but de ce TP est de réalisé un programme en
logicielle MATLAB, qui examine la commandabilité et
l’observabilité des systèmes.

ETUDE THEORIQUE

Un système dynamique (L.T.I) est représenté par une équation différentielle

d’ordre « n » peut toujours être grouper et représenté sous forme condenser et cela
par un ensemble de « n » équations différentielle d’ordre « 1 »qui d’écrite par la
forme globale suivante :

{

X AXBU

Y CXDU
Avec : X (t) =vecteur d’état.
Y (t) =vecteur de sortie.
U (t) =vecteur d’entrée.
A = matrice d’état propre au système.

II.1. COMMANDABILITE :

II.1.1. Définition :

Un système linéaire décrit par les équations d’état :


X (t)  A(t) . X (t)  B (t) .U(t)
Est dit « à état entièrement commandable » (on dit aussi gouvernable) :
 Si : à l’instant quel que soit « X f », il existe une commande U(τ ) avec : τ > t0
, qui transfert l’état , de X (t0) à t f en un temps fini.
Ou bien autrement dit :
Si : par action sur l’entrée, on peut atteindre en temps fini n’importe que l point
de l’espace d’état.
On dit qu’un système est commandable dans un intervalle de temps [t 0 ,t1], si
durant cet intervalle existe des entrées u (t ) qui peuvent transformer le système
de l’état initial x0 (t ) à un autre état désiré x1 (t ).

X (k +1 ) = A * x (k ) + B * u (k ) .
:
X ( k: +1+N ) = AN+1 * x (k ) + AN * B * u (k ) +.......+B * u (k+N ).

II.1.2.Théorème de Commandabilité :

La condition nécessaire et suffisante de commandabilité complète d’un système

est formulée de la manière suivante :
Un système stationnaire continu linéaire est commandable si seulement si le
rang de la matrice :

W = [B A*B A2 *B A3 *B ------ An-1 *B]

Le rang est plein, c'est-à-dire que, la dimension « n*m » égale à n,

Où :
n : La dimension du vecteur d’état,
La matrice W à un « n*m » colonne (le rang est plein) et pour que le rang de W
égale à « n » il faut que le déterminant de W soit différent de zéro c'est-à-dire
que le : det (W) ≠ 0.

II.2. L’OBSERVABILITE :

II.2.1. Définition : un système linéaire décrit par l’équation d’état et de

mesure :

X (t)  A . X(t)  B(t) . U( t)
Y(t)  C . X(t)  D(t) . U(t)

Est dit entièrement observable à l’instant t0

Si : quel que soit X(t0 ) , il existe un instant t – 1 fini et inférieur à t0 , tel que
la connaissance de Y( t)pour tout t [ t -1 , t0 ] soit suffisante pour déterminer
X(t0). Ou bien autrement dit :
Si : par observation des entrées et sorties sur un intervalle de temps fini on
peut déterminer l’état initiale du système. Et Si n’importe quel changement de
l’état du système est détecté à partir des mesures qui sont valables. Ce système
est observable.
On utilisera la notion discrète on peut écrire les équations suivantes :

Y(k) = H * x (k).
Y(k+1) = H * A * x (k) +H * B * U (k).
:
Y(k+N ) = H * AN * x (k) + H * AN-1 * B * u (k) +H * B * U (k+N-1).

II.2.2. Théorème de l’observabilité:

Dans le cas où le système est invariant, le système est observable si et

seulement si la matrice :
V = [C C*A ___ C*An] T
De dimension « n x n » ait un rang égal à « n » c'est-à-dire que le rang est
plein donc le : det (V) ≠ 0

III. Conclusion :

Dans la pratique (domaine industriel), il existe plusieurs types des

systèmes. Pour géré ou contrôlé ces système il faut bien déterminer leurs
comportement a la sortie et avoir la possibilité d’agir sur ses entrées au moment
voulus.
Pour déterminer le comportement et l’accessibilité des système quelconque il
faut bien répondre a ces questions :
-Est-ce que le comportement de ce système peut être déterminé par ses
sorties ?
-Et est-ce que les entrées de ce système sont accessibles ? Ce qui nous
permet de réalise notre commande.
Pour répondre a ces questions on utilise :
1-Le théorème de l’observabilité : si mon système est observable donc je
peut constater sont comportement suivant ses sorties, mais, s’il est non
observable il faut faire appel a d’autre techniques.

2-Le théorème de la commandabilité: si mon système est Commandable

donc je peut agir sur ses entrées, mais, s’il est non commandable il faut faire
appel a d’autre techniques, pour le commander.
IV. Le programme :
Ce programme est réalisé de manière à vérifier sur le MATLAB la
commandabilité et l’observabilité des systèmes :
 M=menu ('choisir une commande','commandabilité','observabilité','end');
if M==1
%commandabilité
a=input ('donner la matrice A=');
b=input ('donner la matrice B=');
n=size (a);
w=b;
for i=1:n-1
w= [b a*w]
end
rank (w);
if rank(w)==n
deteminant=det(w)
rang =rank(w)
disp (' commandable')
elseif rank(w)~=n
disp ( 'non commandable')
end
elseif M==2
%observabilité
a=input('donner la matrice A=');
h=input('donner la matrice H=');
n=size(a);
v=h;
for i=1:n-1
v=[h;v*a]
end
rank(v);
if rank(v)==n
rang=rank(v)
deteminant=det(v)
disp('observable')
elseif rank(v)~=n
disp('non observable')
end
elseif M==3
end

 Remarque :
On peut aussi réaliser un programme qui nous permet d’introduire
directement les valeurs de A, B, C, ce qui va nous données le résultats de
l’observabilité et la commandabilité d’une seule exécution,son programma
est définie comme suite :

M=menu('choisir une commande','comm et obs','end')

A=input('A=')
B=input 'B=')
C=input('C=')
n=size (A);
Com=B;
Obs=C;
if M==1
for i=1:n-1
com=[B A*com];
end
disp('com=')
disp(com)
d1=det(com)
if d1==0
disp('donc le systéme est non commandable')
else
disp('donc le systéme est commandable')
end
for i=1:n-1
obs=[C;obs*A];
end
disp('obs=')
disp(obs)
d2=det(obs)
if d2==0
disp('donc le systéme est non observable')
else
disp('donc le systéme est observable')
end
else
disp('beye')

end