Vous êtes sur la page 1sur 17

Commande d’un MCC par un RLF

I.INTRODUCTION GENERALE :
L’intérêt de l’utilisation de la commande par logique floue sur les machines électriques à
courant continu à excitation séparée est d’éviter les inconvénients de la commande classique tout en
gardant les avantages  simplicité de la commande du flux et du couple à partir du courant d’excitation et
du courant d’induit.

II. Objectif :
L’objectif de ce mini projet est d’utiliser la commande par la logique floue pour illustre une
mise en œuvre concrète pour la commande d’un système réel, qu’est un moteur à courant continu à
excitation séparé, on va utiliser les concepts de base du MATLAB.

III.ETUDE THEORIQUE :
La logique floue est une nouvelle méthode de réglage qui a été introduite à large échelle au
Japon. Cependant, plus récemment elle est de plus en plus appliquée en Europe.

Les méthodes de réglage conventionnelles se basent sur une modélisation adéquate du système
et un traitement analytique à l’aide de fonction de transfert ou d’équations d’état. Par contre le réglage par
logique floue donne une approche plus tôt programmatique, permettant d’inclure les expériences acquises
par les opérateurs.

En effet les bases théoriques de la logique floue ont été établies en 1965 par le professeur
L.A.Zadeh de l’université de Californie de Berkeley, a cette époque cette nouvelle théorie n’a pas été
prise au sérieux, elle permet le traitement des variables non exactes dont la valeur peut varier entre 0 et1.

Cette nouvelle théories a été appliquée initialement dans des domaines non techniques, tel que
le commerce ou la médecine, dans le but de compléter les systèmes experts.
Les premières applications de la logique floue au niveau des systèmes de réglage ne parurent
que dés 1975. Ce sont les Japonais que commencent à l’utiliser dans des produits industriels pour
résoudre les problèmes de réglage et de commande, et récemment en Europe, une intense activité de
recherche à été introduite afin d’introduire ce principe de réglage.

1
Commande d’un MCC par un RLF

1. Principe fondamentale de la logique floue :

Le mode de pensée d’un être humain est généralement fondé sur un résonnement empirique, où
l’analogie et l’intuition jouent un rôle très important. En fait, nos jugements ne nous permettent que
d’évaluer certaines grandeurs que de manière imprécise. Le schéma de principe de ce raisonnement peut
être représenté comme suit :

Figure.1. Principe de ce raisonnement

2. Les régulateurs flous :


Un régulateur flou peut être présenté de différentes façons, mais en général la présentation adoptée
se scinde en trois parties qui sont La fuzzification qui permet de passer de variables réelles à des variables floues,
le cœur du régulateur représenté par les règles reliant les entrées et sorties, et enfin l'inférence et la
défuzzification qui permettent à partir des ensembles flous d'entrée de déterminer la valeur réelle de sortie.

2.1.Fuzzification des entrées  :


L’objectif de la fuzzification est de définir les fonctions d’appartenance pour les différentes variables
(variable d’entrée et de sortie), on réalise ainsi un passage des grandeurs physiques en variables linguistiques
(variables floues) qui peuvent alors être traité par les inférences.

Dans le réglage flou, on utilise en général des fonctions d’appartenance triangulaires et trapézoïdes.

2
Commande d’un MCC par un RLF

En générale, on introduit pour un variable trois, cinq ou sept ensemble représenté par des fonctions
d’appartenances (Figure I-1).

Figure.2. Fonctions d’appartenance triangulaire

2.2.Les lois d’inférence  :


La stratégie de réglage dépend des inférences adoptées. Elles lient les variables d’entrée à une variable
de sortie, un type de règle peut être par exemple :

Si
x 1 est positif et x 2 est zéro alors u est négatif


x 1 et x 2 représentent deux variables d’entrée et u la sortie de commande.

Dans les inférences on utilise les opérateurs ET OU, l’opérateur ET est utilisé pour les variables à
l’intérieur d’une règle, alors que l’opérateur OU lie les différentes règles, il existe plusieurs méthodes pour réaliser
ces opérateurs. On introduit donc la notion de méthodes d’inférence.

Généralement on utilise une des méthodes suivantes :

 méthode d’inférence max-min

 méthode d’inférence max-produit

 méthode d’inférence somme-produit

qui permettent un traitement numérique des inférences.

3
Commande d’un MCC par un RLF

 Méthode d’inférence somme-produit :

La méthode d’inférence somme-produit réalise, au niveau de la condition, l’opérateur OU


par la formation somme, et l’opérateur ET par la formation produit, au niveau de la conclusion elle réalise
l’opérateur ALORS par la formation produit. L’opérateur OU qui lie les différentes règles est réalisé par la
formation somme.

