Poly Introd Matlab Simulink 15

LTI
Laboratoire de
Traitement de l’
Information
Introduction à Matlab,
au Control System Toolbox
et Simulink
Pr. M. Maher
Faculté des
Sciences
Ben M’Sik
Université Hassan II de Casablanca
Table de matières 2/61
Table de matières
Introduction
I - Les bases de Matlab

I.1 - Création des matrices, vecteurs et scalaires
I.2 – Quelques opérations usuelles sur les matrices
I.3 –Opérations sur les polynômes
I.4 – Instructions de contrôle itératif
I.5 –Outils graphiques
I.6 –Sauvegarde des données
I.7 –Création de fichiers de commande et de fonctions Matlab
II – Boîte à outils de régulation automatique ( Control System Toolbox )

II.1 – Introduction
II.2 – Représentation d’un système par sa fonction de transfert
II.3 –Représentation d’un système par la distribution pôles-zéros (forme d’Evans)
II.4 – Représentation d’un système par le modèle d’état
II.5 – Définition d’un système avec retard
II.6 – Passage d’une représentation à une autre
II.7 – Groupement des systèmes
II.7.1 - Systèmes en série
II.7.2 - Systèmes en parallèle
II.7.3 - Systèmes en boucle fermée
II.7.4 - Système bouclé par retour unitaire
II.8 – Echantillonnage et discrétisation
II.9 – Réponse des systèmes
II.9.1 – Réponse temporelle
II.9.2 – Réponse fréquentielle
II.10 – Analyse et synthèse des systèmes
II.10.1 - Commandabilité et Observabilité
II.10.2 - Position des zéros et des pôles
II.10.3 - Marges de gain et de phase
II.10.4 - Lieu des racines (lieu d’Evans)
II.10.5 - Changement de la période d’échantillonnage
II.10.6 - Autres fonctions Matlab
II.11 - Les commandes de Control System Toolbox
III – Boîte à outils de simulation de systèmes dynamiques ( Simulink )

III.1 – Introduction
III.2 – Lancement de Simulink
III.3 – Les différentes librairies de Simulink
III.4 – Application à la régulation d’un système
III.4.1 – Construction du schéma fonctionnel du système
III.4.2 – Modification des paramètres des blocs
III.4.3 – Modification des paramètres de simulation
III.4.4 – Modification des paramètres de visualisation
III.4.5 – Sauvegarde des résultats de simulation
M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

Introduction 3/61
Introduction
MATLAB (MATrix LABoratory) est un logiciel interactif de calcul matriciel numérique et de
visualisation graphique.
C’est un langage de programmation simple basé sur la manipulation des objets de type
matrice. Les dimensions de la matrice n’ont pas besoin d’être précisées et peuvent prendre la
valeur 1 (cas de vecteurs ou de scalaires).
Le logiciel de base Matlab possède une bibliothèque importante de fonctions et d’opérateurs

permettant le traitement des matrices, vecteurs, tableaux et scalaires.
Les opérations demandées sont exécutées par un interpréteur de commande, dans un espace
de travail (Workspace) ou dans un fichier de commande Matlab (fichier.m), ligne par ligne.
Le logiciel Matlab est enrichi par des boîtes à outils. Ce sont des collections d’algorithmes,
écrits à partir des fonctions de base de Matlab, spécifiques à différents domaines tels que la
régulation automatique (Control System Toolbox), le traitement de signal (Signal Processing
Toolbox), l’identification (System Identification Toolbox), la simulation des systèmes
dynamiques (Simulink), les systèmes de puissances (Power Systems Blockset), etc.
La boîte Control System Toolbox est un outil très utile pour la régulation automatique des
systèmes linéaires. Elle offre plusieurs fonctions facilitant l’analyse, dans les domaines
temporel ou fréquentiel, des systèmes dynamiques linéaires continus ou discrets. Différentes
fonctions permettent aussi l’étude de la synthèse des stratégies de commandes et de
régulation.
La boîte à outil Simulink est une interface graphique conviviale. Elle est utilisée pour
programmer graphiquement, sous forme de diagrammes en blocs, des schémas fonctionnels
des systèmes dynamiques linéaires ou non-linéaires, stationnaires ou non-stationnaires,
analogiques ou numériques. La simulation du fonctionnement d’un système par Simulink
permet de suivre l’évolution des ses paramètres en fonction du temps. Ce logiciel graphique
offre avec Matlab dans un environnement unique des outils d’analyse et de synthèse des
systèmes de commandes.
Note : Ce document est un support d’initiation à l’utilisation du logiciel Matlab (version 6.0),
de la boîte à outils Control System Toolbox (version 5.0) et de Simulink (version 4.0) pour le
cours d’automatique. Il est destiné aux étudiants du Master de Traitement de l’Information.
Plus de détails sur les différents éléments de ce document peuvent être obtenus en recourant à
MATLAB Help.

I – Les bases de Matlab 4/61
I - Les bases de Matlab

Le logiciel Matlab utilise la fenêtre de commande (Command Window) en affichant sur
l’écran le symbole ‘ >> ’ pour recevoir les instructions, figure I.1.
Il existe deux modes de fonctionnement
- mode interactif : les instructions introduites dans l’espace de travail par l’utilisateur
sont interprétées par Matlab au fur et à mesure qu’elles sont validées par la touche
‘Return’ du clavier.
Figure I.1
- mode exécutif : Les instructions sont écrites par l’utilisateur à l’aide d’un éditeur de
texte et enregistrées dans un fichier de commande M-file avec l’extension (.m), figure
I.2. Alors, Matlab exécute ligne par ligne le fichier.m (programme en langage Matlab)
par simple introduction du nom du fichier dans l’espace de travail.
Figure I.2
On obtient de l’aide en ligne sur une fonction (contenue dans Matlab ou dans l’une de ses
toolbox) en tapant help nom de fonction, figure I.3.

Figure I.3
I.1 - Création des matrices, vecteurs et scalaires
Une matrice peut être introduite de différentes manières

- à partir d’une liste explicite d’éléments,
- générée à partir d’instructions ou de fonctions,
- créée dans des fichiers M-file,
- chargée à partir de fichiers de données externes.
>> A = [ 1 2 3 ou >> B = [1 2 0; 3 1 4; 4 1 2]
456
789]
A= B=
1 2 3 1 2 0
4 5 6 3 1 4
7 8 9 4 1 2
>> Vl = [ 1 2 3] % un vecteur-ligne.
Vl =
1 2 3
>> Vc = [ 1; 2; 3] % un vecteur-colonne.
Vc =
1
2
3
>> V1 = [1 2 3 4]; % le point-virgule ( ;) pour ne pas afficher le vecteur V1 sur l’écran.

>> V2 = [5 3 6 2];
>> V3 = [7 1 9 3];
>> V4 = [V1 ; V2 ; V3]

V4 =
1 2 3 4
5 3 6 2
7 1 9 3
>> V4(3,1) % pour obtenir l’élément se trouvant à la ligne 3 et colonne 1 de la matrice.
ans = % Matlab copie par défaut le résultat dans la variable ans (answer).
7
ème
>> V4(2,:) % pour obtenir la 2 ligne de la matrice.
ans =
5 3 6 2
>> V4(2:3,1:2) % pour obtenir une sous-matrice.
ans =
5 3
7 1
>> v =[-2.7 (1+2+3)*sqrt(3) exp(2)*2/9]
v=
-2.7000 10.3923 1.6420
>> v = 4.1 :1: 7 ou >> v = 4.1 : 7 % le caractère ‘ : ‘ crée des vecteurs d’éléments successifs
% avec l’incrémentation spécifiée (par défaut égale à +1).
v=
4.1000 5.1000 6.1000
>> v = 9.3 :-2: 4
v=
9.3000 7.3000 5.3000
>> a = [1.5] ou >>a = 1.5 % un scalaire est une matrice de dimension 1x1.
a=
1.5000
>> a = pi % le nombre pi.
a=
3.1416
>> z = 1.2 + 0.47i ; % pour les nombres complexes, la partie imaginaire est écrite avec i ou j.
>> z = 1.2 + 0.47j ;
>> z = 1.2 + 0.47*i ;
z=
1.2000 + 0.4700i
Remarque : voir aussi size, length, etc.

Quelques matrices utiles
>> C = ones(2,3) % matrice dont tous les éléments sont égaux à 1.
C=
1 1 1
1 1 1
>> C = zeros(2,3) % matrice dont tous les éléments sont égaux à 0.
C=
0 0 0
0 0 0
>> C = eye(2) % matrice identité.
C=
1 0
0 1
>> C = diag([5 2 7]) % matrice diagonale.
C=
5 0 0
0 2 0
0 0 7
>> C = rand(2,2) % matrice dont les éléments sont aléatoires.
C=
0.0579 0.8132
0.3529 0.0099
Remarque : voir aussi linspace, logspace, etc.
I.2 – Quelques opérations usuelles sur les matrices
>> A + B % addition.
ans =
2 4 3
7 6 10
11 9 11
>> A - B % soustraction.
ans =
0 0 3
1 4 2
3 7 7
>> A * B % multiplication.

