Correcteurs Usuels

Ce chapitre présente les correcteurs P, PI et PID sous forme numérique. Pour chaque correcteur, nous donnons la fonction de transfert en $z$ (obtenue par la méthode de Tustin) et l'équation de récurrence permettant l'implémentation.

Schéma de régulation numérique

Dans une boucle de régulation numérique, le correcteur $C(z)$ calcule la commande $u[n]$ à partir de l'erreur $\epsilon [n]=r[n]-y[n]$ où $r[n]$ est la consigne et $y[n]$ la mesure.

Correcteur Proportionnel (P)

Forme continue

$$C(s)=K_p$$

Forme discrète

Le correcteur P est indépendant de la fréquence, sa numérisation est donc triviale :

$$C(z)=K_p$$

Équation de récurrence

$$u[n]=K_p\cdot \epsilon [n]$$

Propriétés

• Avantage : Simple à implémenter, réponse rapide
• Inconvénient : Erreur statique non nulle en général

Correcteur Proportionnel-Intégral (PI)

Forme continue

$$C(s)=K_p(1+\frac{1}{T_{i}s})=K_p\frac{1+T_{i}s}{T_{i}s}$$

où :

• $K_p$ : gain proportionnel
• $T_i$ : constante de temps d'intégration

Forme discrète (Tustin)

En appliquant la substitution de Tustin $s=\frac{2}{T_e}\frac{z-1}{z+1}$ :

$$C(z)=K_p\frac{(T_i+T_e/2)z+(T_e/2-T_i)}{T_i(z-1)}$$

En posant $a=1+\frac{T_e}{2T_i}$ et $b=1-\frac{T_e}{2T_i}$ :

$$C(z)=K_p\frac{az-b}{z-1}$$

Démonstration

Partant de $C(s)=K_p(1+\frac{1}{T_{i}s})$ et en substituant $s=\frac{2}{T_e}\frac{z-1}{z+1}$ :

$$C(z)=K_p(1+\frac{1}{T_i\cdot \frac{2}{T_e}\frac{z-1}{z+1}})=K_p(1+\frac{T_e}{2T_i}\frac{z+1}{z-1})$$$$C(z)=K_p\frac{(z-1)+\frac{T_e}{2T_i}(z+1)}{z-1}=K_p\frac{z(1+\frac{T_e}{2T_i})-1+\frac{T_e}{2T_i}}{z-1}$$

En posant $a=1+\frac{T_e}{2T_i}$ et $b=1-\frac{T_e}{2T_i}$ :

$$C(z)=K_p\frac{az-b}{z-1}$$

Équation de récurrence

À partir de $U(z)(z-1)=K_p(az-b)E(z)$, on obtient :

$$u[n]=u[n-1]+K_p(a\cdot \epsilon [n]-b\cdot \epsilon [n-1])$$

Forme incrémentale

Cette forme est dite incrémentale car la commande est calculée comme une correction de la valeur précédente. Elle présente l'avantage de limiter les discontinuités lors de changements de consigne.

Implémentation

# Initialisation
u_prev = 0
eps_prev = 0

# Paramètres
a = 1 + Te / (2 * Ti)
b = 1 - Te / (2 * Ti)

# Boucle de contrôle
def pi_controller(eps):
    global u_prev, eps_prev
    u = u_prev + Kp * (a * eps - b * eps_prev)
    u_prev = u
    eps_prev = eps
    return u

Réponse indicielle d'un système avec correcteur PI numérique

Correcteur Proportionnel-Intégral-Dérivé (PID)

Forme continue

$$C(s)=K_p(1+\frac{1}{T_{i}s}+T_{d}s)$$

où :

• $K_p$ : gain proportionnel
• $T_i$ : constante de temps d'intégration
• $T_d$ : constante de temps de dérivation

Forme parallèle

Le PID peut aussi s'écrire sous forme parallèle :

$$C(s)=K_p+\frac{K_i}{s}+K_{d}s$$

