Laboratoire de régulation numérique. Programmation d'un régulateur PID numérique

Transcription

1 Programmation d'un régulateur PID numérique Table des matières 1 Introduction 2 2 Réalisation d'un régulateur PID numérique But et caier des carges du travail Environnements matériel et logiciel à disposition Edition du cier regul.c, programmation du régulateur Compilation du cier regul.c Essai du régulateur Canevas du cier regul.c 6 4 Régulateur PID numérique 7 4.A Loi de commande B Algoritme selon "textbook" C Algoritme modié Régulateur PID numérique, v MEE \pid_num.tex

2 1 Introduction Le but de ce travail de laboratoire est de programmer puis de mettre en oeuvre une première version du régulateur numérique de type PID. L'algoritme du régulateur sera programmé en langage de aut niveau C sur Windows XP puis testé sur un système à régler du laboratoire simulateur analogique, foen, rail, etc. Bien que l'environnement de travail proposé Windows XP, temps réel, Simulink, etc puisse paraître relativement complexe, il est bon de se rappeler que la seule et unique fonction C que l'on demande de programmer est Le code devra se trouver dans le cier reg_pid regul.c L'annexe 4 page 7 fournit un rappel téorique le régulateur PID numérique. 2 Réalisation d'un régulateur PID numérique 2.1 But et caier des carges du travail On propose dans le cadre de cette manipulation de laboratoire d'écrire le programme C implantant l'algoritme du régulateur PID numérique présenté en annexe 4. Ce programme sera utilisé ultérieurement dans le cadre du laboratoire de régulation numérique. Le programme à écrire doit orir les fonctionnalités suivantes : régulateur PID comprenant les trois actions P, I et D ; limitation logicielle de la grandeur de commande calculée par le régulateur. Le code du régulateur PID devra être testé et validé de façon à ce que l'utilisateur ait l'assurance que les gains K p, T i et T d ainsi que la période d'écantillonnage qu'il applique sont bel et bien ceux pris en compte par la fonction implantant l'algoritme du régulateur. Il est nécessaire de dénir la procédure de test, qui fait partie intégrante de ce travail. Le programme devra être soigneusement documenté et l'on fera usage notamment de variables de type tableau pour la mémorisation des données nécessaires au fonctionnement du régulateur. La fonction programmée sera codée dans le cier regul.c dont le canevas est à disposition cier regul.txt, voir annexe. Il s'agit du seul cier à éditer! 2.2 Environnements matériel et logiciel à disposition Il faut commencer par télécarger et décompresser le cier Régulateur PID numérique, v MEE \pid_num.tex

3 pid_num.zip à partir du site ttp:// mee//laboratoires_regulation_aut.tm dans votre propre répertoire qui devrait être d:\users ou un de ses sousrépertoires que vous pouvez créer Edition du cier regul.c, programmation du régulateur La seule unique fonction que l'on demande de programmer devra se trouver dans le cier regul.c. Pour éditer le code, l'éditeur "PFE" est installé et son utilisation est recommandée. On peut l'appeler par son icône à partir du bureau. Le canevas de ce cier est fourni. Il montre que les signaux provenant de la carte d'acquisition sont disponibles dans les variables globales in0, in1, in2 et in3. f l o a t out0, out1 ; / s o r t i e s a n a l o g i q u e s / f l o a t in0, in1, in2, in3 ; / e n t r e e s a n a l o g i q u e s / / d e c a l a g e s a a p p l i q u e r sur l e s s o r t i e s a n a l o g i q u e s / f l o a t offset_out0, o ffset_out1 ; / d e c a l a g e s a a p p l i q u e r sur l e s e n t r e e s a n a l o g i q u e s / f l o a t o f f s e t _ i n 0, o f f s e t _ i n 1, o f f s e t _ i n 2, o f f s e t _ i n 3 ; Les paramètres du régulateur doivent quant à eux être déclarés comme variables globales, par exemple comme suit : / g a i n s du r e g u l a t e u r PID / f l o a t Kp = 0. 0 ; f l o a t Gi = 0. 0 ; f l o a t Td = 0. 0 ; f l o a t a = ; Le paramètre Gi est égal à 1 T i. Pourquoi le gain sur l'action intégrale est-il implanté de cette manière? De façon à ce que ces paramètres soient visibles et modiables en ligne à partir de RTPWatc, il faut les enregistrer dans le tableau var comme suit : D e c l a r a t i o n des v a r i a b l e s a c c e s s i b l e s d e p u i s l e PC v i a RTPWatc t_var var [ ] = {..., var_float Kp, var_float Gi, var_float Td,..., end_ var_ list } ; Si vous l'estimez nécessaire, vous pouvez bien sûr créer d'autres fonctions privées de regul.c, comme par exemple une fonction de limitation de la commande. A noter que les valeurs numériques initiales, "par défaut" des paramètres peuvent être spéciées dans regul.c : la fonction regulation_init est appelée au démarrage et les initialisations peuvent y être placées : Régulateur PID numérique, v MEE \pid_num.tex