ans =
19 7 14
43 19 32
67 31 50
>> A' % transpose.
ans =
1 4 7
2 5 8
3 6 9
>> z' % conjuguée transpose pour les nombres complexes.
ans =
1.2000 - 0.4700i
>> expm(A) % exponentielle.
ans =
1.0e+006 *
1.1189 1.3748 1.6307
2.5339 3.1134 3.6929
3.9489 4.8520 5.7552
>> logm(A) % logarithme.
ans =
-5.3603 + 2.7896i 11.9071 - 0.4325i -5.3340 - 0.5129i
12.2169 - 0.7970i -22.1367 + 2.1623i 12.5267 - 1.1616i
-4.7144 - 1.2421i 12.8365 - 1.5262i -4.1211 + 1.3313i
>> sqrtm(A) % racine.
ans =
0.4498 + 0.7623i 0.5526 + 0.2068i 0.6555 - 0.3487i
1.0185 + 0.0842i 1.2515 + 0.0228i 1.4844 - 0.0385i
1.5873 - 0.5940i 1.9503 - 0.1611i 2.3134 + 0.2717i
>> A^3 % puissance.
ans =
468 576 684
1062 1305 1548
1656 2034 2412
>> det(B) % déterminant.
ans =
18
>> rank(B) % rang.
ans =
3

>> eig(B) % valeurs propres.
ans =
5.5030
-0.7515 + 1.6451i
-0.7515 - 1.6451i
>> inv(B) % inversion.
ans =
-0.1111 -0.2222 0.4444
0.5556 0.1111 -0.2222
-0.0556 0.3889 -0.2778
Remarque : voir aussi norm, trace, poly, etc.
Opérations élément par élément
>> A.*B % le caractère ‘.’ précède l’opérateur de multiplication.
ans =
1 4 0
12 5 24
28 8 18
>> B./A % le caractère ‘.’ précède l’opérateur de division.
ans =
1.0000 1.0000 0
0.7500 0.2000 0.6667
0.5714 0.1250 0.2222
>> A.^3 % le caractère ‘.’ précède l’opérateur de puissance.
ans =
1 8 27
64 125 216
343 512 729
>> log(A)
ans =
0 0.6931 1.0986
1.3863 1.6094 1.7918
1.9459 2.0794 2.1972
>> sqrt(A)
ans =
1.0000 1.4142 1.7321
2.0000 2.2361 2.4495
2.6458 2.8284 3.0000
Remarque : voir aussi log10, cos, asin, tanh, real, imag, abs, etc.

I.3 –Opérations sur les polynômes
Un polynôme est représenté par un vecteur-ligne où les coefficients sont rangés dans l’ordre
des puissances décroissantes.
3
>> N = [1 0 -12 7]; % représente le polynôme N(p) = p – 12p + 7.
>> racines = roots(N) % calcule les racines du polynôme N.
racines =
-3.7254
3.1240
0.6015
>> poly(racines) % calcule le polynôme à partir de ses racines.
ans =
1.0000 0.0000 -12.0000 7.0000
>> S = N + D % additionne deux polynômes N et D de même degré, sinon on complète

% le plus faible par des zéros.
>> Pr = conv(N,D) % réalise le produit de deux polynômes N et D.
>> [Q,R] = deconv(N,D) % divise le polynôme N par D. Q est le quotient et R est le reste.
>> dN = polyder(N) % dérive le polynôme N par rapport à la variable p.
dN =
3 0 -12
>> val = polyval( N, 5 ) % donne la valeur du polynôme N au point p=5.
val =
72
>> [r, p, k] = residue( [1 0], [1 3 2] ) % décomposition en éléments simple d’une fraction rationnelle
2
% N(p)/D(p) = p /(p +3p+2) = 2/(p+2) –1/(p+1).
r= % r est le vecteur des coefficients.

2
-1
p= % p est le vecteur des pôles.

-2
-1
k= % k est le terme direct.

[]
Remarque : voir aussi conv2, polyvam, polyfit, etc.

I.4 – Instructions de contrôle itératif
for k = 1 : 1 : 11; % FOR (instruction de répétition avec compteur).

y(k) = 2.3 *cos(2*pi*(k-1)*0.1);
end
y
n=1; % WHILE (instruction de répétition avec test).

while
sum(1:n) < 100,
n = n+1;
end
n
k = 0; % IF (test conditionnel).
if k < 11,
k = k + 1;
y(k) = sin(2*pi*(k-1)*0.1);
end
y
Remarque : voir aussi else, elseif, break, pause, return, continue, switch, etc.
I.5 –Outils graphiques
>> figure(2) % spécifie le numéro 2 pour la fenêtre graphique où le tracé sera effectué.
>> plot(y) % représente chaque colonne de la matrice y en fonction de l’indice du rang.
>> plot(t,y) % représente les colonnes de y en fonction de celles de t.

% y et t doivent avoir les mêmes dimensions.
>> plot(t, [y1,y2]) % représente les colonnes de y1 et y2 en fonction de t.
>> plot(t1,y1,’o’,t2,y2,‘x’) % représente les tracés y1=f(t1) et y2=f(t2) avec des symboles.
>> plot3(t,y,z) % représente les graphiques en 3D.
>> stairs(y) % tracé en escaliers (pour les réponses de systèmes échantillonnés).
>> stem(y) % tracé par symbole ‘échantillon’, (pour les réponses de systèmes échantillonnés).
>> loglog(t,y) % représente y=f(t) en échelle logarithmique.
>> semilogx(t,y) % représente y=f(t) avec échelle log(t).
>> print –dps % imprimer le graphique en PostScript.
>> print –dpsc % imprimer le graphique en PostScript Couleur.
>> print –dps dessin.ps % enregistrer le graphique en PostScript dans le fichier dessin.ps.

Remarque : voir aussi semilogy, polar, bar, hist, grid, title, xlabel, ylabel, axis, hold, colordef,
legend, subplot, gtext, ginput, line, text, clf, close, etc.
I.6 –Sauvegarde des données
>> save % sauvegarde toutes les variables définies dans l’espace de travail dans un fichier
% matlab.mat. Dans une session ultérieure taper ‘>> Load’ pour revenir à l’espace
% sauvegardé.
>> save nom_fichier X,Y,… % les variables X, Y, … définies dans l’espace de travail sont
% sauvegardées dans le fichier en Binaire ( *.Mat ) de format
% spécifique à Matlab.
>> save nom_fichier.dat X,Y,… –ASCII % les variables X,Y,… sont sauvegardées dans le
% fichier en ASCII, qui peut être relu ultérieurement par
% Matlab, Word, Excel, etc.
>> load nom_fichier.mat % charge le fichier de donnée à partir du disque dans

% l’espace de travail.
>> A = load(‘nom_fichier.dat’) % charge le fichier ASCII à partir du disque dans la variable A.
>> dlmwrite( ‘nom_fichier.dat’, X, ’sep’, i, j ) % écrit la variable X dans le fichier en utilisant le

% caractère de séparation des données ‘sep’ (par
% exemple ‘ ‘, ’ ; ’, ‘ \t ’, etc.) à partir de la ligne i et de
% la colonne j.
>> X = dlmread( ‘nom_fichier.dat’, ’sep’, i, j ) % lit la variable X à partir du fichier ( ‘sep’ est le
% caractère de séparation des données ) en
% commençant à partir de la ligne i et la colonne j.
Remarque : voir aussi textread, fopen, fclose, fscanf, fprintf, fread, fwrite, etc.
I.7 –Création de fichiers de commande et de fonctions Matlab
Fichier de commande : Un fichier de commande est un fichier ASCII contenant des

instructions Matlab, sauvegardé avec un nom dont l’extension est .m. On peut utiliser
l’éditeur de Matlab en sélectionnant dans la barre de menus File-New-M-File pour créer le
fichier (figure I.2) et File-Save As.. pour le sauvegarder (figure I.4 ) dans un répertoire sur le
disque.
Par exemple, on crée le fichier de commande suivant et on le sauvegarde sous le nom test.m
% Ceci est un fichier de commande test.m

% les lignes de commentaires commencent par le caractère '%'.
%
close all, clear all;

T = input('donner la période du signal en seconde = ');
t = 0:0.1:100;
omega = 2*pi/T ;
y = 0.5 * sin(omega * t);
plot(t,y);
grid;

xlabel(' Temps (s)');

