Compte rendu des Tps

Commande avancée

Fait par : Encadré par :

BOULBAZ Nouhayla M. BOUHOUCHE
AL KHADIRI Ihsane

Ecole Polytechnique privée d’Agadir

Année universitaire 2022/2023
TP 1 : Familiarisation avec "Fuzzy Logic" de Matlab/Simulink Contrôleur Floue

Introduction :
Ce TP a pour but se familiariser à manipuler, d’une part Simulink et d'autre part la boite à outil "Fuzzy Logic
Toolbox" intégrés à Matlab.
Afin d’être capable de réaliser le schéma d'un régulateur flou sous Simulink et effectuer sa simulation et sa
comparaison avec le régulateur classique PID.
Cahier des charges :
 Sous Simulink, réaliser le schéma d'un régulateur classique PID avec des paramètres prédéfinis.
 Compléter le schéma sous Simulink, en ajoutant un régulateur flou en utilisant la boite à outils
"Fuzzy Logic Toolbox".
 Comparer les simulations des deux régulateurs en les visualisant sur un scope
Développement :
Pour commencer Simulink, il suffit de taper la commande Simulink à la ligne de commandes de Matlab. Le
contrôleur à logique floue est situé sous les options "Fuzzy Logic Toolbox".
On obtient la fenêtre suivante :

Le bloc Fuzzy Logic Controller est celui utilisée.

Le bloc Fuzzy Logic Controller with Ruleviewer est presque la même chose, sauf que l'éditeur qui permet de
voir l'inférence et la défuzzification s'ouvre lors d'une simulation.
Après l’insertion des composants, on a obtenu le schéma suivant :
Dans le but de comparer la performance d’un contrôleur PID classique avec le contrôleur flou.
Le contrôleur PID classique à appliquer au système sous étude possède la fonction de transfert ci-dessous à
développer son dénominateur et mettre sous forme d'un polynôme du troisième degré en s :

On obtient alors le schéma suivant :

Le design du contrôleur flou se fait de la même façon que tous les systèmes flous avec Matlab. On commence
en tapant fuzzy à la ligne de commande. On obtient alors le FIS Editor ou Fuzzy Logic Designer de Matlab,
montré à la figure suivante.
Pour le système simple sous étude, on n'utilise qu'une seule entrée qui est l'erreur comme variable de contrôle.
On a donc un système très simple, avec une seule entrée et une sortie.

On ne choisit que 3 variables linguistiques possibles, soit Negative, Zero et Positive. Il est généralement plus
facile de commencer avec un nombre restreint de variables linguistiques possibles, pour simplifier le design
initial.
Dans notre cas, l'entrée utilisée est une entrée échelon unitaire. On choisit de développer les fonctions
d'appartenance du contrôleur flou pour l'entrée entre -1 et +1.
Commencer avec un intervalle de la sortie de -7.5 à +10. Le signal de sortie peut être bien plus grand que le
signal d'entrée afin de corriger rapidement l'erreur.
 Pour l’entrée :

Pour la sortie :
On applique les règles suivantes :
1. IF error is Negative THEN control is Negative
2. IF error is Zero THEN control is Zero
3. IF error is Positive THEN control is Positive

Après la détermination des règles, on a associé le fuzzy au WORKSPACE de MATLAB,

Alors on a simulé le système pour le comparer avec le PID
On a visualisé donc les signaux d’après le scope :
Le temps de stabilisation du contrôleur fuzzy est inférieur au temps de stabilisation du contrôleur PID ;
 Le contrôleur fuzzy est plus facile et plus efficace que le PID (le PID nécessite beaucoup de calcul par
contre le fuzzy nécessite seulement l’information de l’expert)

 Visualisation des règles et surface :

 Après la suppression de la première règle :

Le temps de stabilisation du contrôleur fuzzy est trop supérieur au temps de stabilisation du contrôleur PID
  Changement des paramètres de zero :

La représentation de fuzzy sort de l’ordinaire.

Le temps de stabilisation du contrôleur fuzzy est trop inférieur au temps de stabilisation du contrôleur PID.

Conclusion :
Vers la fin de la séance, on a pu acquérir aux objectifs mentionnés au début.
On a pu alors réaliser le schéma d'un régulateur flou sous Simulink et effectuer sa simulation et sa comparaison
avec le régulateur classique PID afin de savoir l’intérêt de régulateur flou.
TP2 : Contrôleur Floue de Niveau

Introduction :
Ce Tp a pour but de créer un système d'inférence floue associé au régulateur flou proposé, afin d’Effectuer la
simulation et la comparaison avec le régulateur classique PID.
Cahier des charges :
 Compléter la réalisation en créant le système d'inférence flou du régulateur flou proposé en utilisant
la boite à outils "Fuzzy Logic Toolbox".
 Comparer les simulations des deux régulateurs en les visualisant sur un scope.
