Travaux Pratiques Matlab/Simulink :
Pilotage des Systèmes
Auteur : Manus AI
Date : Mars 2026
Niveau : Licence/Master en Automatique et Systèmes Numériques
Table des Matières
1. TP 1 : Simulation d’un système à commande numérique - Conversion A/N et N/A
2. TP 2 : Analyse du système échantillonné - Critères de stabilité
3. TP 3 : Synthèse de régulateur PID - Implémentation pratique dans le plan Z
4. TP 4 : Contrôleur RST pour un système échantillonné
5. TP 5 : Simulation d’un système multi-boucles avec correcteurs numériques
TP 1 : Simulation d’un système à commande
numérique - Conversion A/N et N/A
Objectifs pédagogiques
Ce travail pratique vise à familiariser les étudiants avec les concepts fondamentaux de
la conversion analogique-numérique (A/N) et numérique-analogique (N/A) dans les
systèmes de commande numérique. À l’issue de ce TP, l’étudiant doit être capable de :
Modéliser un système dynamique simple en utilisant Simulink
Implémenter des convertisseurs A/N et N/A dans une chaîne de commande
Analyser l’impact de la fréquence d’échantillonnage sur la qualité de la
conversion
Comparer les signaux analogiques et numériques reconstruit
Description du travail
Partie théorique
La conversion A/N transforme un signal analogique continu en une séquence de
nombres discrets à des instants d’échantillonnage réguliers. La conversion N/A
effectue l’opération inverse. La fréquence d’échantillonnage fe doit respecter le critère
de Nyquist : fe ≥ 2fmax , où fmax est la fréquence maximale du signal analogique.
Partie pratique
Étape 1 : Création du modèle Simulink
Créez un nouveau modèle Simulink contenant les éléments suivants :
1. Un générateur de signal sinusoïdal avec une fréquence de 1 Hz et une
amplitude de 2 V
2. Un bloc A/N (ADC) avec une fréquence d’échantillonnage fe = 10 Hz
3. Un bloc N/A (DAC) avec maintien d’ordre zéro (Zero-Order Hold)
4. Un système dynamique simple (par exemple, un moteur modélisé par une
fonction de transfert du premier ordre)
5. Des oscilloscopes pour visualiser les signaux à différents points
Étape 2 : Configuration des paramètres
Fréquence du signal d’entrée : 1 Hz
Amplitude : 2 V
Fréquence d’échantillonnage : 10 Hz
Durée de simulation : 5 secondes
Pas de simulation : 0.01 secondes
Étape 3 : Analyse des résultats
Comparez les trois signaux :
Signal analogique d’entrée
Signal numérique après A/N
Signal reconstruit après N/A
Observez les erreurs de quantification et les effets du maintien d’ordre zéro.
Solution
Code MATLAB pour la configuration
% Script de configuration du TP 1
clear all; close all; clc;
% Paramètres du système
fe = 10; % Fréquence d'échantillonnage (Hz)
Te = 1/fe; % Période d'échantillonnage (s)
f_signal = 1; % Fréquence du signal d'entrée (Hz)
A = 2; % Amplitude du signal (V)
t_sim = 5; % Durée de simulation (s)
% Fonction de transfert du système (moteur du 1er ordre)
% G(s) = K / (1 + tau*s)
K = 1; % Gain statique
tau = 0.5; % Constante de temps (s)
num = K;
den = [tau 1];
sys_continuous = tf(num, den);
% Discrétisation du système avec la méthode de Tustin
sys_discrete = c2d(sys_continuous, Te, 'tustin');
% Affichage des résultats
disp('Système continu :');
disp(sys_continuous);
disp('Système discret (Tustin) :');
disp(sys_discrete);
% Création du modèle Simulink
% Ouvrir le modèle : open_system('tp1_model')
Modèle Simulink - Description textuelle
Le modèle Simulink doit contenir les blocs suivants, connectés en cascade :
Bloc Paramètres Fonction
Amplitude = 2,
Sine Wave Génère le signal d’entrée analogique
Frequency = 1 Hz
Sample time = 0.1 s (fe =
ADC (A/N) Convertit le signal analogique en numérique
10 Hz)
Zero-Order Maintient la valeur numérique pendant une
Sample time = 0.1 s
Hold période d’échantillonnage
Transfer Fcn Num = [1], Den = [0.5 1] Simule la dynamique du système
(x3 pour les trois
Scope Affiche les signaux
signaux)
Résultats attendus
1. Signal analogique d’entrée : Sinusoïde lisse de 2 V d’amplitude
2. Signal après A/N : Points discrets correspondant aux valeurs échantillonnées
3. Signal après N/A : Fonction en escalier (marches) due au maintien d’ordre zéro
4. Sortie du système : Sinusoïde filtrée et atténuée par la dynamique du système
Analyse des erreurs
L’erreur de quantification dépend de la résolution du convertisseur A/N. Pour un
convertisseur 8 bits avec une plage de ±5 V :
Plage 10
Erreur de quantification = = ≈ 0.039 V
2n 256
L’erreur d’échantillonnage dépend de la fréquence d’échantillonnage. Avec fe = 10 Hz
et fsignal = 1 Hz, le rapport fe /fsignal = 10 est suffisant pour une bonne
reconstruction.
Questions de synthèse
1. Que se passe-t-il si la fréquence d’échantillonnage est inférieure à 2 Hz (violation
du critère de Nyquist) ?
2. Comment améliorer la qualité de la reconstruction en sortie du DAC ?
3. Quel est l’impact de la constante de temps du système sur la sortie finale ?
TP 2 : Analyse du système échantillonné - Critères de
stabilité
Objectifs pédagogiques
Ce TP permet aux étudiants d’acquérir une compréhension approfondie des critères
de stabilité pour les systèmes discrets. À l’issue de ce TP, l’étudiant doit être capable
de :
Calculer les pôles d’un système discret
Appliquer les critères de stabilité (Jury, Routh-Hurwitz sur la transformation
bilinéaire)
Analyser la stabilité d’un système échantillonné
Simuler et interpréter les réponses temporelles
Description du travail
Partie théorique
Pour un système discret, la stabilité est assurée si tous les pôles se trouvent à
l’intérieur du cercle unité dans le plan Z (c’est-à-dire ∣zi ∣ < 1 pour tous les pôles zi ).
Les critères de stabilité courants sont :
1. Critère des pôles : Vérifier directement que ∣zi ∣ < 1
2. Critère de Jury : Appliquer un test sur les coefficients du polynôme
caractéristique
3. Critère de Routh-Hurwitz transformé : Utiliser la transformation bilinéaire s =
2(z−1)
Te (z+1)
Partie pratique
Étape 1 : Définition du système discret
Considérez un système discret avec la fonction de transfert suivante (après
discrétisation) :
0.5z + 0.3
H(z) =
z2 − 1.2z + 0.35
Étape 2 : Analyse de stabilité
1. Calculez les pôles du système
2. Vérifiez la stabilité en utilisant le critère des pôles
3. Appliquez le critère de Jury
4. Simulez la réponse impulsionnelle et échelon
Étape 3 : Étude paramétrique
Modifiez les coefficients du dénominateur et observez comment la stabilité change.
Solution
Code MATLAB pour l’analyse de stabilité
% Script d'analyse de stabilité - TP 2
clear all; close all; clc;
% Définition du système discret
num = [0.5 0.3];
den = [1 -1.2 0.35];
Te = 0.1; % Période d'échantillonnage
% Création du système discret
sys_discrete = tf(num, den, Te);
% Calcul des pôles et zéros
poles = pole(sys_discrete);
zeros = zero(sys_discrete);
% Affichage des pôles et zéros
disp('=== ANALYSE DE STABILITÉ ===');
disp('Pôles du système :');
disp(poles);
disp('Zéros du système :');
disp(zeros);
% Vérification du critère des pôles
stability = all(abs(poles) < 1);
if stability
disp('✓ Le système est STABLE (tous les pôles sont à l''intérieur du
cercle unité)');
else
disp('✗ Le système est INSTABLE (au moins un pôle est en dehors du cercle
unité)');
end
% Affichage des modules des pôles
disp('Modules des pôles :');
for i = 1:length(poles)
fprintf(' |z%d| = %.4f\n', i, abs(poles(i)));
end
% Tracé du diagramme des pôles et zéros
figure('Position', [100 100 800 600]);
subplot(2,2,1);
zplane(num, den);
title('Diagramme des pôles et zéros');
grid on;
% Réponse impulsionnelle
subplot(2,2,2);
impulse(sys_discrete, 1);
title('Réponse impulsionnelle');
grid on;
% Réponse indicielle (échelon)
subplot(2,2,3);
step(sys_discrete, 1);
title('Réponse indicielle');
grid on;
% Diagramme de Bode
subplot(2,2,4);
bode(sys_discrete);
title('Diagramme de Bode');
grid on;
% Critère de Jury
disp('=== CRITÈRE DE JURY ===');
% Pour un polynôme P(z) = z^2 - 1.2*z + 0.35
% Test 1 : P(1) > 0
P_1 = polyval(den, 1);
fprintf('P(1) = %.4f ', P_1);
if P_1 > 0
disp('✓');
else
disp('✗');
end
% Test 2 : P(-1) > 0 (pour n pair)
P_minus1 = polyval(den, -1);
fprintf('P(-1) = %.4f ', P_minus1);
if P_minus1 > 0
disp('✓');
else
disp('✗');
end
% Test 3 : |a0| < an
a0 = den(end);
an = den(1);
fprintf('|a0| = %.4f < |an| = %.4f ? ', abs(a0), abs(an));
if abs(a0) < abs(an)
disp('✓');
else
disp('✗');
end
Résultats attendus
Pour le système donné H(z) = 0.5z+0.3
z 2 −1.2z+0.35
:
Pôles calculés :
z1 ≈ 0.7 + 0.2j
z2 ≈ 0.7 − 0.2j
Modules des pôles :
∣z1 ∣ ≈ 0.728 < 1 ✓
∣z2 ∣ ≈ 0.728 < 1 ✓
Conclusion : Le système est stable car tous les pôles sont à l’intérieur du cercle unité.
Interprétation des réponses temporelles
1. Réponse impulsionnelle : Décroissance exponentielle vers zéro (système stable)
2. Réponse indicielle : Convergence vers une valeur finie (système stable)
3. Diagramme de Bode : Gain décroissant avec la fréquence (comportement de
filtre passe-bas)
Questions de synthèse
1. Que se passe-t-il si un pôle a un module égal à 1 (pôle sur le cercle unité) ?
2. Comment modifier le système pour le rendre plus rapide tout en maintenant la
stabilité ?
3. Quel est l’impact de la période d’échantillonnage sur la position des pôles ?
TP 3 : Synthèse de régulateur PID - Implémentation
pratique dans le plan Z
Objectifs pédagogiques
Ce TP permet aux étudiants de concevoir et d’implémenter un régulateur PID
numérique. À l’issue de ce TP, l’étudiant doit être capable de :
Discrétiser un régulateur PID continu
Implémenter le régulateur dans Simulink
Analyser l’impact des paramètres P, I, D sur les performances
Optimiser les gains pour obtenir une réponse rapide et stable
Description du travail
Partie théorique
Un régulateur PID continu a pour fonction de transfert :
1
+ Kd s = Kp (1 + + Td s )
Ki
C(s) = Kp +
s Ti s
où Kp est le gain proportionnel, Ki est le gain intégral, et Kd est le gain dérivé.
La discrétisation par la méthode d’Euler avant donne :
Te z−1
C(z) = Kp + Ki + Kd
z−1
Te
Partie pratique
Étape 1 : Synthèse du régulateur
Considérez un système de premier ordre :
1
G(s) =
s+1
Objectifs de contrôle :
Erreur statique nulle
Dépassement < 5%
Temps de réponse < 2 secondes
Étape 2 : Implémentation dans Simulink
1. Créez un modèle Simulink avec le système et le régulateur PID
2. Implémentez le régulateur en utilisant la forme discrète
3. Appliquez une entrée échelon et observez la réponse
Étape 3 : Optimisation des paramètres
Utilisez la méthode de Ziegler-Nichols ou le réglage par essais-erreurs pour optimiser
les gains.
Solution
Code MATLAB pour la synthèse du PID
% Script de synthèse du régulateur PID - TP 3
clear all; close all; clc;
% Paramètres du système
num_sys = 1;
den_sys = [1 1];
sys = tf(num_sys, den_sys);
% Période d'échantillonnage
Te = 0.01; % 10 ms
% Discrétisation du système
sys_d = c2d(sys, Te, 'tustin');
% Paramètres du régulateur PID (méthode de Ziegler-Nichols)
% Pour un système du 1er ordre : Kp = 1.2/K, Ki = 0.6/(K*tau), Kd = 0.3*tau
K = 1; % Gain du système
tau = 1; % Constante de temps
Kp = 1.2 / K;
Ki = 0.6 / (K * tau);
Kd = 0.3 * tau;
disp('=== PARAMÈTRES DU RÉGULATEUR PID ===');
fprintf('Kp = %.4f\n', Kp);
fprintf('Ki = %.4f\n', Ki);
fprintf('Kd = %.4f\n', Kd);
% Création du régulateur PID continu
C_cont = tf([Kd Kp Ki], [1 0]);
% Discrétisation du régulateur (méthode de Tustin)
C_disc = c2d(C_cont, Te, 'tustin');
disp('Régulateur PID discret :');
disp(C_disc);
% Système en boucle fermée
sys_bf = feedback(C_disc * sys_d, 1);
% Simulation de la réponse indicielle
t = 0:Te:5;
[y, t] = step(sys_bf, t);
% Affichage des résultats
figure('Position', [100 100 1000 600]);
% Réponse temporelle
subplot(2,2,1);
plot(t, y, 'b-', 'LineWidth', 2);
grid on;
xlabel('Temps (s)');
ylabel('Sortie');
title('Réponse indicielle du système en boucle fermée');
hold on;
plot(t, ones(size(t)), 'r--', 'LineWidth', 1);
legend('Sortie', 'Consigne');
% Diagramme des pôles et zéros en boucle fermée
subplot(2,2,2);
poles_bf = pole(sys_bf);
zeros_bf = zero(sys_bf);
zplane(zeros_bf, poles_bf);
title('Pôles et zéros du système en boucle fermée');
grid on;
% Réponse fréquentielle du régulateur
subplot(2,2,3);
bode(C_disc);
title('Diagramme de Bode du régulateur PID discret');
grid on;
% Erreur de suivi
subplot(2,2,4);
erreur = 1 - y;
plot(t, erreur, 'g-', 'LineWidth', 2);
grid on;
xlabel('Temps (s)');
ylabel('Erreur');
title('Erreur de suivi');
% Calcul des performances
% Dépassement
[max_y, idx_max] = max(y);
depassement = (max_y - 1) * 100;
% Temps de réponse (critère 2%)
idx_tr = find(abs(y - 1) <= 0.02, 1);
if ~isempty(idx_tr)
temps_reponse = t(idx_tr);
else
temps_reponse = NaN;
end
% Erreur statique
erreur_stat = 1 - y(end);
disp('=== PERFORMANCES DU SYSTÈME EN BOUCLE FERMÉE ===');
fprintf('Dépassement : %.2f %%\n', depassement);
fprintf('Temps de réponse (2%%) : %.3f s\n', temps_reponse);
fprintf('Erreur statique : %.6f\n', erreur_stat);
Modèle Simulink - Description
Le modèle Simulink doit contenir :
Bloc Paramètres Fonction
Step Step time = 0, Final value = 1 Génère l’échelon de consigne
Sum List of signs = [+,-] Calcule l’erreur
PID Controller Kp, Ki, Kd (discrétisés) Implémente le régulateur
Transfer Fcn Num = [1], Den = [1 1] Représente le système
Scope (x2) Affiche la consigne et la sortie
Résultats attendus
Avec les paramètres optimisés :
Dépassement : < 5%
Temps de réponse : < 2 secondes
Erreur statique : ≈ 0
Amélioration des performances
Pour réduire le dépassement, augmentez légèrement Kd . Pour accélérer la réponse,
augmentez Kp . Pour éliminer l’erreur statique, augmentez Ki .
Questions de synthèse
1. Comment la période d’échantillonnage affecte-t-elle les performances du
régulateur ?
2. Quel est l’impact de la saturation de l’actionneur sur la stabilité du système ?
3. Comment implémenter un anti-windup pour éviter l’intégration excessive ?
TP 4 : Contrôleur RST pour un système échantillonné
Objectifs pédagogiques
Ce TP permet aux étudiants de concevoir et d’implémenter un contrôleur RST
(Régulateur Standard Tustin). À l’issue de ce TP, l’étudiant doit être capable de :
Comprendre la structure du contrôleur RST
Synthétiser les polynômes R, S, T
Implémenter le contrôleur dans Simulink
Comparer les performances avec un régulateur PID
Description du travail
Partie théorique
Le contrôleur RST a pour structure :
T (z) S(z)
u(k) = yc (k) −
y(k)
R(z) R(z)
où :
R(z) : polynôme de rétroaction
S(z) : polynôme de rétroaction de sortie
T (z) : polynôme de précommande
L’équation caractéristique du système en boucle fermée est :
A(z) + B(z)S(z) = 0
Partie pratique
Étape 1 : Synthèse des polynômes
Considérez un système discret :
0.1z
G(z) =
z2 − 1.5z + 0.5
Objectif : Placer les pôles en boucle fermée à z1 = 0.6 et z2 = 0.4.
Étape 2 : Implémentation
Implémentez le contrôleur RST dans Simulink et comparez avec le PID.
Étape 3 : Analyse comparative
Comparez les performances en termes de :
Rapidité de réponse
Dépassement
Robustesse
Solution
Code MATLAB pour la synthèse RST
% Script de synthèse du contrôleur RST - TP 4
clear all; close all; clc;
% Système discret
num_G = [0.1];
den_G = [1 -1.5 0.5];
Te = 0.1;
% Polynômes A(z) et B(z)
A = [1 -1.5 0.5];
B = [0.1];
% Pôles désirés en boucle fermée
poles_desired = [0.6 0.4];
% Polynôme caractéristique désiré
P = poly(poles_desired);
disp('=== SYNTHÈSE DU CONTRÔLEUR RST ===');
disp('Polynôme A(z) :');
disp(A);
disp('Polynôme B(z) :');
disp(B);
disp('Pôles désirés :');
disp(poles_desired);
disp('Polynôme caractéristique P(z) = A(z) + B(z)*S(z) :');
disp(P);
% Résolution de l'équation de Bézout : A*S + B*R = P
% Pour un système du 2ème ordre, on suppose :
% S(z) = s0 + s1*z
% R(z) = r0
% Construction de la matrice pour résoudre le système linéaire
% [A0 A1 A2 B0] [s0] [P0]
% [0 A0 A1 B0] [s1] = [P1]
% [0 0 A0 B0] [r0] [P2]
% Matrice du système
M = [A(1) A(2) A(3) B(1);
0 A(1) A(2) B(1);
0 0 A(1) B(1)];
% Vecteur des résultats désirés
P_vec = P;
% Résolution
try
% Utiliser la pseudo-inverse pour résoudre
coeff = pinv(M) * P_vec';
s0 = coeff(1);
s1 = coeff(2);
r0 = coeff(3);
disp('Polynôme S(z) :');
S = [s1 s0];
disp(S);
disp('Polynôme R(z) :');
R = [r0];
disp(R);
% Polynôme T(z) pour suivi de consigne
% T(z) = P(z) / B(z) pour un suivi parfait
T = P / B(1);
disp('Polynôme T(z) :');
disp(T);
catch
disp('Erreur : Impossible de synthétiser le contrôleur RST');
disp('Vérifiez que le système est commandable');
end
% Création du système en boucle fermée
% Fonction de transfert en boucle fermée
num_bf = B;
den_bf = P;
sys_bf = tf(num_bf, den_bf, Te);
% Simulation
t = 0:Te:2;
[y, t] = step(sys_bf, t);
% Affichage
figure('Position', [100 100 1000 600]);
subplot(2,2,1);
plot(t, y, 'b-', 'LineWidth', 2);
hold on;
plot(t, ones(size(t)), 'r--', 'LineWidth', 1);
grid on;
xlabel('Temps (s)');
ylabel('Sortie');
title('Réponse indicielle avec contrôleur RST');
legend('Sortie', 'Consigne');
subplot(2,2,2);
zplane(poles_desired, []);
title('Pôles désirés en boucle fermée');
grid on;
subplot(2,2,3);
poles_bf = pole(sys_bf);
zplane(poles_bf, []);
title('Pôles réels du système en boucle fermée');
grid on;
subplot(2,2,4);
erreur = 1 - y;
plot(t, erreur, 'g-', 'LineWidth', 2);
grid on;
xlabel('Temps (s)');
ylabel('Erreur');
title('Erreur de suivi');
% Calcul des performances
[max_y, idx_max] = max(y);
depassement = (max_y - 1) * 100;
idx_tr = find(abs(y - 1) <= 0.02, 1);
if ~isempty(idx_tr)
temps_reponse = t(idx_tr);
else
temps_reponse = NaN;
end
erreur_stat = 1 - y(end);
disp('=== PERFORMANCES ===');
fprintf('Dépassement : %.2f %%\n', depassement);
fprintf('Temps de réponse (2%%) : %.3f s\n', temps_reponse);
fprintf('Erreur statique : %.6f\n', erreur_stat);
Résultats attendus
Le contrôleur RST offre une meilleure réactivité qu’un PID classique car il place
directement les pôles en boucle fermée aux positions désirées.
Comparaison PID vs RST
Critère PID RST
Réglage Empirique (Ziegler-Nichols) Analytique (placement de pôles)
Complexité Faible Moyenne
Robustesse Bonne Excellente
Rapidité Moyenne Élevée
Questions de synthèse
1. Comment modifier le contrôleur RST pour obtenir un suivi de rampe sans erreur ?
2. Quel est l’impact de l’incertitude du modèle sur la performance du contrôleur
RST ?
3. Comment implémenter un anti-windup dans le contrôleur RST ?
TP 5 : Simulation d’un système multi-boucles avec
correcteurs numériques
Objectifs pédagogiques
Ce dernier TP permet aux étudiants d’intégrer tous les concepts précédents pour
concevoir un système de contrôle multi-boucles. À l’issue de ce TP, l’étudiant doit être
capable de :
Concevoir une boucle de contrôle interne (courant/vitesse)
Concevoir une boucle de contrôle externe (position/température)
Implémenter les correcteurs numériques
Analyser les interactions entre boucles
Optimiser les performances globales
Description du travail
Partie théorique
Un système multi-boucles typique comprend :
1. Boucle interne : Contrôle de courant ou de vitesse (bande passante élevée)
2. Boucle externe : Contrôle de position ou de température (bande passante plus
faible)
La séparation des échelles de temps permet de concevoir indépendamment chaque
boucle.
Partie pratique
Étape 1 : Modélisation du système
Considérez un moteur à courant continu avec :
Équation électrique : L dt
di
+ Ri = u − Ke ω
Équation mécanique : J dω
dt = Kt i − f ω
Paramètres :
R = 1 Ω (résistance)
L = 0.1 H (inductance)
J = 0.01 kg·m² (inertie)
Kt = 0.1 N·m/A (constante de couple)
Ke = 0.1 V·s/rad (constante de FEM)
f = 0.01 N·m·s/rad (frottement)
Étape 2 : Conception des boucles
1. Boucle de courant : Régulateur PI avec fe = 1 kHz
2. Boucle de vitesse : Régulateur PI avec fe = 100 Hz
3. Boucle de position : Régulateur PID avec fe = 10 Hz
Étape 3 : Simulation et validation
Simulez le système avec des consignes de position échelon et rampe.
Solution
Code MATLAB pour le système multi-boucles
% Script de simulation du système multi-boucles - TP 5
clear all; close all; clc;
% Paramètres du moteur
R = 1; % Résistance (Ω)
L = 0.1; % Inductance (H)
J = 0.01; % Inertie (kg·m²)
Kt = 0.1; % Constante de couple (N·m/A)
Ke = 0.1; % Constante de FEM (V·s/rad)
f = 0.01; % Frottement (N·m·s/rad)
% Périodes d'échantillonnage
Te_courant = 0.001; % 1 kHz
Te_vitesse = 0.01; % 100 Hz
Te_position = 0.1; % 10 Hz
% === BOUCLE DE COURANT ===
% Fonction de transfert : I(s) / U(s) = 1 / (L*s + R)
num_I = 1;
den_I = [L R];
sys_I = tf(num_I, den_I);
sys_I_d = c2d(sys_I, Te_courant, 'tustin');
% Régulateur PI pour le courant
Kp_I = 0.5;
Ki_I = 1;
C_I = tf([Ki_I Kp_I], [1 0]);
C_I_d = c2d(C_I, Te_courant, 'tustin');
disp('=== SYSTÈME MULTI-BOUCLES ===');
disp('Boucle de courant (1 kHz) :');
disp('Système discret :');
disp(sys_I_d);
disp('Régulateur PI discret :');
disp(C_I_d);
% === BOUCLE DE VITESSE ===
% Fonction de transfert : Ω(s) / I(s) = Kt / (J*s + f)
num_W = Kt;
den_W = [J f];
sys_W = tf(num_W, den_W);
sys_W_d = c2d(sys_W, Te_vitesse, 'tustin');
% Régulateur PI pour la vitesse
Kp_W = 1;
Ki_W = 0.5;
C_W = tf([Ki_W Kp_W], [1 0]);
C_W_d = c2d(C_W, Te_vitesse, 'tustin');
disp('Boucle de vitesse (100 Hz) :');
disp('Système discret :');
disp(sys_W_d);
disp('Régulateur PI discret :');
disp(C_W_d);
% === BOUCLE DE POSITION ===
% Fonction de transfert : Θ(s) / Ω(s) = 1 / s
num_Theta = 1;
den_Theta = [1 0];
sys_Theta = tf(num_Theta, den_Theta);
sys_Theta_d = c2d(sys_Theta, Te_position, 'tustin');
% Régulateur PID pour la position
Kp_Theta = 2;
Ki_Theta = 0.5;
Kd_Theta = 0.2;
C_Theta = tf([Kd_Theta Kp_Theta Ki_Theta], [1 0]);
C_Theta_d = c2d(C_Theta, Te_position, 'tustin');
disp('Boucle de position (10 Hz) :');
disp('Système discret :');
disp(sys_Theta_d);
disp('Régulateur PID discret :');
disp(C_Theta_d);
% === SIMULATION COMPLÈTE ===
% Modèle Simulink simplifié (simulation en cascade)
% Pour une simulation complète, créer un modèle Simulink avec les trois boucles
% Simulation simplifiée : boucle fermée de position
sys_complet = feedback(C_Theta_d * sys_Theta_d, 1);
t = 0:Te_position:10;
[y_theta, t] = step(sys_complet, t);
% Affichage des résultats
figure('Position', [100 100 1200 700]);
% Réponse de position
subplot(3,2,1);
plot(t, y_theta, 'b-', 'LineWidth', 2);
hold on;
plot(t, ones(size(t)), 'r--', 'LineWidth', 1);
grid on;
xlabel('Temps (s)');
ylabel('Position (rad)');
title('Réponse de position');
legend('Position', 'Consigne');
% Diagramme des pôles
subplot(3,2,2);
poles_complet = pole(sys_complet);
zplane(poles_complet, []);
title('Pôles du système en boucle fermée');
grid on;
% Réponse fréquentielle de la boucle de courant
subplot(3,2,3);
bode(C_I_d);
title('Diagramme de Bode - Régulateur de courant');
grid on;
% Réponse fréquentielle de la boucle de vitesse
subplot(3,2,4);
bode(C_W_d);
title('Diagramme de Bode - Régulateur de vitesse');
grid on;
% Réponse fréquentielle de la boucle de position
subplot(3,2,5);
bode(C_Theta_d);
title('Diagramme de Bode - Régulateur de position');
grid on;
% Erreur de suivi
subplot(3,2,6);
erreur = 1 - y_theta;
plot(t, erreur, 'g-', 'LineWidth', 2);
grid on;
xlabel('Temps (s)');
ylabel('Erreur');
title('Erreur de suivi de position');
% Calcul des performances
[max_y, idx_max] = max(y_theta);
depassement = (max_y - 1) * 100;
idx_tr = find(abs(y_theta - 1) <= 0.02, 1);
if ~isempty(idx_tr)
temps_reponse = t(idx_tr);
else
temps_reponse = NaN;
end
erreur_stat = 1 - y_theta(end);
disp('=== PERFORMANCES GLOBALES ===');
fprintf('Dépassement : %.2f %%\n', depassement);
fprintf('Temps de réponse (2%%) : %.3f s\n', temps_reponse);
fprintf('Erreur statique : %.6f\n', erreur_stat);
% Analyse de stabilité
disp('=== ANALYSE DE STABILITÉ ===');
disp('Pôles du système en boucle fermée :');
disp(poles_complet);
if all(abs(poles_complet) < 1)
disp('✓ Système STABLE');
else
disp('✗ Système INSTABLE');
end
Architecture du modèle Simulink multi-boucles
Consigne de position
↓
[Régulateur PID - Position]
↓
Consigne de vitesse
↓
[Régulateur PI - Vitesse]
↓
Consigne de courant
↓
[Régulateur PI - Courant]
↓
[Moteur CC]
↓
Position/Vitesse/Courant (retours)
Résultats attendus
Temps de réponse de position : < 1 seconde
Dépassement : < 10%
Erreur statique : < 0.1%
Stabilité : Tous les pôles à l’intérieur du cercle unité
Optimisation des performances
Pour améliorer les performances :
1. Augmenter la bande passante : Réduire les périodes d’échantillonnage
2. Améliorer le couplage : Ajuster les gains pour une meilleure interaction entre
boucles
3. Ajouter des filtres : Réduire le bruit de mesure
Questions de synthèse
1. Comment la séparation des échelles de temps améliore-t-elle la stabilité ?
2. Quel est l’impact de la latence de communication entre boucles ?
3. Comment implémenter un observateur d’état pour améliorer les performances ?
Conclusion
Ces cinq travaux pratiques couvrent les aspects essentiels de la commande numérique
des systèmes dynamiques. Ils permettent aux étudiants d’acquérir une
compréhension théorique solide et une expérience pratique en simulation et
implémentation de correcteurs numériques.
Les concepts abordés incluent :
La conversion A/N et N/A
L’analyse de stabilité des systèmes discrets
La synthèse de régulateurs PID et RST
La conception de systèmes multi-boucles
Chaque TP peut être étendu avec des variantes (changement de paramètres, ajout de
perturbations, étude de la robustesse, etc.) pour approfondir la compréhension des
étudiants.
Références bibliographiques
[1] Franklin, G. F., Powell, J. D., & Workman, M. L. (1990). Digital control of dynamic
systems. Addison-Wesley Publishing Company.
[2] Viault, D., & Quenec’hdu, Y. (1977). Systèmes asservis échantillonnés. ESE.
[3] Sueur, C., Vanheeghe, P., & Borne, P. (2000). Automatique des systèmes
échantillonnés : éléments de cours et exercices résolus. Technip.
[4] Borne, P., Tanguy, G. D., Richard, J. P., Rotella, F., & Zambetalcis, I. (1993). Analyse et
régulation de processus industriels régulation numérique (Vol. 2). Éditions Technip.
[5] Gopal, M. (1988). Digital control engineering. John Wiley & Sons.
Document généré par Manus AI
Mars 2026