ylabel(' Signal sinusoidal ');
Figure I.4
Fichier de fonction : L’utilisateur peut créer de nouvelles fonctions et les ajouter à Matlab.
Une fonction est un fichier .m dont la première ligne commence par ‘Function’. Elle peut être
utilisée dans les expressions mathématiques ou dans les instructions Matlab.
Par exemple, on crée une fonction qui calcule la moyenne d’une matrice et on la sauvegarde
dans un fichier moyenne.m.
Function y = moyenne(x)
%
% moyenne(x) valeur moyenne d’une matrice.
%
% Retourne pour un vecteur, une valeur moyenne.
% Retourne pour une matrice, un vecteur dont les éléments
% sont la moyenne de chaque colonne.
[n,m] = size(x) ;
if n == 1
n = m;
end
y = sum(x) / m ;
Les lignes de commentaires seront affichées à l’écran, pour avoir des informations sur cette
fonction, chaque fois qu’on tape dans la fenêtre de commande de Matlab :
>> help moyenne

II – Boîte à outils de régulation automatique (Control System Toolbox) 14/61
II – Boîte à outils de régulation automatique (Control System Toolbox)
II.1 – Introduction
Cette boîte à outils offre plusieurs fonctions pour l’analyse, dans le cadre de la régulation
automatique, des systèmes dynamiques linéaires continus ou discrets. Cette analyse peut être
faite dans le domaine temporel ou fréquentiel et à l’aide de représentation graphique.
Différentes fonctions permettent de faire la synthèse d’une stratégie de commande et de
régulation pour un système linéaire continu ou discret.
II.2 – Représentation d’un système par sa fonction de transfert
Pour définir un système à temps continu ( en ‘s’ ou en ‘p’ ) ou à temps discret ( en ‘z’ ou en
‘z-1’ ou en ‘q-1’ ) sans retard par une fonction de transfert, on introduit le numérateur et le
dénominateur sous forme de vecteurs-ligne où les coefficients sont rangés dans l’ordre des
puissances décroissantes des variables ‘s’ ou ‘z’.
La fonction ‘ tf ‘ est utilisée pour créer la fonction de transfert associée à un système continu
ou discret.
2
>> numc = [1 1] ; % Pour introduire la fonction de transfert F(p) = p+1/(p +2p+2).
>> denc = [1 2 2] ; % numc et denc sont deux variables choisies.
>> sysc = tf( numc, denc ); % La fonction tf crée un ‘ objet ’ fonction de transfert associé à
% la variable choisie sysc.
% On obtient le même résultat avec sysc = tf( [1 1], [1 2 2] ).
>> sysc
Transfer function: % La variable ‘s’ est utilisée par défaut.

s+1
------------------
s^2 + 2 s + 2
Pour vérifier la création de ce système par Matlab, on utilise la fonction get qui liste les
paramètres et les caractéristiques de sa fonction de transfert.
>> get(sysc) % Donne les caractéristiques du système continu sysc.
num: {[0 1 1]}

den: {[1 2 2]}
Variable: 's'
Ts: 0 % période d’échantillonnage.
ioDelay: 0 % retard entrée-sortie
InputDelay: 0 % retard sur l’entrée.
OutputDelay: 0 % retard sur la sortie.
InputName: {''} % nom de la variable d’entrée du système.
OutputName: {''} % nom de la variable de sortie du système.
InputGroup: {0x2 cell}
OutputGroup: {0x2 cell}
Notes: {}
UserData: []
La variable ‘s’ utilisée peut être changée par la variable ‘p’.

>> sysc = tf(numc, denc, ' variable ', ' p ') % Pour changer la variable ‘s’ en ‘p’.

Transfer function:
p+1
------------------
p^2 + 2 p + 2
La fonction de transfert peut être introduite directement sous forme de fractions rationnelles.
>> p = tf( ' p ' ); % Pour avoir une forme de fractions rationnelles en ‘p’.
>> sys = ( p + 1 )/( p^2 + 2*p + 2 )
Transfer function:
p+1
-----------------
p^2 + 2 p + 2
Tous les coefficients de la fonction de transfert doivent être introduits qu’ils soient nuls ou
non.
2
>> nc = 3 * [1 0] ; % Pour introduire la fonction de transfert F(p) = (3 * p)/(p +2).
>> dc = [1 0 2] ;
>> sc = tf( nc, dc )
Transfer function:
3s
----------
s^2 + 2
Dans le cas d’un système discret, on introduit aussi la période d’échantillonnage du système.
2
>> numd = [1 -1]; % Pour introduire la fonction de transfert H(z) = z-1/(z -2z+3)
>> dend = [1 -2 3]; % échantillonnée avec la période Te= 1,5 secondes.
>> sysd = tf(numd, dend, 1.5) % La variable choisie sysd contient le modèle discret.
>> sysd
Transfer function: % La variable ‘z’ est utilisée par défaut.

z-1
-----------------
z^2 - 2 z + 3
Sampling time: 1.5
Les paramètres et les caractéristiques du système créé sont obtenus par la fonction get.
>> get(sysd) % Donne les caractéristiques du système discret sysd.
num: {[0 1 -1]}

den: {[1 -2 3]}
Variable: 'z'
Ts: 1.5 % La période d’échantillonnage spécifiée en secondes.
ioDelay: 0
InputDelay: 0
OutputDelay: 0
InputName: {''}
OutputName: {''}
Notes: {}
UserData: []

II.3 –Représentation d’un système par la distribution pôles-zéros (forme d’Evans)
Un système peut être introduit directement à partir de ses zéros, pôles et gain par la fonction
zpk.
>> szpkc = zpk([1 2], [3 4 5], 2.5) ; % Pour définir un système dont les zéros sont {1, 2},
% les pôles sont {3, 4, 5} et le gain est 2,5.
>> szpkc
Zero/pole/gain:
2.5 (s-1) (s-2)
---------------------
(s-3) (s-4) (s-5)
Pour un système discret, il faut introduire aussi la période d’échantillonnage.

>> szpkd = zpk([0.1 0.2], [0.3 0.4 0.5], 10, 1.5) % Pour définir un système échantillonné dont les
% zéros sont {0.1, 0.2}, les pôles sont
% {0.3, 0.4, 0.5}, le gain est 10 et la cadence
% d’échantillonnage est Te= 1,5 s.
Zero/pole/gain:
10 (z-0.1) (z-0.2)
----------------------------
(z-0.3) (z-0.4) (z-0.5)
Sampling time: 1.5
II.4 – Représentation d’un système par le modèle d’état
Afin de définir un système à temps continu ou à temps discret par son modèle d’état, on
introduit les matrices A, B, C et D des équations d’état et de sortie par la fonction ss.
>> A = [1 2 ; 3 4]; % Pour introduire le modèle d’équation d’état x(t) Ax(t) Bu(t) et
>> B = [5; 6]; % d’équation de sortie y(t)Cx(t) Du(t) .
>> C = [7 8];
>> D = 9;
>> metatc = ss(A,B,C,D); % La fonction ss crée un ‘objet’ modèle d’état associé à la variable
% choisie metatc (contient le modèle d’état continu).
% On obtient le même résultat avec l’écriture suivante
% metatc = ss( [1 2 ; 3 4], [5 ; 6], [7 8], 9 ).
>> metatc
a=
x1 x2
x1 1 2
x2 3 4
b=
u1
x1 5
x2 6

c=
x1 x2
y1 7 8
d=
u1
y1 9
Continuous-time model.
La même démarche est utilisée pour définir un modèle d’état dans le cas discret.
>> metatd = ss(A, B, C, D, 1.5); % Pour introduire un modèle d’état échantillonné avec la
% la période Te= 1,5 s.
% La variable choisie metatd contient le modèle d’état discret.
>> metatd
a=
x1 x2
x1 1 2
x2 3 4
b=
u1
x1 5
x2 6
c=
x1 x2
y1 7 8
d=
u1
y1 9
Sampling time: 1.5

Discrete-time model.
II.5 – Définition d’un système avec retard
On introduit le retard d’un système dans une représentation par la fonction set.
>> sys = tf( [1 2], [1 2 3] ) % Système continu défini sans retard.
Transfer function:
s+2
------------------
s^2 + 2 s + 3
>> set(sys, 'ioDelay', 0.3) % Pour introduire un retard T= 0.3 s dans le système.
>> sys
Transfer function:
s+2
exp(-0.3*s) * ------------------
s^2 + 2 s + 3

Les caractéristiques du système continu avec retard sont données par

>> get(sys)
num: {[0 1 2]}

