Réglage (Rapide) d'un Correcteur PI

Le schéma simplifié d’un asservissement est le suivant

Le systéme à Asservir regroupe donc Le moteur, le variateur, les périphériques ; éventuellement une boucle de courant.

Modélisation du Systéme à Asservir

Avant tout calcul de correcteur, il est nécessaire d’avoir une idée du modèle du système à asservir (le plus simple étant le premier ordre

\frac{G}{1+\tau .s}

Un simple essai indiciel suffit donc à déterminer le Gain et la Constante de temps du système Ã asservir :

On envoie donc un échelon sur Iq* (consigne de l’image du courant) et on observe N (image de la vitesse). Le gain G correspond au rapport entre le régime continu de la mesure et l’amplitude de l’échelon de commande. La constante de temps $\tau$ correspond au temps nécessaire pour que la mesure atteigne 63% du régime continu.

A noter que la période d’échantillonnage du correcteur doit être au moins 10 fois plus petite que $\tau$ (afin de “voir” les transitoires précisément).

Détermination d’un correcteur PI

De manière générale, asservir (boucler) un système peut entrainer de l’instabilité.

On considère le système suivant, FTBO(s) système à asservir :

Si le module de FTBO(s) est inférieur à -1, on soustrait à la consigne une valeur négative, ce qui a pour conséquence de rendre l’ensemble instable.

Par ailleurs la consigne étant généralement soit un échelon soit une rampe, constitué d’une somme de sinusoïdes de différentes fréquences (cf. décomposition en séries de fourrier) , il peut exister une fréquence pour laquelle on s’approche dangereusement de ce point -1.

Tout le problème de l’automatique est de veiller à respecter une certaine distance vis-à-vis de ce point.

Le diagramme de Nyquist représente le tracé de FTBO(s) pour l’ensemble des fréquences :

La marge de phase correspond à la distance entre le point -1 et la courbe de FTBO lorsque cette dernière coupe le cercle de rayon 1.

Cette marge de phase est également visible (et plus facilement mesurable) sur le bode de FTBO :

Un critère de réglage d’un correcteur peut donc être l’observation de cette marge de phase.

Rappel des différentes caractéristiques d’une réponse d’un système :

Stabilité : Respect d’une marge de phase d’au moins 30°
Précision : La mesure rejoint-elle la consigne ?
- Dans le cas d’une réponse à un échelon, nécessité d’une intégration $s^{-1}$ dans la boucle ouverte pour respecter une erreur statique nulle
- Dans le cas d’une réponse à une rampe, nécessité déune double intégration $\frac{1}{s^{2}}$ dans la boucle ouverte pour respecter une erreur de trainage nulle.
Rapidité

Un correcteur PI possède une intégration, ce qui permet de régler le problème de l’erreur statique. En contrepartie il ralentit le système, on veillera donc à respecter une marge de phase suffisante mais pas trop grande non plus (plus la marge de phase est grande, plus la réponse et lente et les risques de saturation augmentent).

Ci-dessous figurent les bodes du correcteur PI et de FTBO tel que la constante de temps du correcteur PI vaut 0.1* $\tau$

$PI(s)=K _{1}+\frac{K _{2}}{s}$

On préfèrera la forme : $PI(s)=K _{p}.\frac{\omega _{i}}{s}.(1+\frac{s}{\omega _{i}})$

avec :
$K _{p}=K _{1}$
$\omega _{i}=\frac{K _{1}}{K _{2}}=\frac{1}{T _{i}}$

{: .image_center width=“500px”}

L’association de ces deux blocs donne :

La constante de temps du correcteur étant fixée, le tracé de la phase est figé, on peut alors jouer sur le gain du correcteur pour modifier le module du système corrigé en boucle ouverte et de fait régler la marge de phase.

Pour une marge de phase de 45° on a la réponse temporelle suivante :

Les fichiers de calcul ci dessous reprennent la méthode décrite ; il suffit de modifier les paramètres du système identifié en boucle ouverte, puis modifier le gain du correcteur PI pour avoir une marge de phase correcte. A noter qu’il s’agit d’un PI ANALOGIQUE.

PYTHON

CALCUL_PI.py

#!/usr/bin/python
#jupyter-qtconsole

import numpy as np
import matplotlib.pyplot as plt
from control import *

#=================================================
# CARACTERISTIQUES DU 1er ORDRE IDENTIFIE

G=56
tau=60e-3
#=================================================
# SYSTEME A ASSERVIR ( EN BOUCLE OUVERTE )
FTBO=tf(G,[tau,1]) 

print(FTBO)

t,y=step_response(FTBO)
plt.plot(t,y)
plt.grid()
plt.xlabel('t')
plt.ylabel('FTBO(t)')
plt.show()
#=================================================
# CORRECTEUR PI
ti = 0.1*tau
Kpi = 0.01

CORR = Kpi*tf([ti, 1],[ti, 0])
print(CORR)

mag,phase,omega=bode(CORR, Hz=True,dB=True)
plt.show()

#=================================================
# ASSOCIATION CORRECTEUR PI + SYSTEME A ASSERVIR
FTBO_CORR=CORR*FTBO
gm, pm, wg , wp = margin(FTBO_CORR)

mag,phase,omega=bode(FTBO_CORR, dB=True)
plt.grid()
plt.show()
#=================================================
# SYSTEME CORRIGE EN BOUCLE FERMEE

FTBF= (CORR*FTBO)/(1+CORR*FTBO)

t,y=step_response(FTBF)

plt.plot(t,y)
plt.grid()
plt.xlabel('t')
plt.ylabel('FTBO(t)')
plt.show()
#=================================================

OCTAVE

CALCUL_PI.m

%***********************************************************************
%   IPS - CALCUL D'UN PI 
%   kerhoas@enib.fr
%***********************************************************************
% Pour octave, installer le package 'control' et lancer la commande :
% pkg load control

i=0; % index Figures
%-----------------------------------------------------------------------
%    Définition du Gain et de la Constante de Temps en Boucle Ouverte
%    du système à asservir G/(1+to*s)
%-----------------------------------------------------------------------

G=2.5
to=50e-3

%-----------------------------------------------------------------------
%              Fonction de Transfert en Boucle Ouverte + Tracé
%-----------------------------------------------------------------------

FTBO = tf([G],[to,1])

i=i+1;
figure(i)
t=0:0.0001:1
step(FTBO,t)
grid
title('FTBO - REPONSE A UN ECHELON')

i=i+1;
figure(i)
subplot(1,2,1)
nyquist(FTBO)
grid
title('FTBO - NYQUIST')
subplot(1,2,2)
bode(FTBO)
grid
title('FTBO - BODE')

%-----------------------------------------------------------------------
%              Définition du Correcteur PI + Tracé
%-----------------------------------------------------------------------

ti = 0.1*to
Kpi = 1

CORR = tf(Kpi*[ti , 1],[ti, 0])

i=i+1;
figure(i)
bode(CORR)
grid
title('CORRECTEUR PI - BODE')
%hold on 
%bode(FTBO)

%-----------------------------------------------------------------------
%     Fonction de Transfert EN BO du Système Corrigé + Tracé
%-----------------------------------------------------------------------

FTBO_CORR=CORR*FTBO
[Gm,Pm,Wg,Wp] = margin(FTBO_CORR) % Pm Marge de Phase

i=i+1;
figure(i)
bode(FTBO_CORR)
margin(FTBO_CORR)
grid
title('FTBO CORRIGE - BODE - MARGE DE PHASE')

%-----------------------------------------------------------------------
%     Fonction de Transfert EN BF du Système Corrigé + Tracé
%-----------------------------------------------------------------------

FTBF= (CORR*FTBO)/(1+CORR*FTBO)

i=i+1;
figure(i)
bode(FTBF)
title('FTBF CORRIGE - BODE')
grid
i=i+1;
figure(i)
t=0:0.0001:1
step(FTBF,t)
grid
title('FTBF CORRIGE - REPONSE TEMPORELLE A UN ECHELON')

SCILAB

CALCUL_PI.sce

//
// Script Scilab pour régler un correcteur PI
//

// =====================================================================
// Système à asservir
//
//           G1
// G(s) = ----------
//        1 + tau1*s
//
// ---------------------------------------------------------------------
G1   = 1500/980;  // Gain du système à asservir
tau1 = 100e-3;      // Cte de temps du système à asservir
// ---------------------------------------------------------------------

// =====================================================================
// Correcteur PI
//
// Cpi(s) = Kp + Ki/s = K*(1 + 1/(Ti*s)) [avec K = Kp]
//
// ---------------------------------------------------------------------
Ti = 0.1*tau1; // fixé
K  = 1;        // gain à régler
// ---------------------------------------------------------------------

// NE PAS MODIFIER LA SUITE DU SCRIPTS

// transfert du système non corrigé
FTnc = syslin("c",G1/(1 + tau1*%s));

// transfert du correcteur PI
Cpi = syslin("c",K*(1 + 1/Ti/%s));

// transfert en bo du système corrigé
FTbo = Cpi*FTnc;

// Lieu de Black
scf();
black(FTbo); xgrid();

// Diagrammes de Bode
scf();
bode(FTbo); xgrid();

// Marge - coupure
[Pmarge,fc] = p_margin(FTbo);
Pmarge      = round(Pmarge);
fc          = .01*round(100*fc);
msg1 = ["Marge phase   : " string(Pmarge) "°" ; "Fréq. coupure : " string(fc) "Hz"];
msg2 = "Kp = " + string(K) + " ; Ki = " + string(K/Ti);
disp(msg1)
disp(msg2)

Correcteur Numérique

Discrétisation

$K_{i}=\frac{T_{e}}{T_{i}}$
$u_{p}[n]=K_{p}.\epsilon[n]$
$u_{i}[n]=u_{i}[n-1] + K_{p}.K_{i}.\epsilon[n]$
$cde[n]=u_{p}[n] + u_{i}[n]$

Vérification

On a supposé jusqu’à présent un système parfaitement linéaire.
En réalité il existe toujours des saturations.
Il faut donc vérifier l’allure de la commande, en s’assurant que cette dernière ne sature pas.

Vérification avec scilab-xcos :

sys_corr.zcos
contexte.sce

La boucle de courant dans les Moteurs Electriques Asservissement d'un Moteur à Courant Continu