4 I n i t i a l i s a t i o n du r e g u l a t e u r void r e g u l a t i o n _ i n i t void { / D e f i n i t i o n de l a f o n c t i o n e f f e c t u a n t l a r e g u l a t i o n de l a b o u c l e no1 / regulation_boucle_interne = regul_pid ; / Regulateur 1 / mode_boucle_interne = 1 ; / mode r e g u l a t i o n / / D e f i n i t i o n de l a f o n c t i o n e f f e c t u a n t l a r e g u l a t i o n de l a b o u c l e no2 / regulation_boucle_externe = regul_rien ; / Regulateur 2 / mode_boucle_externe = 0 ; / mode r e g u l a t i o n / / I n i t i a l i s a t i o n des parametres de l a r e g u l a t i o n / Kp = 0. 0 ; Gi = 0. 0 ; Td = 0. 0 ; a = ; AW = 0 ; offset_out0 = 0. 0 ; offset_out1 = 0. 0 ; o f f s e t _ i n 0 = 0. 0 ; o f f s e t _ i n 1 = 0. 0 ; o f f s e t _ i n 2 = 0. 0 ; o f f s e t _ i n 3 = 0. 0 ; } w = 0. 0 ; umax = ; Les valeurs pourront ensuite être modiées en ligne via l'interface RTPWatc Compilation du cier regul.c Vous pouvez compiler votre programme en lançant un compilateur C/C++ à partir de l'éditeur PFE, menu Execute DOS Command and Capture Output. La commande make ou make -B équivalente à l'opération build doit être tapée. Si aucune erreur n'est détectée, le cier objet regul.obj est généré. Dans la négative, la fenêtre PFE ouverte indique le message d'erreur. Régulateur PID numérique, v MEE \pid_num.tex

5 2.2.3 Essai du régulateur Lorsque le code temps réel a été compilé sans erreur, il faut lancer RTPWatc et utiliser l'outil Enregistreur. Sélectionner Autre code temps réel dans le menu et coisir votre DLL se trouvant dans votre répertoire de travail. Régulateur PID numérique, v MEE \pid_num.tex

6 3 Canevas du cier regul.c REGUL.C Version Date Auteur Motif 1 04/05/98 MEE Regulateur s c a l a i r e de courant Regulateur PID de p o s i t i o n 2 14/08/99 MEE Mise a j o u r 3 06/09/99 MEE Adaptation pour temps r e e l NT 4 07/02/01 MEE Labo PID numerique 5 11/03/02 MEE Labo PID numerique avec c a r t e NI #define REGUL_C #include " r e g u l. " / e n t ê t e de l ' u n i t é / Variables, c o n s t a n t e s e t f o n c t i o n s r e l a t i v e s a l a r e g u l a t i o n f l o a t out0, out1 ; / s o r t i e s a n a l o g i q u e s / f l o a t in0, in1, in2, in3 ; / e n t r e e s a n a l o g i q u e s / / d e c a l a g e s a a p p l i q u e r sur l e s s o r t i e s a n a l o g i q u e s / f l o a t offset_out0, o ffset_out1 ; / d e c a l a g e s a a p p l i q u e r sur l e s e n t r e e s a n a l o g i q u e s / f l o a t o f f s e t _ i n 0, o f f s e t _ i n 1, o f f s e t _ i n 2, o f f s e t _ i n 3 ; f l o a t w; / consigne / f l o a t w_0 = 0. 0 ; / d e c a l a g e consigne / / p e r i o d e d ' e c a n t i l l l o n n a g e / f l o a t Te = ; f l o a t Kp = 0. 0 ; / g a i n s du r e g u l a t e u r PID / f l o a t Gi = 0. 0 ; f l o a t Td = 0. 0 ; f l o a t a = ; D e c l a r a t i o n des v a r i a b l e s a c c e s s i b l e s d e p u i s l e PC v i a RTPWatc t_var var [ ] = { var_float w, var_float offset_out0, var_float o f f s e t _ i n 0, var_float o f f s e t _ i n 1, var_float w_0, var_float Te, var_int T_u, var_float A_u, end_ var_ list } ; Regulateur PID void regul_pid { / C a l c u l de l a consigne / w = generateur_u 2 + w_0; // Mesures y = in0 o f f s e t _ i n 0 ; / Algoritme / out0 =... ; Régulateur PID numérique, v MEE \pid_num.tex