den: {[1 2 3]}
Variable: 's'
Ts: 0
ioDelay: 0.3 % Le retard spécifié est de 0.3 s.
InputDelay: 0
OutputDelay: 0
InputName: {''}
OutputName: {''}
Notes: {}
UserData: []
Le retard du système continu peut être introduit directement par la fonction tf.
>> sys = tf( [1 2], [1 2 3], 'ioDelay', 0.3 ) % Pour définir un système continu avec retard T= 0.3 s.
Transfer function:
s+2
exp(-0.3*s) * -----------------
s^2 + 2 s + 3
La même démarche est utilisée pour introduire le retard d’un système discret.
>> sysd = tf([1 2], [1 4 3], 2) % Système échantillonné, avec une cadence Te= 2s, défini
% sans retard.
Transfer function:
z+2
------------------
z^2 + 4 z + 3
Sampling time: 2
>> set(sysd, 'ioDelay', 3) % Pour introduire un retard égale à 3 fois la période d’échantillonnage.
>> sysd
Transfer function:
z+2
z^(-3) * -----------------
z^2 + 4 z + 3
Sampling time: 2
Les caractéristiques du système discret avec retard sont données par

>> get(sysd)
num: {[0 1 2]}

den: {[1 4 3]}
Variable: 'z'
Ts: 2 % La période d’échantillonnage spécifiée en secondes.
ioDelay: 3 % Le retard spécifié est de 3 fois la période d’échantillonnage.
InputDelay: 0
OutputDelay: 0
InputName: {''}
OutputName: {''}


Notes: {}
UserData: []
Le retard du système discret peut être introduit directement par la fonction tf.
>> sysd= tf([1 2], [1 4 3], 2, 'ioDelay', 3) % Pour définir un système échantillonné avec Te= 2 s et
% dont le retard est égale à 3 fois la cadence Te.
Transfer function:
z+2
z^(-3) * ---------------
z^2 + 4 z + 3
Sampling time: 2
Un système continu défini par un retard pur peut être approché par une fonction de transfert
suivant l’approximation de la série de Padé par la fonction matlab pade.
-0,1p
>> [num, den] = pade( 0.1, 3 ); % Pour définir un système continu F(p)= e de retard pur 0,1 s.
% L’ordre choisi pour l’approximation est égale à 3.
>> sys = tf( num,den )
Transfer function:
-s^3 + 120 s^2 - 6000 s + 1.2e005
---------------------------------------------
s^3 + 120 s^2 + 6000 s + 1.2e005
II.6 – Passage d’une représentation à une autre
A partir d’un modèle, mémorisé dans l’espace de travail, Matlab retourne les coefficients
définissant le numérateur et le dénominateur de la fonction de transfert du système par la
fonction tfdata.
>> [num, den] = tfdata(sys, 'v') % sys = tf([1 1], [1 2 5]) est la variable mémorisée
% par Matlab, contenant le modèle continu.
num =
0 1 1
den =
1 2 5
>> [num, den, Ts] = tfdata(sys, 'v') % sys = tf([1 1], [1 4 3], 1.5) est la variable mémorisée
% par Matlab, contenant le modèle échantillonné.
num =
0 1 1
den =
1 4 3
Ts = % La période d’échantillonnage.
1.5000
A partir d’un modèle, mémorisé dans l’espace de travail, Matlab retourne les zéros, les pôles
et le gain définissant le système par la fonction zpkdata.
>> [z , p, k] = zpkdata(sys, 'v') % sys = zpk([1 2], [3 4 5], 2.5) est la variable
% mémorisée par Matlab, contenant le modèle continu.

z=
1
2
p=
3
4
5
k=
2.5000
>> [z, p, k, Ts] = zpkdata(sys, 'v') % sys = zpk([1 3], [2 4 7], 5, 1.3) est la variable mémorisée
% par Matlab, contenant le modèle échantillonné.
z=
1
3
p=
2
4
7
k=
5
1.3000
A partir d’un modèle, mémorisé dans l’espace de travail, Matlab retourne les matrices
définissant le système par la fonction ssdata.
>> [A, B, C, D] = ssdata(sys) % sys = ss([1 2 ; 3 4], [5; 6], [7 8], 9) est la variable
% mémorisée par Matlab, contenant le modèle continu.
A=
1 2
3 4
B=
5
6
C=
7 8
D=
9
>> [A, B, C, D, Ts] = ssdata(sys) % sys = ss([4 2 ; 3 1], [7; 6], [5 8], 3, 1.4) est la variable
% mémorisée par Matlab, contenant le modèle échantillonné.
A=
4 2
3 1
B=
7
6

C=
5 8
D=
3
1.4000
On peut passer d’une représentation d’un système à une autre (de même nature continue ou
discrète), suivant la figure II.1, en utilisant les fonctions précédentes.
Fonction zpk Forme

de transfert tf d’Evans
ss
ss
Modèle
tf zpk
d’état
Figure II.1
fonction de transfert -------> forme d’Evans
>> zpk(sysTFc) % sysTFc = tf([3 -3], [1 3 2]) est un modèle continu.
Zero/pole/gain:
3 (s-1)
---------------
(s+2) (s+1)
>> zpk(sysTFd) % sysTFd = tf([0.6 -0.6], [1 4 3], 1.5) est un modèle discret.
Zero/pole/gain:
0.6 (z-1)
---------------
(z+3) (z+1)
Sampling time: 1.5
forme d’Evans -------> fonction de transfert
>> tf(sysZPKc) % sysZPKc = zpk([1 2], [3 4 5], 2.5) est un modèle continu.
Transfer function:
2.5 s^2 - 7.5 s + 5
-------------------------------
s^3 - 12 s^2 + 47 s - 60
>> tf(sysZPKd) % sysZPKd = zpk([1 3], [2 4 7], 5, 1.3) est un modèle discret.

Transfer function:
5 z^2 - 20 z + 15
-------------------------------
z^3 - 13 z^2 + 50 z - 56
Sampling time: 1.3
modèle d’état -------> fonction de transfert
>> tf(sysSSc) % sysSSc = ss([1 2 ; 3 4], [5; 6], [7 8], 9) est un modèle continu.
Transfer function:
9 s^2 + 38 s - 2
---------------------
s^2 - 5 s - 2
>> tf(sysSSd) % sysSSd = ss([4 2 ; 3 1], [7; 6], [5 8], 3, 1.4) est un modèle discret.
Transfer function:
3 z^2 + 68 z - 5
---------------------
z^2 - 5 z - 2
Sampling time: 1.4
fonction de transfert -------> modèle d’état
>> ss(sysTFc) % sysTFc = tf([3 -3], [1 3 2]) est un modèle continu.
a=
x1 x2
x1 -3 -1
x2 2 0
b=
u1
x1 2
x2 0
c=
x1 x2
y1 1.5 -0.75
d=
u1
y1 0
>> ss(sysTFd) % sysTFd = tf([0.6 -0.6], [1 4 3], 1.5) est un modèle discret.
a=
x1 x2
x1 -4 -1.5
x2 2 0

b=
u1
x1 1
x2 0
c=
x1 x2
y1 0.6 -0.3
d=
u1
y1 0
Sampling time: 1.5

Forme d’Evans -------> modèle d’état
>> ss(sysZPKc) % sysZPKc = zpk([1 2], [3 4 5], 2.5) est un modèle continu.
a=
x1 x2 x3
x1 3 1 0.70711
x2 0 4 1.4142
x3 0 0 5
b=
u1
x1 0
x2 0
x3 3.1623
c=
x1 x2 x3
y1 2.2361 1.118 0.79057
d=
u1
y1 0
>> ss(sysZPKd) % sysZPKd = zpk([1 3], [2 4 7], 5, 1.3) est un modèle discret.
a=
x1 x2 x3
x1 2 0.5 0.5
x2 0 4 1
x3 0 0 7
b=
u1
x1 0
x2 0
x3 4.4721

c=
x1 x2 x3
y1 2.2361 1.118 1.118
d=
u1
y1 0
Sampling time: 1.3

modèle d’état -------> Forme d’Evans
>> zpk(sysSSc) % sysSSc = ss([1 2 ; 3 4], [5; 6], [7 8], 9) est un modèle continu.
Zero/pole/gain:
9 (s+4.274) (s-0.05199)
--------------------------------
(s+0.3723) (s-5.372)
>> zpk(sysSSd) % sysSSd = ss([4 2 ; 3 1], [7; 6], [5 8], 3, 1.4) est un modèle discret.
Zero/pole/gain:
3 (z+22.74) (z-0.07329)
--------------------------------
(z-5.372) (z+0.3723)
Sampling time: 1.4
II.7 – Groupement des systèmes
Les systèmes à temps continu peuvent être associés entre eux en série, en parallèle et en
boucle fermée ; de même ceux à temps discret échantillonnés avec les mêmes cadences.
>> sysF = tf(1, [1 1]); % sysF est le nom associé au système continu F.
>> sysR = tf(1, [1 1 1]); % sysR est le nom associé au système continu R.
>> sysFd = tf(1, [1 2], 1.5); % sysFd est le nom associé au système échantillonnée F.
>> sysRd = tf(1, [1 3 2], 1.5); % sysRd est le nom associé au système échantillonnée R.
II.7.1 - Systèmes en série R F
Pour créer un système équivalent de deux systèmes associés en série, on utilise la fonction
series.
>> sysS = series(sysR, sysF) % sysS créé est un système continu équivalent à sysR
% et sysF en série.
% On obtient le même résultat avec sysS = sysR * sysF.
Transfer function:
1
---------------------------
s^3 + 2 s^2 + 2 s + 1
>> sysSd = series(sysRd, sysFd) % sysSd créé est un système discret équivalent à sysRd
% et sysFd en série.
% On obtient le même résultat avec sysSd = sysRd * sysFd.
Transfer function:
1
----------------------------
z^3 + 5 z^2 + 8 z + 4
Sampling time: 1.5
II.7.2 - Systèmes en parallèle