avec $K_i=\frac{K_p}{T_i}$ et $K_d=K_p{T}_d$.

Forme discrète (Tustin)

En appliquant Tustin à chaque terme :

• Terme P : $K_p$
• Terme I : $K_i\frac{T_e}{2}\frac{z+1}{z-1}$
• Terme D : $K_d\frac{2}{T_e}\frac{z-1}{z+1}$

Équation de récurrence (forme incrémentale)

La forme incrémentale du PID numérique est :

$$\mathrm{\Delta }u[n]=u[n]-u[n-1]$$$$\mathrm{\Delta }u[n]=K_p(\epsilon [n]-\epsilon [n-1])+K_i{T}_e\epsilon [n]+\frac{K_d}{T_e}(\epsilon [n]-2\epsilon [n-1]+\epsilon [n-2])$$

En regroupant les termes :

$$\mathrm{\Delta }u[n]=q_0\epsilon [n]+q_1\epsilon [n-1]+q_2\epsilon [n-2]$$

avec :

• $q_0=K_p+K_i{T}_e+\frac{K_d}{T_e}$
• $q_1=-K_p-\frac{2K_d}{T_e}$
• $q_2=\frac{K_d}{T_e}$

Équation de récurrence (forme position)

$$u[n]=u[n-1]+q_0\epsilon [n]+q_1\epsilon [n-1]+q_2\epsilon [n-2]$$

Implémentation

# Initialisation
u_prev = 0
eps_prev1 = 0  # epsilon[n-1]
eps_prev2 = 0  # epsilon[n-2]

# Coefficients
q0 = Kp + Ki * Te + Kd / Te
q1 = -Kp - 2 * Kd / Te
q2 = Kd / Te

# Boucle de contrôle
def pid_controller(eps):
    global u_prev, eps_prev1, eps_prev2
    u = u_prev + q0 * eps + q1 * eps_prev1 + q2 * eps_prev2
    # Mise à jour des variables
    u_prev = u
    eps_prev2 = eps_prev1
    eps_prev1 = eps
    return u

Réponse indicielle d'un système avec correcteur PID numérique

Améliorations pratiques

Anti-windup

Lorsque l'actionneur sature, l'intégrateur continue d'accumuler l'erreur, ce qui provoque un dépassement important lors du retour en zone linéaire. L'anti-windup limite cet effet :

def pi_controller_antiwindup(eps, u_min, u_max):
    global u_prev, eps_prev, integral

    # Calcul de la commande
    integral += Ki * Te * eps
    u = Kp * eps + integral

    # Saturation avec anti-windup
    if u > u_max:
        u = u_max
        integral = u_max - Kp * eps  # Recalcul de l'intégrale
    elif u < u_min:
        u = u_min
        integral = u_min - Kp * eps

    eps_prev = eps
    return u

Filtrage de la dérivée

L'action dérivée amplifie le bruit de mesure. On ajoute souvent un filtre passe-bas :

$$D(s)=\frac{K_{d}s}{1+\frac{T_d}{N}s}$$

où $N$ est typiquement entre 5 et 20.

Tableau récapitulatif

Correcteur	Fonction de transfert $C(s)$	Annule l'erreur statique	Action anticipatrice
P	$K_p$	Non	Non
PI	$K_p(1+\frac{1}{T_{i}s})$	Oui	Non
PID	$K_p(1+\frac{1}{T_{i}s}+T_{d}s)$	Oui	Oui

Choix de la période d'échantillonnage

Pour un bon fonctionnement du correcteur numérique, la période d'échantillonnage $T_e$ doit être choisie suffisamment petite par rapport à la dynamique du système :

$$T_e\in [\frac{\tau }{20},\frac{\tau }{5}]$$

où $\tau$ est la constante de temps dominante du système en boucle fermée.

Attention

Une période d'échantillonnage trop grande dégrade les performances et peut même rendre le système instable.