Développement :
Une cuve contient un fluide sur une hauteur h. Cette cuve peut être alimentée par une pompe munie d'une valve
"V" imposant un débit volumique. Une autre vanne en fond de cuve engendre un débit de fuite. Le contrôleur
flou schématisé ci-dessous permettra de fournir un signal de commande U en sortie agissant sur la valve V. Le
régulateur Flou à compléter est doté de 2 entrées (Niveau, Derive) et une sortie (Valve). Il sera comparé au
régulateur classique PID en utilisant un schéma Simulink fourni :

 Schéma de comparaison entre un contrôleur PID et un contrôleur floue :

Ajustement les fonctions d'appartenance des 2 entrées (Niveau et Derive) et de la sortie (Valve) ainsi que la
base de règles selon les indications suivantes :
 Définition des entrées et de la sortie :

L’entrée niveau :
L’entrée derive :

La sortie valve :
 Définition des règles d’inférence :

Le commutateur "Switch manuel" permet de comparer les 2 contrôleurs, en faisant dessus un double clic.
Et on peut visualiser sur le scope "Comparaison" les résultats de simulation, en mettant d'abord le
commutateur en position PID, ensuite mettre le commutateur en position Flou.

 Le commutateur en position PID :

On remarque des oscillations qui dépassent l’idéal.

Dans un premier temps on voit que le niveau d’eau dépasse le niveau haut après il se stabilise, de même
pour le niveau bas, il diminue puis il se stabilise.

 Le commutateur en position FLOU :

On remarque qu’il n’y a pas d’oscillations par rapport au cas du PID

Le niveau d’eau se stabilise directement

Remarque
En comparant les deux cas, on constate que le PID provoque souvent des oscillations par contre le
régulateur flou est exacte. On peut dire donc que le temps de réponse du deuxième cas est faible par
rapport au premier cas.
Alors le régulateur flou est plus précis d’avantage.

 Changement de l’intervalle pour :

Pour une sortie Valve de [-3 3] :

On constate que le temps de réponse est plus grand que pour l’intervalle [-1 1]

Pour une sortie Valve de [-0.5 0.5] :

On constate l’apparition des oscillations c’est dû à la tension d’alimentation qui est très petite
 L’entrée Niveau [-0.5 0.5] :

On constate la diminution des oscillations par rapport au cas précédents

L’entrée Niveau [-2 2] :

Temps de réponse est long est cela dû à l’intervalle niveau qu’on a élargi
Remettre les valeurs initiales et changement de l’entrée derive intervalle [-0.5 0.5]:

Pas de dépassement alors pas d’oscillations

Remettre les valeurs initiales et changement de l’entrée derive intervalle [-2 2]:

Lorsqu’on a trop élargi l’intervalle de [-0.5 0.5] à [-2 2] on remarque qu’il s’affiche des oscillations par
contre dans le premier cas y a pas d’oscillations.
  Ajouter les règles :
1ère règle : Si Niveau est "Ok" ET Derive est "Non" Alors Valve est "Ouvr-Lent"

Lorsqu’on a ajouté cette première règle on constate que le système a été perturbé et le niveau d’eau
dépasse largement le niveau haut.

2ème règle : Si Niveau est "Ok" ET Derive est "Non" Alors Valve est "Ferm-Lent"

La deuxième règle ajoutée a perturbé le système, le signal dépasse le niveau bas de la consigne.

3ème règle : Si Niveau est "Ok" ET Derive est "Non" Alors Valve est "Ouvr-Rapid"

La troisième règle ajoutée a perturbé le système, le signal dépasse largement le niveau haut de la
consigne.
 4ème règle : Si Niveau est "Ok" ET Derive est "Non" Alors Valve est "Ferm-Rapid"

La quatrième règle ajoutée est précise, du coup le niveau d’eau ne dépasse ni le niveau haut ni le niveau
bas de la consigne
Remarque :
On peut dire donc que parmi tous ces cas-là, la quatrième règle seulement qui est adéquate à la consigne dans la
mesure où on ne voit pas d’oscillations sur l’oscilloscope et le temps de réponse n’est pas trop long.
Conclusion :
Vers la fin de la séance, on a pu acquérir aux objectifs mentionnés au début.
On a pu créer un système d'inférence floue associé au régulateur flou proposé et effectuer la simulation et la
comparaison avec le régulateur classique PID.
TP3 : Contrôle de vitesse d'un moteur CC à excitation séparée Comparaison Contrôleur
Floue / PID
Introduction :
Ce Tp a pour but de créer un système d'inférence floue associé aux régulateurs RLF. Afin d’effectuer la simulation et la
comparaison avec le régulateur classique PID.
Cahier des charges :
o Créer et réaliser le schéma bloc sous Simulink permettant de comparer les 2 régulateurs Flou et PID
classique.
o Créer le système d'inférence flou du régulateur flou proposé en utilisant la boite à outils "Fuzzy Logic
Toolbox".
Développement :
Dans le cas des machines tournantes, nous nous intéressons à un moteur à courant continu (MCC). Le contrôle
de sa vitesse de rotation peut se faire par divers régulateurs, par exemple à base d'un PID classique, nécessitant
une modélisation mathématique adéquate et un calcul assez précis pour trouver les paramètres idéaux, ou
encore plus simplement en utilisant un régulateur flou (RLF) ne nécessitant pas de modèle mathématique mais
plutôt une bonne base de connaissances (Base de règles).
Dans ce TP nous allons comparer les 2 régulateurs Flou et classique PID afin d'estimer le régulateur le mieux
adapté.