F
+
R +
Pour créer un système équivalent de deux systèmes associés en parallèle, on utilise la

fonction parallel.
>> sysP = parallel(sysF, sysR) % sysP créé est un système continu équivalent à sysF
% et sysR en parallèle.
% On obtient le même résultat avec sysP = sysF + sysR.
Transfer function:
s^2 + 2 s + 2
----------------------------
s^3 + 2 s^2 + 2 s + 1
>> sysPd = parallel(sysFd, sysRd) % sysPd créé est un système discret équivalent à sysFd
% et sysRd en parallèle.
% On obtient le même résultat avec sysPd = sysFd + sysRd.
Transfer function:
z^2 + 4 z + 4
----------------------------
z^3 + 5 z^2 + 8 z + 4
Sampling time: 1.5
II.7.3 - Systèmes en boucle fermée

+ F
-
R
Pour créer un système équivalent de deux systèmes associés en boucle fermée, on utilise la
fonction feedback.
>> sysBF = feedback(sysF, sysR) % sysBF créé est un système continu équivalent à sysF et
% sysR en boucle fermée.
% Pour avoir une contre-réaction positive, on utilise
% sysBF = feedback(sysF, sysR, 1).
Transfer function:
s^2 + s + 1
----------------------------
s^3 + 2 s^2 + 2 s + 2

>> sysBFd = feedback(sysFd, sysRd) % sysBFd créé est un système discret équivalent à
% sysFd et sysRd en boucle fermée.
% Pour avoir une contre-réaction positive, on utilise
% sysBFd = feedback(sysFd, sysRd, 1).
Transfer function:
z^2 + 3 z + 2
----------------------------
z^3 + 5 z^2 + 8 z + 5
Sampling time: 1.5
II.7.4 - Système bouclé par retour unitaire

+ F
Pour créer un système équivalent au système en boucle fermée à retour unitaire, on utilise la
fonction feedback.
>> sysRU = feedback(sysF, 1) % sysRU créé est un système continu équivalent à sysF
% bouclé par retour unitaire.
Transfer function:
1
-------
s+2
>> sysRUd = feedback(sysFd, 1) % sysRUd créé est un système discret équivalent à sysFd
% bouclé par retour unitaire.
Transfer function:
1
-------
z+3
Sampling time: 1.5
II.8 – Echantillonnage et discrétisation
L’échantillonnage d’un système à temps continu est réalisé physiquement par un bloqueur et
un échantillonneur. Cette opération est réalisée par Matlab en utilisant la fonction c2d.
>> sysc = tf([2], [2 1]); % Système continu à échantillonner.
>> sysd = c2d(sysc, 0.5, ' zoh ') % Pour échantillonner avec un bloqueur d’ordre zéro et
% une cadence Te= 0.5 s.
Transfer function:
0.4424
--------------
z - 0.7788
Sampling time: 0.5
Pour comparer les réponses indicielles des systèmes continu sysc et échantillonné sysd, on les
trace à l’aide de la fonction graphique
>> step(sysc, ' - ', sysd, ' -- ')

>> sysd = c2d(sysc, 0.5, ' foh '); % Pour échantillonner avec un bloqueur d’ordre 1 et
Transfer function:
0.2304 z + 0.212
-----------------------
z - 0.7788
Sampling time: 0.5
>> step(sysc, ' - ', sysd, ' -- ') % Pour tracer les réponses indicielles.

La discrétisation d’un modèle à temps continu consiste à le transformer par une

approximation mathématique (exemple Tustin) en un modèle à temps discret. Cette
transformation est réalisée par Matlab en utilisant la fonction c2d.
>> sysd = c2d(sysc, 0.5, ' tustin '); % Pour discrétiser avec la méthode de Tustin et
Transfer function:
0.2222 z + 0.2222
------------------------
z - 0.7778
Sampling time: 0.5
>> step(sysc, ' - ', sysd, ' -- ') % Pour tracer les réponses indicielles.
La conversion d’un système à temps discret à un système à temps continu est obtenue par la
fonction matlab d2c.
>> sysd = tf([0.4424] , [ 1 -0.7788], 0.5) % Système discret à convertir.
>> sysc = d2c(sysd) % Pour passer au modèle continu.

% On obtient le même résultat avec sysc = d2c(sysd, ‘ zoh ’).
% On obtient le même résultat avec sysc = d2c(sysd, ‘ tustin ’).
Transfer function:
1
---------
s + 0.5

II.9 – Réponse des systèmes
II.9.1 – Réponse temporelle
La graphe de la réponse indicielle d’un système à temps continu ou à temps discret est
obtenue directement par l’utilisation de la fonction step.
>> sysc = tf([3], [4 1]); % Système continu à étudier.
>> step(sysc) % Si l’instruction [y, t] = step(sysc) est utilisée, on a accès à

% y un vecteur-colonne contenant la réponse et
% t un vecteur-ligne contenant les instants de calcul.
% Pour un modèle d’état sys, on utilise [y, t, x] = step(sys) afin d’avoir
% x une matrice contenant l’évolution du vecteur d’état.
>> sysd = c2d(sysc, 0.5, ' zoh '); % Système discret à étudier.
>> sysd
Transfer function:
0.3525
-------------
z - 0.8825
Sampling time: 0.5

>> step(sysd) % Trace la réponse indicielle du système discret.

La graphe de la réponse impulsionnelle d’un système à temps continu ou à temps discret est
obtenue directement par l’utilisation de la fonction impulse.
>> impulse(sysc) % Si l’instruction [y, t] = impulse(sysc) est utilisée, on a accès à
% Pour un modèle d’état sys, on utilise [y, t, x] = impulse(sys) afin d’avoir

>> impulse(sysd) % Trace la réponse impulsionnelle du système discret.
La graphe de la réponse à une entrée arbitraire d’un système à temps continu ou à temps
discret est obtenue directement par l’utilisation de la fonction lsim.
>> t = 0 : 0.1 : 12; % Pour créer un vecteur-ligne temps variant entre 0 s et 12 s par
% pas de 0.1 s pour la simulation.
>> u = 2 * t' ; % Calcule une entrée rampe de pente 2 sous forme d’un
% vecteur-colonne de même dimension que le vecteur t.
>> lsim(sysc, u, t) % Trace la réponse du système continu pour l’entrée rampe u.
% Si l’instruction [y, t] = lsim(sysc, u, t) est utilisée, on a accès à

% Pour un modèle d’état sys, on utilise [y, t, x] = lsim(sys, u, t) afin d’avoir

>> k = 0 : 0.5 : 20;

>> u = 2 * k' ;
>> lsim(sysd, u, k) % Trace la réponse du système discret pour l’entrée rampe u.
II.9.2 – Réponse fréquentielle
La réponse fréquentielle d’un système à temps continu ou à temps discret sur le diagramme
de Bode est obtenue directement par l’utilisation de la fonction bode.
>> sysc = tf([3],[4 1]) % Système continu à étudier.
Transfer function:
3
----------
4s+1
>> bode(sysc) % Si l’instruction [A, phi, w] = bode(sysc) est utilisée, on a accès à

% A un vecteur-colonne contenant le gain et
% phi un vecteur-colonne contenant la phase (en degré) et
% w un vecteur-ligne contenant les pulsations (en rd/sec).
>> sysd = c2d(sysc, 0.5,'zoh') % Système discret à étudier.
Transfer function:
0.3525
-------------
z - 0.8825
Sampling time: 0.5

>> bode(sysd) % Trace la réponse fréquentielle du système discret.

de Nyquist est obtenue directement par l’utilisation de la fonction nyquist.
>> nyquist(sysc) % Si l’instruction [re, im, w] = nyquist(sysc) est utilisée, on a accès à
% re un vecteur-colonne contenant la partie réelle et
% im un vecteur-colonne contenant la partie imaginaire du lieu de
% transfert et w un vecteur-ligne contenant les pulsations (en rd/sec).

