2,57 Mo

Réalisation d’un T.P.
de régulation thermique
(niveau BAC + 2)
en utilisant
l’environnement MATLAB
pour la partie commande
Patrick BRUNET
Emile FERRERE
LTEG Henri BRISSON
25 Avenue Henri BRISSON
18108 VIERZON
02 48 52 74 00
Sommaire
A. PRÉSENTATION DU SYSTÈME À RÉGULER ..................................3
A.1. SCHÉMA DE PRINCIPE ............................................................................3
A.2. DONNÉES POUR LA MODÉLISATION DU SYSTÈME ...................................4
B. MODÉLISATION DU PROBLÈME AVEC MATLAB ........................5
B.1. PRÉSENTATION DE MATLAB................................................................5
B.2. CONSTRUCTION DU MODÈLE AVEC MATLAB.......................................6
B.2.1. Modélisation de la cuve....................................................................6
B.2.2. Modélisation du gradateur de puissance ..........................................7
B.2.3. « vectorisation » du contrôleur.........................................................7
B.2.4. Prise en compte d’une perturbation..................................................7
B.3. CONSTRUCTION DU CORRECTEUR FLOU .................................................8
B.3.1. Introduction à la logique floue .........................................................8
B.3.2. Notion d’ensemble flou.....................................................................8
B.3.3. Structure d’un contrôleur flou ........................................................ 10
B.3.3.1. Opération de fuzzification ......................................................... 10
B.3.3.2. Base de règles « d’inférence » ................................................... 11
B.3.3.3. Mise en oeuvre de la base de règles ........................................... 11
B.3.3.4. Défuzzification .......................................................................... 12
B.3.3.5. Conclusion ................................................................................ 13
B.3.4. Utilisation de la boite à outils « Fuzzy logic » ................................ 14
B.3.4.1. Opérations de fuzzification........................................................ 14
B.3.4.2. Sauvegarde du contrôleur dans l’espace de travail matlab ......... 15
B.4. RÉSULTATS DE SIMULATION ................................................................ 16
B.4.1. Réponse à une consigne de température ......................................... 16
B.4.2. Réponse à une perturbation en régime établi.................................. 17
C. RÉGULATION TEMPS RÉEL DU SYSTÈME .................................. 18
C.1. PRÉ-REQUIS LOGICIELS ........................................................................ 18
C.2. CARACTÉRISTIQUES DE LA CARTE D’ENTRÉES / SORTIES ..................... 19
C.3. MODIFICATION DU MODÈLE................................................................. 20
C.3.1. Insertion et paramétrage du bloc Analog Input .............................. 21
C.3.2. Insertion et paramétrage du bloc Analog Output............................ 22
C.3.3. Paramétrage des propriétés des oscilloscopes................................ 23
C.4. GÉNÉRATION DU CODE ........................................................................ 24
C.5. EXÉCUTION DU CODE........................................................................... 28
Patrick BRUNET-Emile FERRERE
Année 2000-2001
1
Régulation thermique sous Matlab
C.6. RÉSULTATS TEMPS RÉEL ...................................................................... 32
C.6.1. Réponse à une consigne de température ......................................... 32
C.6.2. Réponse à une perturbation en régime établi.................................. 33
C.6.3. Réponse à une modification de la consigne en cours de régulation 34
D. CONCLUSION....................................................................................... 35
Patrick BRUNET-Emile FERRERE
Année 2000-2001
2
Régulation thermique sous Matlab
A.
Présentation du système à réguler
A.1. Schéma de principe
Cuve dont la
température est à
réguler
sonde PT 100
220V/50Hz
Thermoplongeur
Bloc de puissance
« gradipack »
Le schéma de principe ci-dessus représente le synoptique de la régulation de température à réaliser
Fonctions gérées
par l’ordinateur
*
E*
+
uc
Régulateur
θ consigne
C.N.A.
Bloc de
puissance :
GRADIPACK
système :
cuve
θ
*
échantillonnage
Capteur :
sonde PT 100
et dont le schéma fonctionnel est précisé ci-dessous :
Il s’agit de réguler la température de l’eau d’une cuve (seau d’une contenance de quelques litres)
équipée d’un thermoplongeur apportant l’énergie calorifique. Une sonde de température (PT100)
permet de mesurer la température réelle de l’eau. Il est bon de prévoir un brassage de l’eau dans la cuve
afin d’homogénéiser sa température.
La puissance nominale du thermoplongeur (1 kW) est modulée grâce à un bloc de puissance
« GRADIPACK » (dénomination commerciale). Il s’agit d’un ensemble de 2 thyristors montés têtebêche (gradateur) permettant de faire varier la puissance électrique dissipée par variation de l’angle de
retard à l’amorçage des thyristors. Celle-ci est contrôlée par une tension de commande 0 -10V
continue (Ucom ) qui permet de faire varier la tension efficace (Ueff ) appliquée au thermoplongeur.
Le rôle du micro-ordinateur sera de faire la mesure de la température de la cuve à partir du signal
délivré par la sonde PT100 et sa mise à l’échelle, de comparer cette valeur avec la température de
consigne, de traiter l’écart entre ces 2 valeurs et de fournir une tension de commande utile pour le
« GRADIPACK ». Tout cela nécessite la mise en oeuvre d’une carte d’entrées-sorties analogiques.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
3
Régulation thermique sous Matlab
A.2. Données pour la modélisation du système
Cuve à chauffer :
On supposera que la capacité calorifique de la cuve à chauffer se réduit à l’eau qu’elle contient. En
prenant un volume de 3 litres, on obtient :
C = m.c = 3 * 4.18 E 3 ≈ 1.25 E 4 JK −1
Contrôle du thermoplongeur :
Ueff
230 V
Ucom
0.5 V
8.5 V
La figure ci-dessus donne la modélisation du fonctionnement du « GRADIPACK ». La tension
efficace appliquée au thermoplongeur passe de 0 à 230V si la tension de commande évolue de 0.5V à
8.5V. On pourra donc écrire :
230
U eff =
.(U com − 0.5)
8
La puissance de chauffe sera donnée par : P = PN .
(U )
eff
(U N )2
2
, soit en tenant compte de l’expression
précédente :
P=
PN
8
2
(U com − 0.5)2
2
= 15.6(U com − 0.5) (en Watts).
Evaluation des pertes thermiques :
Les pertes thermiques peuvent se mettre sous la forme Pth = K .(θ − θ ext ) (Loi de FOURIER).
L’expérience montre qu’elles sont faibles. On les estimera à 50 W pour un ∆θ = 25°C. D’où
K = 2WK
−1
Bilan de puissance sur la cuve :
La puissance fournie par le thermoplongeur : PT, sert à élever la température de l’eau et participe
aux pertes soit :
d (θ − θ ini )
PT = C.
+ K .(θ − θ ext )
dt
avec θ : température de l’eau
θ ini : température initiale de l’eau
θ ext : température extérieure à la cuve
Patrick BRUNET-Emile FERRERE
Année 2000-2001
4
Régulation thermique sous Matlab
B.
Modélisation du problème avec MATLAB
B.1.
Présentation de MATLAB
MATLAB est le « noyau dur » d’un logiciel de mathématiques spécialement étudié pour traiter
des matrices. Un langage de programmation spécifique permet de faire des manipulations sur des matrices
et toutes sortes de calculs et de présentation graphique de ces calculs.
Différentes « boites à outils » peuvent y être adjointes pour simuler le comportement de systèmes
linéaires ou non. Dans ce cas, il n’est pas nécessaire d’utiliser le langage de programmation car une
interface graphique permet d’avoir accès de façon intuitive à des schémas réalisant une fonction
particulière.
Plusieurs d’entre elles sont dédiées à l’étude de l’automatique. La plus importante est
SIMULINK. Ce module permet de construire des schémas fonctionnels à partir d’éléments contenus dans
des bibliothèques qu’il suffit de « draguer » avec la souris pour les déposer sur la « feuille » de travail et
construire son système :
la bibliothèque « source » fournit des échelons, des GBF, etc …
les bibliothèques « continu » et « discret » proposent des dérivateurs, des intégrateurs, des
fonctions de transfert pour construire des systèmes à temps continu ou échantillonné (discret),
la bibliothèque « math » fournit des gains, des multiplicateurs, des sommateurs,
on trouve également des multiplexeurs pour « vectoriser » des signaux ainsi que des
oscilloscopes pour visualiser les résultats de modélisation.
Le module CONTROL SYSTEM TOOLBOX fournit des outils d’analyse des sytèmes (Bode, etc …)
Le module FUZZY LOGIC TOOLBOX permet de générer des blocs utilisant la logique floue.
On développera particulièrement dans la suite de cet article la méthode permettant
d’élaborer un « correcteur flou » après avoir donné les éléments nécessaires à la compréhension.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
5
Régulation thermique sous Matlab
B.2.
Construction du modèle avec MATLAB
Le schéma fonctionnel ci dessous présente la modélisation du système à étudier à partir des
éléments de base décrits plus haut. On peut y reconnaître :
des échelons,
des sommateurs,
un produit,
des oscilloscopes,
un intégrateur,
des multiplexeurs,…
B.2.1. Modélisation de la cuve
En reprenant le bilan de puissance sur la cuve, il vient en utilisant la notation de Laplace :
PT = C. p(θ − θ ini )+ K (θ − θ ext )
PT − K (θ − θ ext ) = C. p(θ − θ ini )
1
(θ − θ ini )= [PT − K (θ − θ ext )] 1
θ = θ ini +
[PT − K (θ − θ ext )]
C. p
C. p
Ce qui se traduit par le schéma simulink ci dessous :
Patrick BRUNET-Emile FERRERE
Année 2000-2001
6
Régulation thermique sous Matlab
B.2.2. Modélisation du gradateur de puissance
Rappelons la relation donnant la puissance de chauffe en fonction de la tension de commande
P
2
2
P = N2 (U com − 0.5) = 15.6(U com − 0.5)
8
La saturation permet de limiter la tension de commande à la plage 0.5V-8.5V et le bloc produit
permet de faire l’élévation au carré.
B.2.3. « vectorisation » du contrôleur
1
» est un opérateur échantillonné, sa sortie est mise à jour toutes les 5
z
secondes. Il permet de mémoriser la valeur de l’erreur à l’instant « t-1 ». Ainsi, le circuit de différence
permet d’obtenir la variation de l’erreur entre 2 instants d’échantillonnage. Le contrôleur sera donc
sensible à l’erreur de température et à sa variation.
L’opérateur retard «
B.2.4. Prise en compte d’une perturbation
La perturbation pourra être simulée par un créneau de puissance négatif limité dans le temps (et
décalé par rapport au début de la simulation) traduisant un apport d’eau froide par exemple.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
7
Régulation thermique sous Matlab
B.3.
Construction du correcteur flou
B.3.1. Introduction à la logique floue
Si les processus commandés sont linéaires, (c’est-à-dire lorsque les grandeurs de sortie sont reliées
aux grandeurs d’entrée par des équations différentielles linéaires) ils peuvent être alors modélisés par un
modèle mathématique (fonction de transfert en « p » pour les systèmes à temps continu ou en « z » pour
les systèmes à temps échantillonnés). Le concepteur devra alors calculer les valeurs des paramètres de
réglage du régulateur (gain, durées d’intégration et de dérivation) pour satisfaire aux exigences d’un
cahier des charges (temps de montée, dépassement). Le système régulé sera correct s’il est peu sensible
aux perturbations (on dira alors qu’il est robuste).
Certains processus sont par nature difficilement modélisables (thermique, chimique), variables
dans le temps ou encore ne peuvent être correctement représentés par un modèle linéaire. Dans ce cas, les
paramètres de réglage du régulateur ne seront pas optimaux et le système pourra ne pas être correctement
contrôlé.
Dans une approche « logique floue », on ne se préoccupe pas d’une modélisation mathématique
du processus mais, par contre, on suppose le processus non régulé bien connu par un opérateur humain,
l’objectif est toutefois de l’automatiser. On parle alors de connaissance par un « expert » qui sait ce qu’il
faut faire pour que ça marche dans tous les cas de figure. Par exemple : si la température est très basse,
je chauffe "plein pot" jusqu’à telle valeur, ensuite je réduis de 50 % si le four est plein ou de 75% si le
four est moitié plein car j’ai remarqué que c’est un bon choix : c’est « l’expertise ».
On se propose dans la suite de détailler les étapes permettant, à partir des données fournies par
un ou plusieurs capteurs, d’élaborer un signal de commande compréhensible par une interface de
puissance (0-10V par exemple).
B.3.2. Notion d’ensemble flou
Un problème de vocabulaire se pose pour le mot flou (fuzzy en anglais qui signifie vague, confus).
Cela ne doit pas être interprété comme on va le voir par un « p’tet ben qu’oui, p’tet ben qu’non » ! En
aucun cas il ne s’agit d’un manque d’information pour une décision à prendre, mais d’une représentation
qui prend en compte l’incertitude que l’on a du modèle.
La notion d’ensemble flou a été introduite par L.A. ZADEH en 1965. Une théorie des ensembles
flous permet de définir toutes les opérations classiques (conjonction, disjonction, etc.). Elle englobe la
théorie des ensembles classiques.
La figure ci-dessous représente la plage de variation d’un capteur (de température par exemple).
Le signal de sortie peut varier de 0 à 10V, mais on constate qu’à partir de 9 V se produit une saturation.
On va décider de partitionner la plage de variation utile (0-9V) en 3 zones qui seront dénommées : petite
(0-3V), moyenne (3V à 6V), et grande (6V à 9V).
µ : degré d’appartenance
petite
moyenne
grande
1
tension issue du capteur
0
3V
6V
9V
Patrick BRUNET-Emile FERRERE
Année 2000-2001
8
Régulation thermique sous Matlab
Si la tension est de 2V, elle est alors dans la classe « petite » et bien sûr ni « moyenne » ni
« grande ». Le degré d’appartenance de la valeur 2V à la classe « petite » est de 1 et 0 pour les 2 autres.
On retrouve là une logique binaire où l’état d’un comparateur ne peut être que « 0 » ou « 1 ».
l’inconvénient de cette représentation est que la valeur 2.95V appartient à la classe « petite » alors que la
valeur 3.05V appartient à la classe « moyenne » et pourtant les valeurs sont proches. Ceci est dû à la
définition des 3 sous-ensembles classiques « petite », « moyenne » e t « grande » qui ont une
« frontière » nette d’où cette discontinuité. Si le résultat de la mesure est légèrement bruité (cas très
fréquent évidemment), on pourra basculer d’un coté à l’autre de la « frontière ».
La notion de sous-ensemble flou permet d’éviter cette discontinuité brutale. Cette opération
s’appelle « la fuzzification ». La sortie du capteur est appelée variable « linguistique » puisqu’elle
pourra prendre les valeurs linguistiques « petite », « moyenne » ou « grande », mais on va modifier
comme indiqué ci-dessous les « frontières » entre ces valeurs linguistiques, c’est-à-dire les formes des
fonctions d’appartenance.
µ : degré d’appartenance
petite
moyenne
grande
1
0.8
0.2
tension issue du capteur
0
1.5V
3V
4.5V
7.5V
6V
9V
Représentation des degrés d’appartenance avec 3 ensembles flous
Dans cette représentation la valeur de tension 2V sera à la fois « petite » et « moyenne »; de plus,
on va préciser de combien. On définit alors un degré d’appartenance µ à chacune de ces classes :
µpetite = 0.8 et µmoyenne = 0.2
On peut dire que l’ordre de grandeur de la tension issue du capteur est pris en compte par les
valeurs linguistiques, puis la valeur précise est contenue dans les degrés d’appartenance (on parle aussi de
mesure d’appartenance ou de degré de certitude).
Remarques :
Les profils des frontières peuvent être variés : triangle, trapèze, sigmoïde, courbe de Gauss, etc.
Il n’y a rien de flou dans cette représentation, une même mesure peut appartenir à plusieurs
classes avec un degré d’appartenance précis dans chaque classe.
La valeur de la tension issue du capteur est ici considérée comme précise comme en
automatique classique (on l’appelle singleton).
C’est le rôle de l’expert que de définir les valeurs linguistiques de la variable.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
9
Régulation thermique sous Matlab
B.3.3. Structure d’un contrôleur flou
B.3.3.1. Opération de fuzzification
La grandeur d’entrée du contrôleur doit d’abord être fuzzifiée, c’est-à-dire que l’on va fixer les
valeurs linguistiques ainsi que la forme des fonctions d’appartenance. Cette opération doit être faite
également sur la variable de sortie. Bien sûr cette sortie fuzzifiée n’est pas exploitable pour attaquer
l’interface de puissance. Il faudra donc avoir en tête de faire une opération de « défuzzification » pour
résoudre ce problème.
On va prendre un exemple où l’on va fuzzifier l’erreur (notée e), entrée du régulateur, mais aussi
la variation de l’erreur (notée ∆e) et la sortie (notée s). Les valeurs de e de ∆e sont mises à jour à chaque
période d’échantillonnage. On passe pour cela par un convertisseur analogique numérique.
erreur : e
µ : degré d’appartenance
grande -
moyenne -
petite
moyenne +
grande +
1
0.8
variable : e
0.2
-9
-7.5
-4.5
-1.5
0
1.5
4.5
7.5
9
2V
variation de
l’erreur : ∆ e
µ : degré d’appartenance
grande -
moyenne -
petite
moyenne +
grande +
1
0.6
variable : ∆ e
0.4
-9
-7.5
-4.5
-1.5
0
1.5
4.5
7.5
9
2.2V
µ : degré d’appartenance
sortie : s
petite
moyenne
grande
1
varaible : s
0
1.5V
3V
4.5V
6V
7.5V
9V
Fuzzification des 2 variables d’entrée et de la variable de sortie
L’entrée e a été partitionnée en 5 valeurs linguistiques ainsi que ∆e. Elles peuvent être positives
ou négatives.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
10
Régulation thermique sous Matlab
La sortie s a été partitionnée en 3 valeurs linguistiques ; elle pourra n’être que positive (cas de la
figure) dans le cas où la partie puissance est commandée par une tension (0, 10V) par exemple.
On a gradué les axes donnant la variation des variables en Volt pour faciliter la compréhension,
mais en pratique les tests seront faits sur les valeurs échantillonnées des entrées (on passe par un C.A.N.)
B.3.3.2. Base de règles « d’inférence »
Le rôle de l’expert est ici présent car c’est lui qui va fixer les règles de la commande qui vont
porter uniquement sur les valeurs linguistiques des variables.
Soit par exemple la liste de règles suivantes (qui résultent de la connaissance de l’expert) :
-R1 : SI (e) est petite ET (∆e) est petite ALORS (s) est petite
-R2 : SI (e) est petite ET (∆e) est moyenne + ALORS (s) est petite
-R3 : SI (e) est moyenne + ET (∆e) est petite ALORS (s) est petite
-R4 : SI (e) est moyenne + ET (∆e) est moyenne + ALORS (s) est moyenne
-R5 : SI (e) est grande + ET (∆e) est moyenne + ALORS (s) est moyenne
- ....
Le tableau ci-dessous représente la base de règles en donnant les valeurs de la sortie pour les
différentes valeurs linguistiques de e et ∆e :
∆e
e
grande moyenne petite
moyenne +
grande +
grande -
moyenne -
...
...
...
...
...
...
petite
...
...
(R1) s : petite
(R2) s : petite
...
moyenne +
grande +
...
...
...
...
(R3) s : petite
...
(R4) s:moyenne (R5) s:moyenne
Remarques :
« SI (e) est petite » : constitue une prémisse de la règle
« ET »: est appelé opérateur de conjonction
« ALORS (s) est petite » : est appelé implication (conclusion) de la règle
La liste des règles est appelée base d’inférence (inférence : opération logique par laquelle on
admet une proposition en vertu de sa liaison avec d’autres propositions tenues pour vraies :
Nouveau Petit Robert). On parle aussi de moteur d’inférence. Il n’est pas nécessaire que toutes
les cases du tableau soient remplies.
On peut trouver les règles énoncées critiquables, elles ne sont données qu’à titre d’exemples et
doivent être adaptées en fonction de chaque processus.
B.3.3.3. Mise en oeuvre de la base de règles
Supposons qu’à un instant t on ait :
e = 2 V et ∆e = 2.2 V
Ces valeurs vont constituer des faits et à ce titre activer la base de règles. Il est facile de voir à
partir de la figure donnant la fuzzification de e et ∆e que les règles R 1, R2 , R3 , R4 vont être actives
puisque e et ∆e sont à la fois petite et moyenne + (partie la plus grisée du tableau). Il s’agit ici des
valeurs linguistiques des variables.
Mais l’examen des figures montre aussi que l’on peut en déduire les degrés d’appartenance à
chacune de ces classes.
Pour e on a µpetite = 0.8 et µmoyenne + = 0.2
Pour ∆e on a µpetite = 0.6 et µmoyenne + = 0.4
Patrick BRUNET-Emile FERRERE
Année 2000-2001
11
Régulation thermique sous Matlab
On va donc étudier maintenant le rôle de chaque règle activée et voir concrètement comment on
traduit les opérations de conjonction (ET) et d’implication (ALORS).
Pour traduire le ET (c’est-à-dire la conjonction des prémisses), on peut utiliser la fonction MIN :
on prendra la valeur minimale des 2 degrés d’appartenance des prémisses. La signification
physique de ce choix est de conserver l’information la plus sûre.
Le résultat est un nouveau degré d’appartenance au sous ensemble flou de la sortie.
Ainsi pour R1, on a :
le MIN de 0.8 et 0.6 est 0.6, donc pour (s) : µpetite = 0.6
On fait ensuite la même chose pour toutes les règles activées et on obtient les résultats suivants
pour la variable linguistique de sortie (s) :
Pour R1 : µpetite = 0.6
Pour R2 : µpetite = 0.4
Pour R3 : µpetite = 0.2
Pour R 4 : µ moyenne =
0.2
L’opération n’est pas terminée car les 4 règles étant activées en même temps, il faut faire ce que
l’on appelle l’agrégation des règles (l’assemblage)
Les règles R1, R2 et R3 concernent la même valeur linguistique « petite » de la variable de sortie
alors que R 4 porte sur la valeur « moyenne ». On utilise ici l’opérateur MAX, c’est-à-dire que pour
chaque valeur linguistique de sortie concernée on va prendre la valeur maximum des degrés
d’appartenance.
Le résultat de l’agrégation des règles donne donc la variable s « petite » avec un degré
d’appartenance de 0.6 en même temps que « moyenne » avec un degré d’appartenance de 0.2.
A ce stade, on a donc la sortie définie sous forme linguistique avec des degrés d’appartenance
précis. Il faut maintenant passer à une grandeur qui, elle, sera interprétable par l’interface de commande.
B.3.3.4. Défuzzification
µ : degré d’appartenance
sortie : s
petite
moyenne
grande
1
valeur de la
commande
0.6
0.2
variable : s
0
1.5V
4.5V
3V
6V
7.5V
9V
La figure ci-dessus indique comment on interprète l’agrégation des règles. Le sous ensemble
« petite » est limité par le degré d’appartenance à 0.6 et le sous ensemble « moyenne » par 0.2 (on prend
le MIN entre la fonction d’appartenance de la valeur linguistique de la sortie concernée et le µ trouvé par
l’agrégation des règles). On obtient ainsi toute la surface grisée. Pour obtenir le signal de commande à
envoyer à l’interface, on utilise le plus souvent la règle « du centre de masse » c’est-à-dire que l’on
calcule le barycentre de la surface pour obtenir la valeur de la commande.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
12
Régulation thermique sous Matlab
B.3.3.5. Conclusion
CAN
ajustement des échelles
consigne
Base de règles en ROM
+
e
CAN
Fuzzification
CAN
retour
-
sortie
d/dt
Moteur
d’inférence
en RAM
∆e
Défuzzification
Fuzzification
Les grandeurs réelles consigne et retour sont numérisées avec ces convertisseurs AN puis
l’erreur (éventuellement la variation de l’erreur) est fuzzifiée. La base de règles qui sera stockée en
ROM sera activée et le moteur d’inférence permettra d’élaborer une sortie qui sera ensuite défuzzifiée et
convertie en signal analogique.
On peut constater que dans son principe même le contrôleur à logique floue n’est pas
linéaire.
En effet l’activation des règles d’inférence n’est pas un processus linéaire pas plus que la
traduction mathématique que l’on en donne (algorithme MAX MIN).
On a utilisé ici l’algorithme MIN MAX (MIN pour la conjonction des prémisses et l’implication
des règles, MAX pour l’agrégation des règles). Mais, il existe d’autres possibilités : on peut par exemple
utiliser l’algorithme PROD MAX (PROD pour la conjonction des prémisses et l’implication des règles,
MAX pour l’agrégation des règles) c’est-à-dire que l’on fait le produit des degrés d’appartenance obtenu
avec chaque règle pour définir le degré d’appartenance pour la sortie.
Il existe un autre type de contrôleur flou dit de type SUGENO. Les prémisses des règles sont aussi
linguistiques mais les conclusions sont élaborées directement sous une forme polynomiale avec des
coefficients définis à l’avance. L’avantage de ce type de régulateur est qu’il est possible d’introduire des
algorithmes d’apprentissage pour adapter les coefficients. C’est ainsi qu’il existe des contrôleurs flous
adaptatifs. La technologie des réseaux de neurones peut être utilisée pour l’apprentissage.
Bibliographie :
Université d’été du 8 au 12 Juillet 1996 organisée par l’IUP du littoral à Calais
(Université du littoral)
La logique floue de Jean-Raphael Tong Tong (Editions HERMES)
La logique floue de B Bouchon-Meunier (Que sais-je)
Le contrôle flou de Bühler (éditions E.P.R.)
Fuzzylogic toolbox (documentation du logiciel MATLAB)
Patrick BRUNET-Emile FERRERE
Année 2000-2001
13
Régulation thermique sous Matlab
B.3.4. Utilisation de la boite à outils « Fuzzy logic »
On commence par taper fuzzy à l’invite de la fenêtre de commande de MATLAB : >> ce qui
lance l’éditeur de contrôleur flou : Fis Editor
B.3.4.1. Opérations de fuzzification
étape 1
La commande Edit permettra de choisir le nombre d’entrées-sorties (2 entrées et 1 sortie dans
notre application). On pourra renommer à loisir ces différentes variables.
étape 2
Double-cliquer sur chaque variable d’entrée ou de sortie pour définir les valeurs linguistiques et la
forme des fonctions d’appartenance. Pour cela utiliser dans le nouveau menu Edit la commande
Add MFs, ce qui signifie ajouter des fonctions d’appartenance. On pourra choisir des fonctions
triangulaires [trimf], trapézoïdales [trapmf], etc…
Patrick BRUNET-Emile FERRERE
Année 2000-2001
14
Régulation thermique sous Matlab
étape 3
Double-cliquer sur le bloc central (mandani) pour entrer les règles d’inférences choisies.
étape 4
Pour visualiser le comportement du contrôleur ainsi créé, on pourra utiliser dans le menu View, la
commande View rules. Il est alors possible de fixer les valeurs des variables d’entrées, de voir quelles
sont les règles d’inférences activées et de lire la valeur de la tension de commande correspondante.
B.3.4.2. Sauvegarde du contrôleur dans l’espace de travail matlab
Pour que le contrôleur ainsi créé soit disponible dans un modèle simulink, il faut qu’il soit
sauvegardé dans l’espace de travail. Pour cela dans le menu File, utiliser l’option Save to workspace.
Ainsi, son contenu sera mis dans un fichier de type « *.fis » (chauff3.fis dans l’exemple ci-dessus) auquel
il sera fait appel dans simulink.
Pour incorporer le correcteur flou dans son propre modèle simulink, le plus simple est d’en copier
un à partir d’une démo de MATLAB. Ensuite, on double-cliquera sur le modèle en entrant dans la fenêtre
le nom du fichier (chauff3 comme indiqué précédemment)
Le modèle définitif est (enfin !) prêt à fonctionner.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
15
Régulation thermique sous Matlab
B.4.
Résultats de simulation
B.4.1. Réponse à une consigne de température
La consigne de température est réglée à 30°C alors que la température initiale est de 15°C. Les
oscillogrammes ci-dessous donnent les évolutions de la température, de la tension de commande du
gradipack, de l’erreur et de la variation de l’erreur.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
16
Régulation thermique sous Matlab
B.4.2. Réponse à une perturbation en régime établi
La consigne de température reste réglée à 30°C. Les oscillogrammes ci-dessous donnent les
évolutions de la température, de la tension de commande du gradipack, de l’erreur et de la variation de
l’erreur lorsque l’on perturbe le système à t = 500s.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
17
Régulation thermique sous Matlab
C.
Régulation temps réel du système
C.1.
Pré-requis logiciels
Pour mener à bien la régulation de température en temps réel sous MATLAB, les boîtes à outils et
le compilateur suivants doivent être installés sur le micro-ordinateur :
Matlab 6 (release 12)
Simulink 4.0 (release 12)
Real-Time Workshop 4.0
Real-Time Windows Target 2.0
Compilateur Watcom 11.0
De plus, différents fichiers sont nécessaires à la création du modèle et sont téléchargeables sur le
site http://www.iufmrese.cict.fr/ dans l’archive regul.zip :
Liste des fichiers inclus dans l’archive :
doslib.mdl
fstlabad.c, fstlabad.h, fstlabad.tlc (sources du driver de la carte)
fstlabda.c, fstlabda.h, fstlabda.tlc (sources du driver de la carte)
drt_comp.h
win_watc.tmf
chauff3.fis (source du contrôleur flou)
regul_rt.mdl (modèle simulink temps réel du système)
Avant de modifier le modèle précédemment décrit, plusieurs manipulations doivent être
effectuées, une fois tous les fichiers téléchargés :
Extraire tous les fichiers de l’archive dans un répertoire temporaire
Sauvegarder le fichier doslib.mdl original du répertoire \matlabR12\toolbox\rtw\rtw sous un autre
nom ce qui permettra d’en garder une image en cas de fausse manœuvre.
Copier le fichier doslib.mdl téléchargé dans le répertoire \matlabR12\toolbox\rtw\rtw
Sauvegarder le fichier win_watc.tmf original du répertoire :
matlabR12\toolbox\rtw\targets\rtwin\rtwin sous un autre nom
Copier le fichier win_watc.tmf téléchargé dans le répertoire :
\matlabR12\toolbox\rtw\targets\rtwin\rtwin
Remplacer le fichier drt_comp.h du répertoire \matlabR12\rtw\c\dos\devices par le fichier
téléchargé de même nom
Créer un répertoire nommé fastlab dans le répertoire \matlabR12\rtw\c\dos\devices
Copier tous les sources du driver dans le répertoire fastlab
Copier le fichier fis.c qui se trouve dans le répertoire \matlabR12\toolbox\fuzzy\fuzzy dans le
répertoire \matlabR12\toolbox\fuzzy\fuzzy\src
Copier les fichiers regul_rt.mdl et chauff3.fis dans le répertoire de travail de Matlab
\matlabr12\work
Patrick BRUNET-Emile FERRERE
Année 2000-2001
18
Régulation thermique sous Matlab
C.2.
Caractéristiques de la carte d’entrées / sorties
Pour élaborer la tension de commande du gradateur de puissance et pour récupérer la température
mesurée par la sonde PT100, il nous a fallu installer une carte d’entrées / sorties analogiques dans le
micro-ordinateur. La carte retenue pour le système est une FASTLAB sur bus ISA du fabricant Eurosmart.
Cette carte possède de nombreuses fonctionnalités fort intéressantes, mais dans ce document nous
ne verrons plus précisément que les caractéristiques techniques concernant les conversions
analogique / numérique et numérique / analogique.
Interface Analogique / Numérique :
Voies d’entrée
Résolution
Echelle d’entrée bipolaire
8 simples ou 4 différentielles
12 bits (4096 pts)
± 10 V max. – gain 1
programmable
Temps de conversion
Codage numérique
16 gains programmables
1,25 µs (800 kHz)
Binaire naturel
1, 2, 4, 8, 10, 20, 40, 80, 100, 200, 400, 800, 1000,
2000, 4000, 8000 V/V
Interface Numérique / Analogique :
Voies de sortie bipolaire
2 indépendantes
Résolution
12 bits (4096 pts)
Echelle de sortie bipolaire
± 10 V
Temps de conversion
5 µs max
Codage numérique
Binaire naturel
Patrick BRUNET-Emile FERRERE
Année 2000-2001
19
Régulation thermique sous Matlab
C.3.
Modification du modèle
Pour la régulation temps réel du système, il faut modifier le modèle simulink décrit précédemment
au paragraphe B.2 :
en supprimant toute la partie modélisation du gradateur de puissance, de la cuve et de la
perturbation
en rajoutant 2 blocs Sfunction permettant de piloter la carte FASTLAB, le gain du transmetteur
de la sonde PT100 (G=38.485)
Patrick BRUNET-Emile FERRERE
Année 2000-2001
20
Régulation thermique sous Matlab
Les deux blocs Sfunction (Analog Input, Analog Output) correspondent au driver « Matlab » de la
carte FASTLAB, permettant de générer la tension de commande du Gradipack et de récupérer la tension
délivrée par le transmetteur (image de la température de l’eau du bac).
Ce driver a été réalisé en se basant sur l’exemple du driver de la carte Keithley fourni avec les
boîtes à outils de MATLAB (cf. § Creating Device Drivers doc. Real-Time Workshop). Le driver n’est
pas complet, étant données toutes les fonctionnalités de la carte (E/S logiques, Timer), mais la partie qui
concerne notre système fonctionne.
Remarque : Le driver fonctionne sous Dos, Windows 9x, mais pas sous WinNT.
C.3.1. Insertion et paramétrage du bloc Analog Input
Dans le navigateur de simulink,
Développer l’arborescence Real-Time Workshop
Développer la sous-arborescence Eurosmart FASTLAB
Sélectionner le bloc Sfuntion Analog Input
Faire glisser le bloc sélectionné dans le modèle simulink regul_rt.mdl
Double-Cliquer sur le bloc Analog Input du modèle regul_rt.mdl
Patrick BRUNET-Emile FERRERE
Année 2000-2001
21
Régulation thermique sous Matlab
Configurer le driver en se référant à l’image suivante :
Adresse de base
de la carte E/S
Etendue de la plage
d’entrée en Volts
Gain en entrée
(1.0 - 8000.0)
Numéro de la voie
d’entrée (0 - 7)
Période
d’échantillonnage
Accès à la carte
d’entrées / sorties
Valider par la touche OK
C.3.2. Insertion et paramétrage du bloc Analog Output
Procéder de même pour l’insertion du bloc Sfunction Analog Output
Double-Cliquer sur le bloc Analog Output du modèle regul_rt.mdl
Configurer le driver en se référant à l’image suivante
Adresse de bas
de la carte E/S
Etendue de la plage
de sortie en Volts
Valeur de sorti
avant simulatio
en Volts
Valeur de sortie
après simulation
en Volts
Numéro de la vo
(channel 1 / chann
Période
d’échantillonna
Accès à la carte
d’entrées / sorties
Valider par la touche OK
Patrick BRUNET-Emile FERRERE
Année 2000-2001
22
Régulation thermique sous Matlab
C.3.3. Paramétrage des propriétés des oscilloscopes
Double-Cliquer un des blocs scope du modèle regul_rt.mdl
Cliquer sur le bouton Properties de la fenêtre scope
Cliquer sur l’onglet General et configuer les paramètres du bloc scope suivant l’image ci-dessous
Ne pas cocher
la case
Nombre de
graphes tracés
Echelle des temps
1000 s
Affichage en
continu
Cliquer sur le bouton OK pour confirmer
Recommencer les opérations précédentes pour chaque bloc scope
Patrick BRUNET-Emile FERRERE
Année 2000-2001
23
Régulation thermique sous Matlab
C.4.
Génération du code
Pour générer le programme exécutable relatif au modèle simulink regul_rt.mdl comportant le
contrôleur flou, il est nécessaire de :
Définir le compilateur par défaut utilisé par Matlab (Watcom 11.0)
Entrer sur la ligne de commande Matlab : mex –setup ↵
Appuyer sur les touches <y> et <Entrée> afin que Matlab localise les différents compilateurs
installés sur le poste
Saisir le numéro correspondant au compilateur Watcom 11.0 et valider par la touche <Entrée>
Confirmer le choix du compilateur par les touches <y> et <Entrée>
Ajouter le chemin d’accès aux fichiers du driver de la carte Fastlab à la liste des
chemins d’accès de Matlab
Sélectionner Set Path… du menu File de la fenêtre Matlab
Cliquer sur le bouton Add Folder…
Patrick BRUNET-Emile FERRERE
Année 2000-2001
24
Régulation thermique sous Matlab
Déployer l’arborescence c:\matlabr12\rtw\c\dos\devices
Sélectionner le répertoire Fastlab
Valider par le bouton OK
Sauvegarder la liste en appuyant sur le bouton Save de la boîte de dialogue Set Path
Fermer la boîte de dialogue en appuyant sur le bouton Close
Compiler les fichiers du driver de la carte Fastlab
Se positionner dans le répertoire où se trouvent les fichiers du driver de la carte Fastlab, en
tapant la commande cd c:\matlabr12\rtw\c\dos\devices\fastlab ↵ dans la fenêtre Matlab ou en
cliquant sur l’icône Browse for Folder dans la barre d’outils
Patrick BRUNET-Emile FERRERE
Année 2000-2001
25
Régulation thermique sous Matlab
Compiler le fichier fstlabad.c en saisissant sur la ligne de commande Matlab : mex fstlabad.c ↵
⇒ génération du fichier fstlabad.dll
Compiler le fichier fstlabda.c en saisissant sur la ligne de commande Matlab : mex fstlabda.c ↵
⇒ génération du fichier fstlabda.dll
Charger le contrôleur flou dans l’espace de travail de Matlab
Se positionner dans le répertoire où se trouvent les fichiers modèles regul_rt.mdl et chauff3.fis,
en tapant la commande cd c:\matlabr12\work ↵ ou en utilisant le
Entrer sur la ligne de commande Matlab : fuzzy chauff3 ↵
Appuyer sur le bouton Close
Appuyer sur le bouton Save to workspace
Valider par le bouton OK
Configurer la page du module Real-Time Workshop
Revenir à la fenêtre simulink du modèle, cliquer sur la rubrique Simulation parameters du
menu Simulation
Cliquer sur l’onglet Real-Time Workshop
Cliquer sur le bouton Browse
Dans le navigateur des fichiers systèmes cible, sélectionner le fichier rtwin.tlc pour la
génération de code dans le mode temps réel sous Windows
Patrick BRUNET-Emile FERRERE
Année 2000-2001
26
Régulation thermique sous Matlab
Cliquer sur le bouton OK
Faire dérouler la liste Category et sélectionner la rubrique Real-Time Windows Target build
options
Cocher les options External mode et Compiler optimizations
Cliquer sur le bouton Apply
Configurer la page « solver » du module simulink
Cliquer sur l’onglet Solver afin de définir les paramètres de simulation
Durée de simulation
de 1000 s
Echantillonnage
à pas fixe
Système
à temps discret
période
d’échantillonnage
de 5 s
Valider par le bouton OK
Patrick BRUNET-Emile FERRERE
Année 2000-2001
27
Régulation thermique sous Matlab
Générer le code exécutable de l’application temps réel
Dans le menu Tools de la fenêtre simulink, sélectionner le sous-menu Real-Time Workshop
Cliquer sur la rubrique Build Model
Real-Time Workshop génère plusieurs fichiers sources, les compile et génère le fichier binaire
regul_rt.rwd correspondant à l’application temps réel sous windows.
C.5.
Exécution du code
Avant d’exécuter l’application temps réel sous windows, il faut vérifier que le noyau
temps réel de Matlab soit installé.
Entrer sur la ligne de commande Matlab : rtwho ↵
Si le message suivant apparaît, cela signifie que le noyau temps réel est installé
Sinon, installer le noyau temps réel en tapant la commande : rtwintgt –install ↵
Redémarrer le micro-ordinateur pour que le noyau soit actif
Ouvrir à nouveau le modèle regul_rt.mdl
Cocher le mode External dans le menu Simulation de la fenêtre simulink, pour que le module
simulink s’exécute dans le mode externe
Pour visualiser les tracés des courbes en temps réel sur les blocs scope, ajouter les
paramètres de déclenchement
Dans le menu Tools de la fenêtre simulink, cliquer sur External mode control panel…
Patrick BRUNET-Emile FERRERE
Année 2000-2001
28
Régulation thermique sous Matlab
La boîte de dialogue External Mode Control Panel s’ouvre :
Cliquer sur le bouton Target interface … et vérifier que le fichier rtwinext.dll soit bien entré
Cliquer sur le bouton OK
Patrick BRUNET-Emile FERRERE
Année 2000-2001
29
Régulation thermique sous Matlab
Cliquer sur le bouton Signal & triggering …
La boîte de dialogue External Signal & Triggering s’ouvre :
Cocher la case Select all
Sélectionner manual dans la liste Source
Sélectionner normal dans la liste Mode
Indiquer le nombre de points à afficher (durée=1000 s, fréquence échantillonnage = 1 Hz => 1000
dans le champ Duration
Cocher la case Arm when connect to target
Cliquer sur le bouton Apply pour que les nouveaux paramètres soient pris en compte
Cliquer sur le bouton Close
Patrick BRUNET-Emile FERRERE
Année 2000-2001
30
Régulation thermique sous Matlab
Connecter le modèle simulink regul_rt.mdl à l’application temps réel regul_rt.rwd,
en cliquant sur Connect to target du menu Simulation ou sur l’icône de la barre
d’outils
L’application temps réel est chargé en mémoire et communique avec le modèle simulink.
Démarrer la régulation du système en cliquant sur Start real-time code ou sur
de la barre d’outils
l’icône
Patrick BRUNET-Emile FERRERE
Année 2000-2001
31
Régulation thermique sous Matlab
C.6.
Résultats temps réel
C.6.1. Réponse à une consigne de température
Ces résultats de mesure seront mis en parallèle avec ceux obtenus en simulation (cf. paragraphe
B.4.1). Ils ont été réalisés un jour de forte chaleur dans une salle non climatisée (température ambiante
proche de 30°C !).
La période d’échantillonnage a été fixée à 5 s dans cet essai.
On peut noter que la durée de mise en température est assez proche de celle obtenue en simulation.
On note un léger dépassement de la consigne qui peut s’expliquer par le fait que le thermoplongeur
possède une inertie thermique et que les échanges de chaleur ne sont pas instantanés. La température
mettra donc du temps à s’homogénéiser et la sonde thermique ne donnera une information fiable que
lorsque cette homogénéisation aura eu lieu. Ces aspects n’ont pas été pris en compte dans la modélisation.
La consigne étant réglée à 30°C, soit très proche de la température ambiante, aucun
refroidissement naturel ne pourra avoir lieu ce qui explique que la température atteinte reste stabilisée
autour de 31 °C.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
32
Régulation thermique sous Matlab
C.6.2. Réponse à une perturbation en régime établi
Ces résultats seront comparés à ceux du paragraphe B.4.2. Ils ont été obtenus avec une période
d’échantillonnage de 1s. La perturbation consiste à introduire une petite quantité de glace dans le seau ;
On constate la chute de la température puis sa remontée grâce à l’apport de puissance thermique
du thermoplongeur comme l’atteste la tension de commande du Gradipack.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
33
Régulation thermique sous Matlab
C.6.3. Réponse à une modification de la consigne en cours de régulation
Il est possible de modifier en temps réel la valeur de la consigne de température (comme d’autres
paramètres du modèle).
C’est ce que montre les 4 oscillogrammes ci-dessous.
La consigne est réglée à 30 °C pendant les 300 premières secondes puis portée à 50 °C. Enfin une
perturbation est introduite autour de 700 s.
On notera les mises en températures avec les évolutions de la tension de commande du Gradipack
correspondantes.
Contrairement à ce qu’il se passait avec une consigne de 30 °C, lorsque celle celle-ci est portée à
50 °C, la température chute naturellement. En effet le différentiel de température entre l’eau et l’ambiante
(20 °C environ) permet cette fois un refroidissement naturel. En conséquence, on note la remise en action
du Gradipack qui permet la compensation des pertes.
Patrick BRUNET-Emile FERRERE
Année 2000-2001
34
Régulation thermique sous Matlab
D.
Conclusion
L’objectif de cette contribution est de montrer la faisabilité d’une application temps réel mettant
en œuvre les outils de modélisation de MATLAB pour la partie commande . Dans cet article, c’est un
contrôleur flou qui a été implanté, mais on pourrait tout aussi bien mettre en œuvre un contrôleur PID
plus classique.
On peut penser que les opérations préalables à la génération du code sont un peu lourdes. Un
développement futur permettra de les rendre transparents pour un utilisateur non intéressé par cette partie.
Enfin d’autres cartes d’Entrées / Sorties pourraient être prises en compte.
Toutes les remarques à propos de cette étude peuvent nous être adressées à :
[email protected] (Patrick BRUNET) ou [email protected] (Emile FERRERE).
Patrick BRUNET-Emile FERRERE
Année 2000-2001
35