Outils Logiciels (OL) - Semestre 4

PART A - Présentation Générale du Cours

Contexte et objectifs

Suite OL S3 : transformée en Z, commande numérique, séries. Outils mathématiques pour automatique numérique et filtrage numérique S4.

Objectifs :

Prérequis

PART B: EXPÉRIENCE, CONTEXTE ET FONCTION

Module 1 : Transformée en Z avancée

Définition (rappel) : \(X(z) = \sum_{n=0}^{\infty} x[n] z^{-n}\)

Propriétés essentielles :

Applications :

Module 2 : Commande numérique

Discrétisation systèmes continus :

Correcteurs numériques :

Analyse performances :

Module 3 : Séries numériques

Séries entières : \(\sum_{n=0}^{\infty} a_n x^n\)

Séries numériques :

Applications :

PART C: ASPECTS TECHNIQUES

TP1 : Transformée en Z

TP2 : PID numérique

TP3 : Filtrage numérique par Z-transform

TP4 : Séries

Outils

PART D: ANALYSE ET RÉFLEXION

Évaluation

Compétences acquises

Liens interdisciplinaires

📚 Contenu du cours

Transformation en Z

Définition

Transformée en Z directe : \(X(z) = \sum_{n=0}^{\infty} x[n]z^{-n}\)

Transformée en Z inverse : Méthodes :

Propriétés

Transformées usuelles

Région de convergence (ROC)

Asservissement numérique

Systèmes échantillonnés

Échantillonnage :

Bloqueur d’ordre zéro (BOZ) :

Fonction de transfert en Z

Système numérique : \(H(z) = \frac{Y(z)}{U(z)} = \frac{b_0 + b_1z^{-1} + \ldots + b_m z^{-m}}{1 + a_1z^{-1} + \ldots + a_n z^{-n}}\)

Équation aux différences : \(y[n] = -\sum_{k=1}^{n}a_k y[n-k] + \sum_{k=0}^{m}b_k u[n-k]\)

Discrétisation de systèmes continus

Méthode d’Euler (avant) : \(s \approx \frac{z-1}{T_e}\)

Méthode d’Euler (arrière) : \(s \approx \frac{z-1}{T_e z}\)

Transformation bilinéaire (Tustin) : \(s \approx \frac{2}{T_e}\frac{z-1}{z+1}\)

Meilleure conservation de la stabilité

Invariance impulsionnelle : Échantillonnage de la réponse impulsionnelle

Stabilité

Critère : Tous les pôles dans le cercle unité : $|z_i| < 1$

Tests :

Analyse de performances

Réponse temporelle :

Erreur en régime permanent : \(\epsilon_{\infty} = \lim_{n\to\infty} e[n] = \lim_{z\to 1} (z-1)E(z)\)

Synthèse de correcteurs

Correcteur proportionnel (P) : \(C(z) = K_p\)

Correcteur proportionnel-intégral (PI) : \(C(z) = K_p + K_i\frac{T_e z}{z-1}\)

Correcteur proportionnel-intégral-dérivé (PID) : \(C(z) = K_p + K_i\frac{T_e z}{z-1} + K_d\frac{z-1}{T_e z}\)

Correcteur RST :

Séries numériques et entières

Convergence de séries

Développements en série

Applications

🛠️ Travaux pratiques

TP Transformation en Z

TP Asservissement numérique

Système étudié : Position moteur DC

Étapes :

  1. Modélisation continue
  2. Discrétisation (Tustin)
  3. Analyse en boucle ouverte
  4. Synthèse correcteur PI ou PID
  5. Simulation réponse indicielle
  6. Validation robustesse

Outils MATLAB :

TP Comparaison méthodes de discrétisation

Projet : Asservissement pratique

💻 Outils utilisés

Simulation

Analyse

Implémentation

📊 Évaluation

🔗 Liens avec d’autres cours

📐 Exemple d’application

Régulateur PID numérique

Algorithme position :

e = r - y;           % Erreur
P = Kp * e;          % Terme proportionnel
I = I + Ki*Te*e;     % Terme intégral
D = Kd/Te * (e - e_prev);  % Terme dérivé
u = P + I + D;       % Commande
e_prev = e;          % Sauvegarde

Algorithme vitesse (incrémentiel) :

delta_u = q0*e[n] + q1*e[n-1] + q2*e[n-2];
u[n] = u[n-1] + delta_u;

Avec :

Anti-windup :

if u > u_max
    u = u_max;
    I = I - Ki*Te*e;  % Ne pas intégrer
elseif u < u_min
    u = u_min;
    I = I - Ki*Te*e;
end

Système du premier ordre

Continu : \(H(s) = \frac{K}{\tau s + 1}\)

Discret (Tustin, Te=0.1s, τ=1s, K=1) : \(H(z) = \frac{0.0476(z+1)}{z - 0.905}\)

💡 Applications pratiques

Régulation

Filtrage

Traitement du signal

📖 Compétences développées

🎯 Plan en Z (stabilité)

Cercle unité :

Correspondance plan s → plan z :

⚠️ Pièges courants

Discrétisation

PID numérique

Implémentation

🔧 Bonnes pratiques

Choix de Te

Réglage PID

Méthode de Ziegler-Nichols (numérique) :

  1. Trouver gain critique Kc
  2. Période d’oscillation Tc
  3. Calculer Kp, Ki, Kd

Réglage empirique :

  1. P seul : augmenter jusqu’à oscillation
  2. Ajouter I : éliminer erreur statique
  3. Ajouter D : réduire dépassement

Code embarqué