>> nyquist(sysd) % Trace la réponse fréquentielle du système discret.
de Nichols est obtenue directement par l’utilisation de la fonction nichols.
>> nichols(sysc) % Si l’instruction [A, phi, w] = nichols(sysc) est utilisée, on a accès à
% A un vecteur-colonne contenant le gain et
% phi un vecteur-colonne contenant la phase (en degré) et
% w un vecteur-ligne contenant les pulsations (en rd/sec).

Pour visualiser les courbes de l’abaque de Nichols sur la figure précédente, on utilise la
fonction ngrid.
>> ngrid
>> nichols(sysd) % Trace la réponse fréquentielle du système discret.

II.10 – Analyse et synthèse des systèmes
II.10.1 - Commandabilité et Observabilité

On utilise la fonction ctrb pour calculer la matrice de commandabilité et obsv pour calculer
la matrice d’observabilité d’un système représenté par un modèle d’état.
>> A = [1 2 ; 3 4]; % Pour un modèle d’équation d’état x(t) Ax(t) Bu(t) et
>> B = [5; 6]; % d’équation de sortie y(t)Cx(t) Du(t) .
>> C = [7 8];
>> D = 9;
>> mat_com = ctrb(A,B) % Pour calculer la matrice de commandabilité.
mat_com =
5 17
6 39
>> rang_mat_com=rank(mat_com) % Pour calculer le rang de la matrice de commandabilité.
rang_mat_com =
>> mat_obs = obsv(A,C) % Pour calculer la matrice d’observabilité.
mat_obs =
7 8
31 46
>> rang_mat_obs=rank(mat_obs) % Pour calculer le rang de la matrice d’observabilité.
rang_mat_obs =
II.10.2 - Position des zéros et des pôles
Pour tracer les positions des zéros et pôles d’un système dans le plan complexe, on utilise la
fonction pzmap et pour afficher les courbes à égale coefficient d’amortissement, on utilise la
fonction sgrid.
>> sysc = tf( [3 7.5 3],[1 2 1.25] ); % sysc est le système continu à étudier.
>> pzmap(sysc)
>> sgrid

II.10.3 - Marges de gain et de phase

Pour étudier graphiquement la stabilité d’un système (critère de Nyquist et critère de Revers),
on utilise la fonctions matlab margin. Cette fonction calcule les valeurs des marges de gain et
de phase et trace la courbe de réponse dans le diagramme de Bode.
>> sysc = tf([3],[4 1]); % sysc est le système continu à étudier.
>> margin(sysc)

>> sysd = c2d(sysc, 0.5,'zoh') % sysd est le système discret à étudier.
Transfer function:
0.3525
-------------
z - 0.8825
Sampling time: 0.5

>> margin(sysd)
II.10.4 - Lieu des racines (lieu d’Evans)

Pour déterminer les valeurs du gain d’un système en boucle fermée qui assurent sa stabilité,
on utilise la fonction rlocus. Cette fonction calcule et trace le lieu des racines en boucle
fermée lorsque le gain varie de zéro à l’infini.
>> sysc=tf( [1 3], [1 6 10 8 0] ) % Cette fonction de transfert est équivalente à
% (s+3)
% ----------------------------
% s (s+4) (s^2 + 2s + 2)
Transfer function:
s+3
-----------------------------------
s^4 + 6 s^3 + 10 s^2 + 8 s
>> rlocus(sysc)

II.10.5 - Changement de la période d’échantillonnage

Pour changer la valeur de la période d’échantillonnage d’un système discret, on utilise la
fonction matlab d2d.
>> sysd_1 = zpk(0.7,0.5,1,0.1) % sysd_1 est le modèle discret à étudier où T e = 0.1 s
Zero/pole/gain:
(z-0.7)
---------
(z-0.5)
Sampling time: 0.1
>> sysd_5 = d2d(sysd_1, 0.05) % Pour changer Te à la valeur 0.05 s.
Zero/pole/gain:
(z-0.8243)
--------------
(z-0.7071)
Sampling time: 0.05
II.10.6 - Autres fonctions matlab
gensig = génère un signal d’entrée de type (sinusoïdal, carré, impulsion).

ord2 = crée un système continu du second ordre.
damp = détermine les coefficients d’amortissements et les pulsations propres d’un système.
dcgain = détermine le gain statique d’un système.
zero = calcule les zéros d’un système.
pole = calcule les pôles d’un système.
ss2ss = permet d’appliquer un changement de base pour un modèle d’état.
canon = permet d’avoir un modèle d’état sous forme canonique (modale ou compagne).

initial = représente la réponse libre du modèle d’état en fonction de ses conditions initiales.
acker = placement de pôles par retour d’état pour un système à une seule entrée.
place = placement de pôles par retour d’état.
zgrid = représente les courbes à égale coefficient d’amortissement dans le plan de ‘z’.

II.11 - Les commandes de Control System Toolbox (Version 5.0 )
LTI Models Model Conversion

drss - Generate random discrete state- c2d - Convert from continuous- to
space model. discrete-time models.
dss - Create descriptor state-space chgunits - Convert the units property for FRD
model. models.
filt - Create discrete filter with DSP d2c - Convert from discrete- to
convention. continuous-time models.
frd - Create a frequency response data d2d - Resample discrete-time models.
(FRD) model. delay2z - Convert delays in discrete-time
frdata - Retrieve data from an FRD model. models or FRD models.
get - Query LTI model properties. frd - Convert to a frequency response
rss - Generate random continuous data model.
state-space model. pade - Compute the Padé approximation of
set - Set LTI model properties. delays.
ss - Create state-space model. reshape - Change the shape of an LTI array.
ssdata, residue - Provide partial fraction expansion.
dssdata - Retrieve state-space data. ss - Convert to a state space model.
tf - Create transfer function. tf - Convert to a transfer function
tfdata - Retrieve transfer function data. model.
totaldelay - Provide the aggregate delay for zpk - Convert to a zero-pole-gain model.
an LTI model.
zpk - Create zero-pole-gain model.
zpkdata - Retrieve zero-pole-gain data. Model Order Reduction
balreal - Calculate an I/O balanced
realization.
State-Space Realizations mineral - Calculate minimal realization or
canon - Canonical state-space realizations. eliminate pole/zero pairs.
ctrb - Controllability matrix. modred - Delete states in I/O balanced
ctrbf - Controllability staircase form. realization.
gram - Controllability and observability sminreal - Calculate structured model
grammians. reduction.
obsv - Observability matrix.
obsvf - Observability staircase form.
ss2ss - State coordinate transformation. Model Dynamics
ssbal - Diagonal balancing of state-space damp - Calculate natural frequency and
realizations. damping.
dcgain - Calculate low-frequency (DC) gain.
covar - Calculate covariance of response to
Model Characteristics white noise.
class - Displaymodel type ('tf', 'zpk', 'ss', or dsort - Sort discrete-time poles by
'frd'). magnitude.
hasdelay - Test true if LTI model has any type esort - Sort continuous-time poles by real
of delay. part.
isa - Test true if LTI model is of specified norm - Calculate norms of LTI models (H2
type. and H∞).
isct - Test true for continuous-time pole,
models. eig - Calculate the poles of an LTI model.
isdt - Test true for discrete-time models. pzmap - Plot the pole/zero map of an LTI
isempty - Test true for empty LTI models. model.
isproper - Test true for proper LTI models. rlocus - Calculate and plot root locus.
issiso - Test true for SISO models. roots - Calculate roots of polynomial.
ndims - Display the number of model/array sgrid,
dimensions. zgrid - Superimpose s- and z-plane grids for
size - Display output/input/array root locus or pole/zero maps.
dimensions. zero - Calculate zeros of an LTI model.

Model Interconnections
append - Append models in a block diagonal Time Delays
configuration. delay2z - Convert delays in discrete-time
augstate - Augment output by appending models or FRD models.
states. pade - Compute the Padé approximation
connect - Connect the subsystems of a block- of delays.
diagonal model according to an totaldelay - Provide the aggregate delay for
interconnection scheme of your an LTI model.
choice.
feedback - Calculate the feedback connection
of models. SISO Feedback Design
lft - Form the LFT interconnection (star allmargin - Calculate all crossover
product). frequencies and associated gain,
ord2 - Generate second-order model. phase and delay margins.
parallel - Create a generalized parallel margin - Calculate gain and phase
connection. margins.
series - Create a generalized series rlocus - Calculate and plot root locus.
connection. sistool - Open the SISO Design Tool.
stack - Stack LTI models into a model
array.
Pole Placement
acker - Calculate SISO pole placement
Time Response design.
gensig - Generate an input signal. place - Calculate MIMO pole placement
impulse - Calculate and plot impulse response. design.
initial - Calculate and plot initial condition estim - Form state estimator given estimator
response. gain.
lsim - Simulate response of LTI model to reg - Form output-feedback compensator
arbitrary inputs. given state-feedback and estimator
ltiview - Open the LTI Viewer for linear gains.
response analysis.
step - Calculate step response.
Frequency Response LQG Design