Dans ce schéma bloc, sous forme de 2 boucles fermées, la fonction de transfert insérée dans chacune des
boucles représente le modèle d'une machine MCC pour laquelle nous souhaitons réguler la vitesse.
Concernant les paramètres du PID ils sont indiqués sur ce schéma. Comme vous le remarquez au niveau du
RLF, il possède 2 entrées l'erreur et sa dérivée (Err et DErr) et la sortie (Control) permettant de fournir le signal
de contrôle de la vitesse de la MCC.
Grâce à l'oscilloscope appelé ici Vitesse nous visualisons et comparons ce signal de contrôle fourni par chacun
des régulateurs.
Après on tape la commande "fuzzy" ; ce qui fera apparaitre la fenêtre "Fuzzy Logic Designer".
 Ajuster les fonctions d'appartenance des 2 entrées (Err et DErr) et de la sortie (Control)
Entrée : Err

Entrée : DErr
 Sortie : Control

 Base de Règles :
  La simulation de ces 2 régulateurs puis comparer-les par visualisation de leur sortie sur le
scope prévu à cet effet :

o La courbe VP en move c’est pour le PID

o La courbe VF en jaune c’est pour le fuzzy

Remarque :
Retard dans la stabilité mais moins d’oscillations
Par contre le PID y a beaucoup d’oscillations.
  Visualisation de la surface en 3D du domaine d'inférence :

Conclusion :
Vers la fin de la séance, on a pu acquérir aux objectifs mentionnés au début.
On a pu alors créer un système d'inférence floue associé aux régulateurs RLF et ffectuer la simulation et la
comparaison avec le régulateur classique PID.
TP 4 : Hacheur "Boost" commandé par un contrôleur flou
Introduction
Ce TP a pour but de simuler un contrôleur du hacheur parallèle ou "Boost" par les outils de la logique floue
afin d’être capable de dessiner le schéma du régulateur flou d'un hacheur parallèle (Boost) sous Simulink et -
Effectuer sa simulation.

Cahier de charge
o Sous Simulink, réaliser le schéma donné ci-dessous, en concevant le régulateur à l'aide de la boite à outils
"Fuzzy Logic Toolbox".
o Voir en temps réel, par des visualisations à travers des scope, l'effet d'une consigne fixe, puis variable
sous forme d'escalier, sur la sortie de ce hacheur "Boost".

Développement
Comme vu dans les ateliers précédents, le développement d'un contrôleur flou intégré aux schémas blocs sous
Simulink, permettra une simulation en temps réel du système étudié. Dans cet atelier nous allons tester la
commande floue pour une consigne (Tension Ref.) d'abord fixe, ensuite variable sous forme d'escalier (Voir les
figures plus en bas).
Pour commencer, tracer le schéma bloc Simulink ci-dessous, en utilisant les blocs suivants dont certains
paramètres sont indiqués sur le schéma bloc.

Pour le bloc "Fuzzy Logic Controller", il sera configuré comme montré ci-dessous avec des fonctions
d'appartenances de type triangulaire. Ce bloc est doté de 2 entrées (Erreur & D-Erreur) et une sortie (Alpha)
équivalente à l'angle d'amorçage du transistor du Mosfet. Les variables d'entrée et de sortie évoluent toutes
dans les limites +1 et -1.
L’entrée Erreur

L’entrée D-Erreur
 La sortie alpha

Comme les fonctions d'appartenance correspondent à 7 variables linguistiques pour chacune des 2 entrées, ce
qui donnera 49 (= 7x7) règles pour le système d'inférence :
  La simulation
Voilà les signaux du courant d’entrée et de sortie, ainsi que les signaux de la tension d’entrée et de sortie

Le signal de référence est à 40 V

On remplace alors le bloc de la "Tension de Référence" par le générateur nommé "Signal Builder". Avec ce
dernier, on peut dessiner un signal électrique en forme d'escalier comme le montre la figure ci-dessous.

Signal de référence :

Après la simulation on peut voir donc les signaux :

 On compare ces deux signaux (tension de référence et tension de sortie) :

Dans un premier temps ( à la pulsation 20V), même si on impose que le signal commence à 20 V, mais il
commence à presque 24 V , il suit alors la valeur du DC Voltage qui est 24 V.
Pour la pulsation 35 V et 40 V, le signal commence à 35 V dans un premier temps, et à 40 V dans un
deuxième temps, comme imposer de la part de la consigne (signal builder)
Remarque :
Pour minimiser les piques, on doit agir sur les valeurs de R et C ainsi que les règles d’inférence et
fonctions d’appartenances.

Conclusion
Vers la fin de la séance, on a pu acquérir aux objectifs mentionnés au début.
On a pu simuler un contrôleur du hacheur parallèle ou "Boost" par les outils de la logique floue, en
effectuant sa simulation.