Toujours dans le but d'illustrer le dossier sur le Logique Floue, cet article présente un second et dernier exemple de système flou : le régulateur proportionnel intégrale flou (PI flou).
Le système flou sera assez basique et pourra être grandement améliorer le but étant avant tout de comprendre comment mettre en place une régulation flou de type PI. En fin d'article, j'expliquerais comment étendre l'exemple à un régulateur plus complet de type PID. Par contre, je n'ai pas fait de simulations, je vous laisse le soin de tester ce régulateur et d'effectuer les réglages vous-même.

Si vous ne connaissez pas le principe des régulateurs PI ou PID pour asservir un système, je vous conseille de faire une petite recherche sur le web ou de lire cet article qui explique le fonctionnement d'un PID : Implémenter un PID sans faire de calculs !

I Principe d'un régulateur PI

Dans l'article Implémenter un PID sans faire de calculs, j'explique comment fonctionne un régulateur de type PI : en définissant la commande comme combinaison linéaire de l'erreur et de la somme des erreurs du système, on arrive à obtenir un asservissement avec une erreur statique finale nulle. La formulation d'un tel régulateur est commande = Kp * erreur + Ki * somme(erreurs). Cette formulation fait intervenir le proportionnel et l'intégrateur en parallèle (commande = erreur + intégrale de l'erreur). Une autre formulation du régulateur PI peut être trouvé écrivant : variation de la commande = intégrale de ( la dérivé de l'erreur + l'erreur).

Ainsi, la formule commande = Kp * erreur + Ki * somme(erreurs) se transforme en commande(k) = commande(k-1) + Kp * variation(erreur) + Ki * erreur