allmargin - Calculate all crossover lqr - Calculate the LQ-optimal gain for
frequencies and associated gain, continuous models.
phase, and delay margins. dlqr - Calculate the LQ-optimal gain for
bode - Calculate and plot Bode response. discrete models.
bodemag - Calculate and plot Bode lqry - Calculate the LQ-optimal gain with
magnitude only. output weighting.
evalfr - Evaluate response at single lqrd - Calculate the discrete LQ gain for
complex frequency. continuous models.
freqresp - Evaluate frequency response for kalman - Calculate the Kalman estimator.
selected frequencies. kalmd - Calculate the discrete Kalman
interp - Interpolate FRD model between estimator for continuous models.
frequency points. lqgreg - Form LQG regulator given LQ gain
linspace - Create a vector of evenly spaced and Kalman filter.
frequencies.
logspace - Create a vector of logarithmically
spaced frequencies.
ltiview - Open the LTI Viewer for linear Equation Solvers
response analysis. care - Solve continuous-time algebraic Riccati
margin - Calculate gain and phase equations.
margins. dare - Solve discrete-time algebraic Riccati
ngrid - Superimpose grid lines on a equations.
Nichols plot. lyap - Solve continuous-time Lyapunov
nichols - Calculate Nichols plot. equations.
nyquist - Calculate Nyquist plot. dlyap - Solve discrete-time Lyapunov
sigma - Calculate singular value plot. equations.

Graphical User Interfaces for Control System Analysis and Design

ltiview - Open the LTI Viewer for linear response analysis.
sisotool - Open the SISO Design GUI.

III – Boîte à outils de simulation de systèmes dynamiques ( Simulink ) 45/61
III – Boîte à outils de simulation de systèmes dynamiques ( Simulink )
III.1 – Introduction
Simulink est un logiciel graphique interactif, faisant partie des boîtes à outils de Matlab, qui
permet de représenter les fonctions mathématiques et les systèmes sous forme de diagramme
en blocs et de simuler leurs fonctionnements.
Il fournit avec Matlab dans un environnement unique des outils d’analyse et de synthèse des
systèmes de commande linéaires ou non-linéaires, stationnaire ou non-stationnaires,
analogiques ou numériques.
La programmation graphique offerte par Simulink permet d’introduire facilement les schémas
fonctionnels des systèmes dynamiques sous forme de blocs et de les interconnecter par des
lignes en utilisant la souris.
III.2 – Lancement de Simulink
Pour lancer le logiciel Simulink, on tape dans la fenêtre de commande (Command Window)
de l’espace de travail Matlab l’instruction
>> simulink
ou bien, on appuie sur le bouton correspondant à Simulink de la barre d’outils, figure III.1,
de la fenêtre de Matlab.
Figure III.1
Une nouvelle fenêtre, figure III.2, de Simulink et ses librairies est affichée.
Figure III.2

En ouvrant le bloc Simulink, à l’aide du bouton droit de la souris, on affiche la librairie

principale de Simulink, figure III.3.
Figure III.3
Elle est formée par neuf blocs de librairies spécifiques et un bloc de démonstration. Chacun
des blocs spécifiques de cette librairie est une collection de blocs fonctionnels standards.
Sources est une collection de générateurs de signaux.

Sinks est une collection de blocs permettant de diriger un signal vers un fichier, ou de
l’afficher sur un bloc de visualisation.
Continuous est une collection de blocs de modèles continus linéaires.
Discrete est une collection de blocs de modèles discrets.
Math est une collection de blocs de fonctions mathématiques.
Functions & Tables est une collection de blocs de fonctions spéciales.
Nonlinear est une collection de blocs d’éléments non-linéaires.
Signals & Systems est une collection de blocs de systèmes de connexion de signaux.
Blocksets & Toolboxes est une collection de blocs spécifiques aux différentes boîtes à outils
de Matlab.
Demos est un bloc qui permet l’accès aux différentes démonstrations de Matlab et de ses
boîtes à outils.

III.3 – Les différentes librairies de simulink
En ouvrant les blocs Continuous et Discrete, à l’aide du bouton droit de la souris, on affiche
les éléments de leurs librairies, figure III.4 et figure III.5 respectivement.
Figure III.4
Cette librairie contient des éléments continus qui permettent de simuler des systèmes continus
(analogiques). Cette collection contient un modèle d’état, un modèle sous forme de fonction
de transfert, un modèle sous forme d’Evans, un intégrateur, un dérivateur, un retard pur, etc.
Figure III.5
Cette librairie contient des éléments discrets qui permettent de simuler des systèmes discrets
(numériques). Cette collection contient un modèle d’état discret, un modèle discret sous forme
de fonction de transfert, un modèle discret sous forme d’Evans, un bloqueur d’ordre zéro, un
intégrateur discret, etc.

En ouvrant le bloc Functions & Tables, à l’aide du bouton droit de la souris, on affiche les
éléments de cette librairie, figure III.6.
Figure III.6
Cette librairie contient des éléments qui permettent de réaliser des opérations spéciales, par
exemple des interpolations linéaires, utilisation des formes polynomiales, utilisation des
expressions écrites en langage C, appeler des fonctions Matlab standard, appeler des
fonctions S-Function de Simulink, etc.

En ouvrant le bloc Math, à l’aide du bouton droit de la souris, on affiche les éléments de
cette librairie, figure III.7.
Figure III.7
Cette librairie contient des éléments qui permettent d’avoir des opérateurs mathématiques
agissant sur des signaux, tels que sommateurs, produits, gains, opérateurs logiques, fonctions
trigonométriques, fonctions logiques combinatoires , etc.

En ouvrant le bloc Nonlinear, à l’aide du bouton droit de la souris, on affiche les éléments de
Figure III.8
Cette librairie contient des éléments non-linéaires qui permettent de simuler différents
systèmes non-linéaires. Cette collection contient un limiteur de la variation par rapport au
temps, un limiteur par saturation, un convertisseur à quantification, un élément avec zone
morte, un élément avec hystérésis, etc.

En ouvrant le bloc Signals & Systems, à l’aide du bouton droit de la souris, on affiche les
éléments de cette librairie, figure III.9.
Figure III.9
Cette librairie contient une collection d’éléments, tels qu’un multiplexeur, un démultiplexeur,
des ports d’entrée et de sortie, etc.

En ouvrant le bloc Sinks, à l’aide du bouton droit de la souris, on affiche les éléments de
Figure III.10
Cette librairie contient une collection d’éléments qui permettent de visualiser des signaux
pendant la simulation ou de diriger des signaux vers l’espace de travail ou vers un fichier de
sauvegarde pour un traitement ultérieur, etc.

En ouvrant le bloc Sources, à l’aide du bouton droit de la souris, on affiche les éléments de
Figure III.11
Cette librairie contient une collection de blocs, tels que des générateurs de signaux (échelon,
rampe, impulsionnel, sinusoïdal, aléatoire, bruit blanc,…) et des horloges fournissant le
temps courant des simulations.

En ouvrant les blocs Blocksets_and_Toolboxes et Simulink Extras, à l’aide du bouton droit

de la souris, on affiche les éléments de leurs librairies, figure III.12 et figure III.13
respectivement.
Figure III.12
Cette librairie contient une collection de blocs spécifiques aux différentes boîtes à outils de
Matlab, tels que Control System Toolbox, Fuzzy LogicToolbox, Power System Blockset, etc.
Figure III.13
Cette librairie contient une collection de blocs additionnelles de la librairie Linear. On
remarque qu’elle contient des éléments tels que PID Controller qui permettent la réalisation
d’une régulation par commande PID.

III.4 – Application à la régulation d’un système
On va simuler la régulation d’un système continu du premier ordre représenté par sa fonction
0,2
de transfert F(p) par un régulateur intégral dont le gain de l’action intégrale est 0.5
10.5p
en boucle fermée. La consigne est un signal carré variant entre 0 et 1.
Ce système de régulation va être représenté par Simulink sous forme d’un diagramme de
blocs élémentaires dans une fenêtre de travail qu’on va créer.
III.4.1 – Construction du schéma fonctionnel du système
Pour commencer, on ouvre un nouveau fichier Simulink en sélectionnant File-New-Model.