2.3. La défuzzification  :
Elle consiste de transformer la variable floue résultante d’inférence des règles en une information
déterministe. La méthode de défuzzification la plus utilisé est celle par centre de gravité, qui détermine le centre
de gravité de la fonction d’appartenance résultante.

2.4. Régulateur flou de type MAMDANI  :


Ce régulateur utilise la forme de Mamdani pour obtenu la commande a partir des différents entrées:

Ri  : Si x1 est E1 ET x2 est E2 ET … ET xn est En Alors U est Ui

n  : nombres de variables d’entrée.

i  : la ième règle.

On peut citer quatre structures connues qui sont  la structure proportionnelle, proportionnelle dérivée,
proportionnelle intégrale, et proportionnelle dérivée intégrale.

 Régulateur flou proportionnel :

La loi de commande d'un régulateur flou de ce type est proportionnelle à la valeur de l'erreur entre la
sortie du système et la consigne ; les règles sont de la forme : Si e(k) est E alors u(k) est U.

La loi de commande s'apparente à celle d'un régulateur Proportionnel classique avec un gain non linéaire :

 Régulateur flou proportionnel dérivé :

Pour ce type de régulateur, la commande du système s'obtient en fonction des erreurs et de leurs

dérivées premières suivant des règles de la forme : Si e(k) est E ET de(k) est DE ALORS u(k) est U.

4
Commande d’un MCC par un RLF

La loi de commande du régulateur PD classique équivalent est :

u(k )=K p (k )⋅e (k )+ K d (k )⋅de( k )

 Régulateur flou proportionnel intégral :

C'est le plus classique des régulateurs à structure PID utilisés pour des systèmes d'ordre inférieur ou

égal à 2. Une règle s'écrit alors sous la forme : Si e(k) est E ET de(k) est DE ALORS du(k) est DU.

Le régulateur PI classique équivalent s'écrivant :

du( k )=K p ( k )⋅de(k )+K i (k )⋅e (k )

 Régulateur flou proportionnel intégral et dérivé :

Ce dernier type de régulateur utilise l'erreur, l'intégrale de l'erreur et la variation de l'erreur pour

k−1
δe(k )= ∑ e(i)
élaborer les règles. Avec : i=1 , les règles sont de la forme : Si e(k) est E ET de(k) est DE ET δe(k) est
SE ALORS u(k) est U.

VI. étude théorique :

Soit à régler la vitesse d’un mcc en utilisant un RLF à action PI selon le schéma suivante :

Figure.3. : Schéma bloc de commande d’un MCC par PI floue.

5
Commande d’un MCC par un RLF

 Données :

MCC : Ra =0.6 Ω ; l a=0.012 H ; U a=220 V ; R f =240 Ω; l f =120 H ; maf =1.8 ;

s
j=1 Kgm 2 ; f r=0.007032 Nm ; C =5.282 ; wrn=100 ; p=1 ;
rad f

Pour le regulateur RLF les gains K e , K de , K dce ,sont choisies par tâtonnement.

 Caractéristiques du RLF :

e=Ω¿r−Ωr , ∆ e , ∆ C emsont fuzzifiés par 5 sous ensembles flous, la Méthode d’inférence Somme-Produit
et Méthode de défuzzification de Centroïde.
Le régulateur de vitesse aura comme entrées l'erreur sur la vitesse et sa dérivée et pour sortie la
variation de la consigne de courant, qui sera intégrée afin d'obtenir Ic. La base de règle associée au
régulateur de type Mamdani est la suivante :

Figure.4. Fonction d’appartenance à 5 sous ensembles flous pour la fuzzification de

e, ∆ e , ∆ C em

 Modèle de la MCC :

dI a