C'est cette seconde formulation que l'on utilisera pour concevoir notre système flou. Ainsi, on a :

 \left\{ \begin{array}{l} u(k) = u(k-1) + \Delta u \\ \Delta u = K_p. \Delta e + K_i.e\\ e = c-y \\ \Delta e = e(k) - e(k-1)\end{array} \right.

Avec :

  •  u(k) : la commande à l'instant k
  •  \Delta u : la variation de la commande
  •  e : l'erreur (e(k), l'erreur à l'instant k)
  •  \Delta e : la variation de l'erreur (e(k) - e(k-1))
  •  c : la consigne à respecter
  •  y : la mesure de la réponse du système à la consigne donnée

On voit bien que tout ce que l'on a à faire, c'est trouver la variation de la commande à appliquer à chaque instant en fonction de l'erreur et de sa variation. L'utilisation d'un système flou va nous permettre de ne pas nous soucier des coefficients Kp et Ki qui seront automatiquement déterminés en fonction des réglages que l'on aura fait sur notre système flou.

II Les variables linguistiques

Les données que l'on a en entrées sont l'erreur et la variation de l'erreur. Chacune de ses entrées sera représentée par trois variables linguistiques. (erreur_négative, erreur_nulle, erreur_positive, variation_erreur_négative, variation_erreur_nulle et variation_erreur_positive).

Les fonctions d'appartenances sont de simples triangles ou fonctions linéaires :

Ici, on devra fixer E et \Delta E des fonctions d'appartenances par essais/erreurs en fonction du système.

Enfin, pour la sortie, on choisira trois variables linguistiques représentant la variation de la commande (variation_commande_négative, variation_commande_nulle, variation_commande_positive). Les fonctions d’appartenances sont représentées ci-dessous :

De même que pour les fonctions d'appartenances des variables linguistiques d'entrée, \Delta U sera à déterminer expérimentalement.

III Les règles d'inférences

Il est temps maintenant de déterminer les divers règles à entrer au système. Comme il y a deux données d'entrées à trois variables linguistiques chacune, il y aura donc au maximum 3^2=9 règles d'inférences. Ces neuf cas sont représentés schématiquement ci-dessous :

Cas un :

Dans ce premier cas, l'erreur est positive, ce qui veut dire que la réponse est inférieure à la consigne et la variation de l'erreur est nulle, ce qui veut dire que la réponse n'évolue pas. Dans ce cas, pour que la réponse atteigne la consigne, il faut augmenter la commande. La variation de la commande sera donc positive.

Cas deux :

A l'inverse, ici la réponse est supérieure à la consigne et n'évolue pas au cours du temps. Il faut donc diminuer la commande pour que la réponse atteigne la consigne. La variation de la commande est donc négative.

Cas trois :

Dans ce cas, la réponse n'évolue plus et vaut exactement la consigne. Dans ce cas-là, le système est asservit et il ne faut donc plus toucher à la commande. La variation de la commande est nulle.

Cas quatre :

Ici, la réponse est inférieure à la consigne, mais plus le temps passe et plus elle se rapproche de celle-ci. Il ne faut donc pas toucher à la commande. La variation de la commande sera nulle.

Cas cinq :

Dans ce cas-là par contre, la réponse est supérieure à la consigne (erreur négative) et elle continue à augmenter (donc à s'éloigner de la réponse). Ici, il faut diminuer fortement la commande. La variation de la commande sera donc négative.

Cas six :

L'erreur est nulle dans ce cas. Par contre, la réponse à tendance à vouloir dépasser la consigne. Il faut donc diminuer la commande. La variation de la commande est négative.

Cas sept :

Ici la réponse est bien en dessous de la consigne (erreur positive) et celle-ci diminue (variation de l'erreur négative). Il faut augmenter fortement la commande. La variation de la commande sera donc positive.

Cas huit :

Dans ce cas, la réponse est au-dessus de la consigne, mais elle tend à se rapprocher de celle-ci. Il ne faut donc pas toucher à la commande. La variation de la commande est nulle.

Cas neuf :

Enfin, dernier cas. La réponse est égal à la consigne, mais elle tend à diminuer. Pour contrer cela, il faut augmenter la commande. La variation de la commande sera positive.

Voilà. On a donc nos neuf règles prêtes à être utilisés !

  • SI erreur positive ET variation_errreur nulle ALORS variation_commande positive
  • SI erreur négative ET variation_errreur nulle ALORS variation_commande négative
  • SI erreur nulle ET variation_errreur nulle ALORS variation_commande nulle
  • SI erreur positive ET variation_errreur positive ALORS variation_commande nulle
  • SI erreur négative ET variation_errreur positive ALORS variation_commande négative
  • SI erreur nulle ET variation_errreur positive ALORS variation_commande négative
  • SI erreur positive ET variation_errreur négative ALORS variation_commande positive
  • SI erreur négative ET variation_errreur négative ALORS variation_commande nulle
  • SI erreur nulle ET variation_errreur négative ALORS variation_commande positive

IV Réglage et amélioration du régulateur flou

Afin de tester ce système, vous devrez choisir les opérateurs logiques et la méthode de défuzzification à utiliser. Une fois ces paramètres fixés, vous pourrez chercher les valeurs de E, \Delta E et  \Delta U des fonctions d'appartenances afin de trouver le réglage qui correspond le mieux à votre cahier des charges.

Afin d'améliorer ce régulateur, vous pouvez :

  • Changer la forme des fonctions d'appartenances
  • Rajouter des variables linguistiques en entrée
  • Rajouter des variables linguistiques en sortie
  • Rajouter ou modifier les règles d'inférences

V Le régulateur PID flou

Maintenant que l'on a vu le fonctionnement d'un régulateur de type PI, je vais toucher deux mots sur le régulateur PID. Dans l'article Implémenter un PID sans faire de calculs, on a vu qu'un PID classique s'écrivait u = K_p . e + K_i . \int e + K_d . \Delta e. Sur le même principe que pour le régulateur PI, on peut réécrire cette équation afin de mettre l'intégrateur en série plutôt qu'en parallèle. Ce qui nous donne u = \int \left( K_p . \Delta e + K_i . e + K_d . \Delta^2 e \right) soit  u(k) = u(k-1) + \Delta u avec \Delta u = K_p . \Delta e + K_i . e + K_d . \Delta^2 e.

On se rend compte que le principe pour créer un PID flou est le même que pour le régulateur PI mis à part que l'on rajoute l'information dérivée seconde de l'erreur. Les variations de la variation de l'erreur seront ainsi à prendre en compte. Le nombre de règle à dresser sera donc plus importante.

3 commentaires à “Exemple de système flou : un régulateur PI flou”

  1. Bonjour,

    Je cherche a transformer mon régulateur flou à une équation simple comme : commande = K_erreur * erreur + K_derive_erreur * derive_erreue. pour diminue la puissance de calcule de µcontroleur à 8bit; sachent que la surface de lois sur Matlab est linéaire donc cette solution est possible par contre je ne vois pas comment faire autrement comment déterminer les deux gain (K_erreur et K_derive_erreur).

    Cordialement,

    • Bonjour,

      Si tu connais les caractéristiques précises de ton moteur, tu peux donc le modéliser mathématiquement et en déduire les coefficients qui permettront le meilleur compromis stabilité / rapidité.

      Dans le cas général, il faut les déterminer à la main, par essais/erreurs.

      As-tu lu ces articles ?
      Le premier rappelle le principe d'un PID
      Le second est un exemple d'implémentation du PID pour asservir en vitesse un moteur

  2. je cherche comment appliquer un PI fou a une machine asynchrone ,je ss persdue,si vous pouvez m'aidez svp?

Laisser un commentaire

(required)

(required)

Vous pouvez utiliser ces tags et attributs HTML&nsbp;: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>

© 2011-2012 Ferdinand Piette