7 } I n i t i a l i s a t i o n du r e g u l a t e u r void r e g u l a t i o n _ i n i t void { / D e f i n i t i o n de l a f o n c t i o n e f f e c t u a n t l a r e g u l a t i o n de l a b o u c l e no1 / regulation_boucle_interne = regul_pid ; / Regulateur 1 / mode_boucle_interne = 1 ; / mode r e g u l a t i o n / / D e f i n i t i o n de l a f o n c t i o n e f f e c t u a n t l a r e g u l a t i o n de l a b o u c l e no2 / regulation_boucle_externe = regul_rien ; / Regulateur 2 / mode_boucle_externe = 0 ; / mode r e g u l a t i o n / / I n i t i a l i s a t i o n des parametres de l a r e g u l a t i o n / Kp = 0. 0 ; Gi = 0. 0 ; Td = 0. 0 ; a = ; AW = 0 ; offset_out0 = 0. 0 ; offset_out1 = 0. 0 ; o f f s e t _ i n 0 = 0. 0 ; o f f s e t _ i n 1 = 0. 0 ; o f f s e t _ i n 2 = 0. 0 ; o f f s e t _ i n 3 = 0. 0 ; } w = 0. 0 ; umax = ; 4 Régulateur PID numérique 4.A Loi de commande La loi de commande du régulateur PID numérique peut être obtenue par discrétisation de celle d'un régulateur PID analogique u t = K p e t + 1 t e τ dτ + T d de T i dt où et est le signal d'erreur. Cette loi est discrétisée en l'évaluant à l'instant d'écantillonnage k noté k par la suite an alléger la notation, étant constante. Pour ce faire, on eectue les substitutions u t u [k] e t e [k] de dt 0 e [k] e [k 1] Régulateur PID numérique, v MEE \pid_num.tex

8 A D D B A F I HEIG-VD On voit que la dérivée de et est approximé par la pente de la droite liant l'écantillon présent e[k] au précédent e[k 1]. La résolution de l'intégrale passe par le calcul de l'aire comprise entre l'axe t et le signal et. Une approximation de cette aire peut être faite par la métode des rectangles : A E A H A? J = C A J A A A A D D D J L'intégrale de et à l'instant t = k est donc approximée par une somme de rectangles de largeur et de auteur On a : k 0 e[0] e[1] e[2]... e[k 1] k 1 e τ dτ e [l] La loi de commande discrète du régulateur PID numérique devient : u [k] = K p e [k] + 1 k 1 e [k] e [k 1] e [l] + T d T i 4.B Algoritme selon "textbook" La forme de la loi de commande obtenue ci-dessus se prête mal à la programmation, puisqu'elle nécessite la mémorisation de toutes les valeurs passées e[0], e[1], e[2],..., e[k 1] du signal d'erreur numérique e[k]. An de contourner cette Régulateur PID numérique, v MEE \pid_num.tex

9 diculté, écrivons les lois de commande aux instants présent k et et précédent [k 1] et soustrayons membre à membre : u [k = K p e [k] + 1 k 1 e [k] e [k 1] e [l] + T d T i u [k 1] = K p e [k 1] + 1 k 2 e [k 1] e [k 2] e [l] + T d T i On obtient tout d'abord u [k] u [k 1] = K p [e [k] e [k 1] + K k 1 p k 2 e [l] e [l] T i } {{ } puis e[k 1] e [k] e [k 1] + K p T d e [k 1] e [k 2] u [k] u [k 1] = K p 1 + T d e [k] + K p T d e [k 1] + K p T d e [k 2] T } {{ } i } {{ } } {{ } b 0 b b 2 1 et nalement : u [k] u [k 1] = b 0 e [k] + b 1 e [k 1] + b 2 e [k 2] La loi de commande du régulateur PID numérique s'écrit donc : avec : u [k] = u [k 1] + b 0 e [k] + b 1 e [k 1] + b 2 e [k 2] b 0 = K p 1 + T d b 1 = K p b 2 = K p Td 4.C Algoritme modié 1 + T i 2 T d Pour des raisons pratiques, liées notamment à des problèmes de limitation, on a souvent intérêt à calculer les contributions intégrale et dérivée séparément, i.e. à programmer : i_e [ k ] = i_e [ k 1] + e [ k 1] ; d_e [ k ] = e [ k ] e [ k 1] f e ; C'est cette forme que l'on propose d'implanter ici dans le code C. Régulateur PID numérique, v MEE \pid_num.tex

10 Version du document Date Notes v mars 2002 Traduction à partir de Word, adaptation à RTPWatc et à la carte National v mars 2003 v1.3 9 mars 2004 v1.4 3 janvier 2005 v mars 2005 v1.6 1 er octobre 2007 v1.7 Tab. 1 Versions publiées Régulateur PID numérique, v MEE \pid_num.tex