{
U a=R a I a + La +E
dt
dI f
U f =L f +Rf I f
dt
dΩ 1
= (k I −Cr −f r Ω)
dt J c a

 Modèle de régulateur de courant :


Si I ¿a−I a ≥ ∆i=¿ U a =E

Si I ¿a−I a ≤−∆ i=¿ U a=−E

6
Commande d’un MCC par un RLF

 Limitation de courant:
Si i a ≥ i max =¿ i a=i max
Si i a ≤ i max =¿ i a=−i max

 Algorithme :
1. Lecture de données ;
2. initialisation ;
3. Boucle de calcul

Tant que temps ≤ temps finale


% Définir les entrées l’erreur e, et sa dérivée ∆ e , et on les normalisés;
¿
Initialialement e (i )=Ωr−Ωr , ∆ e ( i )=e(i)

% La fuzzification des entrées ;


% L’inférence floue et base des données ;
%Défuzzification ;
%controle par hystérésis ;
% limitateur de courant ;
% Résolution des équations de la machine
e (i+1 )=∆ e ( i ) , ∆ e ( i+1 )=Ω¿r (i+1) −Ωr (i+1)
Fin

 Programme :
clear all;clc;
% ------LE REGLAGE DE LA VITESSE D'UN MCC PAR UN FLC A ACTION PI
%----- lecture de donnés(MCC+FLC)-----------
ra=0.6; la=0.012;ua=220;maf=1.8; j=1; rf=240;lf=120;ufn=220;
fr=0.007032;cf=5.282;;wrn=150;p=1; E=200; ifn=ufn/rf;ia=30;
wrn=150;ke=0.005; kde=0.004; kucm=0.03;kt=1/(p*maf*ifn);iref=0;
imax=90;
di=0.5; h=0.01;
%--------------------- initialisation-------------------------------%
i=1;tf=100;k=1;
t(1)=0;
ia(1)=0;
w=0;e=0;
r=ke*(wrn-w);
de=kde*((r-e)/h);
e=r;
de;
cem=0;
t1(i)=t;
% -------------------Boucle de calcul
while t<=tf
% --------------1 ERE ETAPE : FUZZIFICATION.
% --------------fuzzification de l'erreur
if e<-1 munge=1
elseif -1<=e<=-0.5 munge=-2*e+1
else munge=0
end;
if -1<=e<=-0.5 munme=2*e+2

7
Commande d’un MCC par un RLF
elseif -0.5<=e<=0 munme=-2*e
else munme=0
end;
if -0.5<=e<=0 mueze=2*e+1
elseif 0<=e<=0.5 mueze=-2*e+1
else mueze=0
end;
if 0<=e<=0.5 mupme=2*e
elseif 0.5<=e<=1 mupme=-2*e+2
else mupme=0
end;
if 0.5<=e<=1 mupge=2*e-1
elseif e<=1 mupge=1
else mupge=0
end;
% -------------------fuzzification de la variation de l'erreur=de
if de<-1 mungde=1
elseif -1<=de<=-0.5 mungde=-2*e+1
else mungde=0
end;
if -1<=de<=-0.5 munmde=2*e+2
elseif -0.5<=de<=0 munmde=-2*e
else munmde=0
end;
if -0.5<=de<=0 muezde=2*e+1
elseif 0<=de<=0.5 muezde=-2*e+1
else muezde=0
end;
if 0<=de<=0.5 mupmde=2*e
elseif 0.5<=de<=1 mupmde=-2*e+2
else mupmde=0
end;
if 0.5<=de<=1 mupgde=2*e-1
elseif de<=1 mupgde=1
else mupgde=0
end;
e0=e;
% ------------LA 2 EME ETAPE : INFERENCE FLOUE PAR SOMME-PRODUIT
% Xr(i)la surface de la fonction d'appartennance de la sortie correspondant à la
régle (i).
% Xg(i) est l'abscisse de son centre de gravité .
Xr(1)=0.25; Xg(1)=-0.5-1/3;
Xr(2)=0.25; Xg(2)=-0.5-1/3;
Xr(3)=0.5; Xg(3)=-0.5;
Xr(4)=0.5; Xg(4)=-0.5;
Xr(5)=0.5; Xg(5)=0;
Xr(6)=0.25; Xg(6)=-0.5-1/3;
Xr(7)=0.5; Xg(7)=-0.5;
Xr(8)=0.5; Xg(8)=-0.5;
Xr(9)=0.5; Xg(9)=0;
Xr(10)=0.5; Xg(10)=0.5;
Xr(11)=0.5; Xg(11)=-0.5;
Xr(12)=0.5; Xg(12)=-0.5;
Xr(13)=0.5; Xg(13)=0;
Xr(14)=0.5; Xg(14)=0.5;
Xr(15)=0.5; Xg(15)=0.5;
Xr(16)=0.5; Xg(16)=-0.5;
Xr(17)=0.5; Xg(17)=0;
Xr(18)=0.5; Xg(18)=0.5;
Xr(19)=0.5; Xg(19)=+0.;
Xr(20)=0.25; Xg(20)=0.5+1/3;
Xr(21)=0.5; Xg(21)=0;
8
Commande d’un MCC par un RLF
Xr(22)=0.5; Xg(22)=0.5;
Xr(23)=0.5; Xg(23)=0.5;
Xr(24)=0.25; Xg(24)=0.5+1/3;
Xr(25)=0.25; Xg(25)=0.5+1/3;
% Uc(i) est le degré de vérification de la prémisse de la régle (i).
Uc(1)=munge*mungde;Uc(2)=munge*munmde;Uc(3)=munge*muezde;
Uc(4)=munge*mupmde;Uc(5)=munge*mupgde;Uc(6)=munme*mungde;
Uc(7)=munme*munmde;Uc(8)=munme*muezde;Uc(9)=munme*mupmde;
Uc(10)=munme*mupgde;Uc(11)=mueze*mungde;Uc(12)=mueze*munmde;
Uc(13)=mueze*muezde;Uc(14)=mueze*mupmde;Uc(15)=mueze*mupgde;
Uc(16)=mupme*mungde;Uc(17)=mupme*munmde;Uc(18)=mupme*muezde;
Uc(19)=mupme*mupmde;Uc(20)=mupme*mupgde;Uc(21)=mupge*mungde;
Uc(22)=mupge*munmde;Uc(23)=mupge*muezde;Uc(24)=mupge*mupmde;Uc(25)=mupge*mupgde;
% LA 3 EME ETAPE : DEFUZZIFICATION PAR LA METHODE DE CENTROIDE
s1=0;s2=0;
for i=1:25
s1=s1+Uc(i)*Xg(i)*Xr(i);
s2=s2+Uc(i)*Xr(i);
end
ACG=s1/s2;
Ucm=kucm*ACG;
Cem=cem+Ucm;
iref=kt*Cem;
%procédé du comparateur par hystérésis
if abs(ia)>iref+di,
ua=sign(ia)*E;
end;

%limitateur de courant
if abs(ia)>imax;
ia=sign(imax)*imax;
end;
% procédure resultat le modéle du MCC ia if wr
ifn=(h/ifn)*(ufn-rf*ifn)+ifn;
ia=(h/la)*(ua-ra*ia-p*maf*ifn*w)+ia;
w=(h/j)*(p*maf*ia*ifn-fr*w-cf)+w;
s1(i)=ifn;
s2(i)=ia;
s3(i)=w;
tt(i)=t;
t=t+h;
i=i+1;

end
plot(t,s1,'r');grid on;
figure%1
plot(t,s2);grid on;
figure%2
plot(t,s3,'b');grid on;
figure%3

9
Commande d’un MCC par un RLF

Après l’éxuction de ce programme on obtient les résultats suivants :

evolution du courant d'exitation


1

0.9

0.8

0.7
courant d'inducteur if

0.6

0.5

0.4

0.3

0.2

0.1

0
0 5 10 15 20 25 30 35 40
temps (sec)

10
Commande d’un MCC par un RLF

evolution du courant d'induit


160

140

120

100
courant d'induit ia

80

60

40

20

0
0 5 10 15 20 25 30 35 40
temps(sec)

evolution de la vitesse
100

90

80

70

60
vitesse

50

40

30

20

10

0
0 5 10 15 20 25 30 35 40
temps (sec)

11
Commande d’un MCC par un RLF

SIMULATION-Mise en œuvre de la boite outils- :

Les trois premiers étapes sont franchies, pouvons utiliser les services de la boite à outils Fuzzy
Logic.

1. ouvrez l’éditeur FIS (Fuzzy Inference System) en tappant : fuzzy dans la fenêtre de commande
MATLAB, On ajoute une entrée à ce régulateur avec Edit : Add input.

12
Commande d’un MCC par un RLF

2. Pour choisit les fonctions d’appartenance :View : Edit Membreship Functions. Cet éditeur permet de
définir les ensembles flous de chacun des variables erreur, derreur, XR.

13
Commande d’un MCC par un RLF

3. maintenant, édite les règles d’inférence (rules) en restant dans le menu View : Edit rules …A une
combinaison des entrées correspondra une valeur (floue) pour la sortie.

14
Commande d’un MCC par un RLF

4. Exploitation : le rule viewer :


En cliquant maintenant sur View : View rules, vous faites apparaitre la fenêtre de rule viewer qui montre
pour un erreur de +0.147,il faut appliquée un signal de commande sur le système de 0.23.
15
Commande d’un MCC par un RLF

-il existe d’autres outils pour utilisateurs plus expérimentés et notamment le surface viewer qui montre,
sous la forme d’une surface, la relation entre la sortie et les deux entrées : XR=f (erreur , derreur).cette relation

16
Commande d’un MCC par un RLF

non linéaire résulte la définition même des ensembles flous (nombre et forme définie par la fonction
d’appartenance ) et des règles d’inférence.

V. Conclusion :
Après cette application, nous pouvons déduire quelques avantages et inconvénients de cette technique de
commande :

 La logique floue ne nécessite pas de modèle du système à commander.


 le contrôleur floue reste robuste vis-à-vis les perturbations interne et externe.
 mais les problèmes majeur de la logique floue est l’élaboration des règles et les largeur des sous ensembles
floues ou il faut des experts pour les déterminés, mais en fais appelle a d’autre éléments de soft computing
tel que les RN pour joué le rôle de l’expert humain.

17

Vous aimerez peut-être aussi