Une fenêtre vide nommée untitled s’affichera sur l’écran. Ensuite, on ouvre les différentes
librairies, vus précédemment, qui contiennent les blocs dont on a besoin pour construire le
diagramme de notre système de régulation.
Les blocs élémentaires (Transfer Fcn, PID Controller, Pulse Generator, Sum, Mux,
Scope et To File) seront déplacés dans la nouvelle fenêtre créée. Ce déplacement n’affecte
pas le bloc original mais crée uniquement une copie de celui-ci. Cette copie garde les mêmes
caractéristiques que le bloc original.
Pour connecter deux blocs, on clic sur le port de sortie du premier bloc, déplacer le curseur
en maintenant le bouton de la souris enfoncé, jusqu’au port d’entrée du deuxième bloc et
relâcher le bouton. Ainsi, une ligne est créée avec une flèche indiquant le sens de la
propagation des signaux entre les deux blocs.
Après avoir terminer le diagramme, figure III.14, on l’enregistre dans un fichier sous le nom
com_PID_sys (avec l’extension .mdl par défaut) dans un répertoire choisi en sélectionnant
File-Save as….
Figure III.14
III.4.2 – Modification des paramètres des blocs
Pour changer les paramètres du bloc fonction de transfert Transfer Fcn, on double-clic
dessus. Une boite de dialogue (figure III.15) s’ouvre et dans laquelle les valeurs des

coefficients du numérateur et dénominateur seront introduites. Une fois terminé, on ferme

cette boite de dialogue.
Figur III.15
Remarque : L’échange de données entre Simulink et l’espace de travail de Matlab peut être
réalisé par des variables communes ou par des fichiers (d’extension .mat).
Les blocs élémentaires de Simulink peuvent être paramétrés par des variables symboliques.
Les valeurs de ces paramètres peuvent être définies dans l’espace de travail Matlab, d’une
manière manuelle ou par l’exécution d’un fichier de commande avant le début de la
simulation.
La même démarche sera utilisée pour paramétrer le bloc Pulse Generator, figure III.16,
pour avoir un signal de consigne périodique de période 140 s et d’amplitude 1 unité.
Figure III.16

Sur le bloc sommateur Sum, on change la liste des signes ++ en +- pour avoir une boucle
fermée avec une contre-réaction négative, figure III.17.
Figure III.17
Pour le bloc multiplexeur Mux, figure III.18, on choisit deux entrées l’une pour le signal de
consigne et l’autre pour le signal de sortie.
Figure III.18
De même pour le bloc du régulateur PID Controller, on introduit le terme intégral (le gain de
l’action intégrale), figure III.19.

Figure III.19

III.4.3 – Modification des paramètres de simulation
En sélectionnant dans la barre des tâches Simulation-Simulation parameters…, une boite

de dialogue (figure III.20) s’ouvre. On définit les paramètres de la simulation tels que le
temps initial (Start time), le temps final (Stop time), la méthode d’intégration numérique des
équations différentielles (par défaut Runge-Kutta 45 est utilisée), le pas d’intégration
maximal (Max step size), la précision des calculs désirée pour l’intégration (tolerance),
etc.
Figure III.20
Pour notre application, on a choisi un pas d’intégration maximal de l’ordre de 0.1 s car le
système étudié admet une constante de temps de l’ordre de 0.5 s. Dans ce cas, la précision
fixée à 1 e-3 sera atteinte.
III.4.4 – Modification des paramètres de visualisation
Pour ajuster l’échelle verticale de l’oscilloscope afin de visualiser les signaux de la consigne
et la sortie régulée, on clic par la touche droite de la souris sur la fenêtre de l’affichage
Scope et on choisit Axes properties…. La fenêtre (figure III.21) s’ouvre et par la suite on
introduit les valeurs désirées.
Figure III.21

Une fois tous les paramètres des blocs constituant le diagramme Simulink sont introduits, on
sélectionne dans la barre des tâches Simulation-Start pour lancer la simulation de la
régulation de notre système. On observe l’évolution des signaux en cours de simulation sur
l’oscilloscope (figure III.22) pour une durée de 150 s. Les deux courbes représentent le signal
de la consigne et le signal de la sortie régulée du système.
Figure III.22
On peut modifier les échelles de l’affichage, en utilisant les boutons jumelles et zoom suivant
l’axe vertical ou horizontal.

III.4.5 – Sauvegarde des résultats de simulation
On peut sauvegarder les résultats de la simulation dans une variable Matlab ou dans un
fichier de données pour un traitement ultérieur.
Dans notre application, nous avons choisi de sauvegarder la consigne et la sortie régulée
dans un fichier à travers le bloc To File placé à la sortie du multiplexeur. Les paramètres de
ce bloc sont introduits en double-cliquant dessus. La boîte de dialogue(figure III.23) s’ouvre
et permet d’introduire le nom du fichier de sauvegarde (Filename) qu’on a nommé
com_sys.mat et le nom de la variable (Variable name) qu’on a nommé yr_y.
Figure III.23
Le fichier com_sys.mat est créé, par défaut, dans le dossier Work faisant partie du répertoire
de Matlab. La variable yr_y est une matrice à trois lignes dont la première est le temps, les
deux autres sont la consigne et la sortie. Le nombre de colonnes de cette matrice est fonction
du choix du nombre de mesures à sauvegarder par rapport au pas d’intégration
(Decimation) et la durée entre les instants des sauvegardes (Sample time).
Dans notre cas, on a choisi de sauvegarder après chaque 4 pas d’intégration (une mesure sur
quatre) et le paramètre du Sample time est pris par défaut.

Poly Introd Matlab Simulink 15

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Poly Introd Matlab Simulink 15

Uploaded by

Copyright:

Available Formats

LTI

au Control System Toolbox

I - Les bases de Matlab

II – Boîte à outils de régulation automatique ( Control System Toolbox )

III – Boîte à outils de simulation de systèmes dynamiques ( Simulink )

M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

Le logiciel de base Matlab possède une bibliothèque importante de fonctions et d’opérateurs

M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

I - Les bases de Matlab

M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

I.1 - Création des matrices, vecteurs et scalaires

Une matrice peut être introduite de différentes manières

>> V1 = [1 2 3 4]; % le point-virgule ( ;) pour ne pas afficher le vecteur V1 sur l’écran.

M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

>> V4(3,1) % pour obtenir l’élément se trouvant à la ligne 3 et colonne 1 de la matrice.

>> V4(2:3,1:2) % pour obtenir une sous-matrice.

>> v =[-2.7 (1+2+3)*sqrt(3) exp(2)*2/9]

>> v = 9.3 :-2: 4

>> a = pi % le nombre pi.

Remarque : voir aussi size, length, etc.

M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

Quelques matrices utiles

>> C = ones(2,3) % matrice dont tous les éléments sont égaux à 1.

>> C = zeros(2,3) % matrice dont tous les éléments sont égaux à 0.

>> C = eye(2) % matrice identité.

>> C = diag([5 2 7]) % matrice diagonale.

>> C = rand(2,2) % matrice dont les éléments sont aléatoires.

Remarque : voir aussi linspace, logspace, etc.

I.2 – Quelques opérations usuelles sur les matrices

M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

>> A' % transpose.

>> z' % conjuguée transpose pour les nombres complexes.

>> expm(A) % exponentielle.

>> logm(A) % logarithme.

>> sqrtm(A) % racine.

>> A^3 % puissance.

>> det(B) % déterminant.

>> rank(B) % rang.

M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

>> eig(B) % valeurs propres.

>> inv(B) % inversion.

Remarque : voir aussi norm, trace, poly, etc.

Opérations élément par élément

>> A.*B % le caractère ‘.’ précède l’opérateur de multiplication.

>> B./A % le caractère ‘.’ précède l’opérateur de division.

>> A.^3 % le caractère ‘.’ précède l’opérateur de puissance.

M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

I.3 –Opérations sur les polynômes

>> racines = roots(N) % calcule les racines du polynôme N.

>> poly(racines) % calcule le polynôme à partir de ses racines.

>> S = N + D % additionne deux polynômes N et D de même degré, sinon on complète

>> Pr = conv(N,D) % réalise le produit de deux polynômes N et D.

>> dN = polyder(N) % dérive le polynôme N par rapport à la variable p.

>> val = polyval( N, 5 ) % donne la valeur du polynôme N au point p=5.

r= % r est le vecteur des coefficients.

p= % p est le vecteur des pôles.

k= % k est le terme direct.

Remarque : voir aussi conv2, polyvam, polyfit, etc.

M.Maher – 15 Introduction à Matlab, au Control System Toolbox et Simulink

I.4 – Instructions de contrôle itératif

for k = 1 : 1 : 11; % FOR (instruction de répétition avec compteur).

n=1; % WHILE (instruction de répétition avec test).

I.5 –Outils graphiques

>> plot(y) % représente chaque colonne de la matrice y en fonction de l’indice du rang.

>> v =[-2.7 (1+2+3)sqrt(3) exp(2)2/9]