Sur beaucoup de site sur le web, lorsque l'on trouve un article parlant de la régulation PID, on se heurte souvent à des fonctions de transfert et à des équations dans le domaine de Laplace. Alors implémenter un PID est-il impossible sans avoir une base solide en mathématiques ? Heureusement non, loin de là. Outre l'approche mathématiques, le PID peut très bien s'expliquer de façon intuitive "avec les mains". Le but de cet article est justement d'essayer d'expliquer comment marche une régulation PID sans entrer dans les calculs ni sans utiliser les fonctions de transfert du système et autres équations quelque peu cabalistiques pour les non-initiés.

Asservir la vitesse d'une voiture "à la main"

Imaginez que vous conduisez votre voiture sur l'autoroute et que vous souhaitez stabiliser votre vitesse à 130 km/h pil-poil ! Dans la pratique, vous y arriverez sans trop de problèmes. Le but de cet exemple est d'essayer de comprendre comment votre esprit arrive à réguler votre vitesse intuitivement.

Règle 1 :

Tout d'abord, la chose la plus intuitive que vous faites lorsque vous voulez rouler à une certaine vitesse sur l'autoroute, c'est de vous dire : " plus je roule lentement par rapport à la vitesse voulu et plus j’appuie sur la pédale d'accélération ". La pression sur l'accélérateur est donc proportionnelle à l'erreur que vous commettez, c'est-à-dire, proportionnelle à la différence entre la vitesse voulue et la vitesse réelle.

Avec cette méthode, pas de problème. Vous êtes à 50 km/h, vous appuyez sur le champignon ! Votre vitesse augmente et se rapproche de la vitesse limite. Vous exercez une pression de moins en moins forte. Une fois que la vitesse atteint 130 km/h, vous avez réussi ! L'erreur est nulle, vous lâchez donc l'accélérateur. Manque de bol, comme l'accélérateur est complètement lâche, la voiture commence à ralentir. Vous recommencez donc à appuyer un peu sur l'accélérateur, puis de plus en plus au fur et à mesure que la voiture ralenti. Au final, vous arrivez à stabiliser votre vitesse à une vitesse inférieure à celle que vous avez choisi, disons 120km/h.

Règle 2 :

C'est alors que vous vous dites : " Zut ! Je n'arrive pas à atteindre la vitesse voulue, il faut que je rajoute une règle supplémentaire à mon raisonnement ! ". Du coup, vous décidez que si votre vitesse reste longtemps sous l'objectif, vous accélérez de plus en plus fort. Vous décidez donc qu'en plus d'accélérer proportionnellement à l'erreur commise, vous allez aussi mémoriser cette erreur au cours du temps. Plus l'erreur globale est importante et plus vous accélérez.

Ainsi, lorsque vous stabilisez votre vitesse à 120km/h, l'erreur globale augmente et vous vous mettez à appuyer de plus en plus fort sur l'accélérateur jusqu’à atteindre 130km/h... et le dépasser ! En effet, arrivé à 130km/h, l'erreur globale est positive, donc vous continuez à appuyer sur l'accélérateur. Arrivé au-delà de 130km/h, l'erreur est négative et fait donc diminuer d'erreur globale. Vous levez donc le pied de l'accélérateur de plus en plus fortement jusqu’à retourner à 130 km/h. Arrivé à 130km/h, rebelote, l'erreur est passé en négatif et vous continuez à décélérer... ainsi de suite jusqu'à finalement arriver à vous stabiliser à 130km/h après de multiples oscillations.

Règle 3 :

Arrivé à 130km/h, vous vous dites : " ça y est, j'y suis ! Mais je n'ai pas été très efficace... Ne faudrait-il pas rajouter une troisième règle afin d'être plus performant ? ". C'est alors que vous décidez d'anticiper votre vitesse. Plus votre vitesse se rapproche de la vitesse optimale, moins vous accélérez et moins elle se rapproche de la vitesse optimale, plus vous accélérez !

Ainsi, si vous vous rapprochez rapidement des 130 km/h, vous vous empressez de lever le pied afin de ne pas dépasser les 130 trop brutalement. Ainsi, vous réduisez les oscillations et vous vous stabilisez rapidement à la vitesse souhaitez !

Voilà, vous avez intuitivement fait une régulation de type PID ! 🙂

Implémentation d'un PID sur un robot

A partir de cet exemple, on voit qu'un asservissement PID n'a rien de très compliqué ! Tout ce que l'on a à faire, c'est de mémoriser l'erreur, la somme des erreurs et la différence de l'erreur courante avec l'erreur précédente.

Le régulateur proportionnel (P : première règle)

La commande de ce régulateur est proportionnelle à l'erreur.

commande = Kp * erreur

Kp est le coefficient de proportionnalité de l'erreur à régler de façon manuelle.

Le régulateur proportionnel intégral (PI : première et seconde règle)

La commande de ce régulateur est proportionnelle à l'erreur, mais aussi proportionnelle à l'intégrale de l'erreur. On rajoute donc à la commande généré par le régulateur proportionnel, la somme des erreurs commises au cours du temps.

commande =  Kp * erreur + Ki * somme_erreurs

Ki est le coefficient de proportionnalité de la somme des erreurs. Il faut aussi le régler de façon manuelle.

Le régulateur proportionnel dérivé (PD : première et troisième règle)

La commande de ce régulateur est proportionnelle à l'erreur, mais aussi proportionnelle à la dérivée de l'erreur. La dérivée de l'erreur correspond à la variation de l'erreur d'un échantillon à l'autre et se calcule simplement en faisant la différence entre l'erreur courante et l'erreur précédente (c'est une approximation linéaire et locale de la dérivée).

commande = Kp * erreur + Kd * (erreur - erreur_précédente)

Kd est le coefficient de proportionnalité de la variation de l'erreur. Il faut régler ce coefficient manuellement.

Le régulateur proportionnel intégrale dérivé (PID : première, seconde et troisième rèlge)

Ici, la commande est à la fois proportionnelle à l'erreur, proportionnelle à la somme des erreurs et proportionnelle à la variation de l'erreur.

commande = Kp * erreur + Ki * somme_erreurs + Kd * (erreur - erreur_précédente)

Vous devez donc faire une mesure sur votre système pour pouvoir calculer l'erreur et ainsi appliquer le PID. Cette mesure est à faire régulièrement à une certaine fréquence d'échantillonnage.

Tous les x millisecondes, faire :
    erreur = consigne - mesure;
    somme_erreurs += erreur;
    variation_erreur = erreur - erreur_précédente;
    commande = Kp * erreur + Ki * somme_erreurs + Kd * variation_erreur;
    erreur_précédente = erreur

Comment régler les coefficients d'un PID ?

Le réglage des coefficients Kp, Ki et Kd d'un PID peut se faire "à la main" par essais/erreurs. Tout d'abord, sachez qu'il ne sert à rien de vouloir régler les trois coefficients en même temps ! Il y a trop combinaisons possibles et trouver un triplet performant relèverait de l'exploit. Il vaut mieux y aller par étape.

  • Tout d'abord, il faut mettre en place un simple régulateur proportionnel (les coefficients Ki et Kd sont donc nuls). Par essais/erreurs, il faut régler le coefficient Kp afin d'améliorer le temps de réponse du système. C'est-à-dire qu'il faut trouver un Kp qui permette au système de se rapprocher très vite de la consigne tout en faisant attention de garder la stabilité du système : il ne faut pas que le système réponde très vite tout en oscillant beaucoup !
  • Une fois ce coefficient réglé, on peut passer au coefficient Ki. Celui-là va permettre d'annuler l'erreur finale du système afin que celui-ci respecte exactement la consigne. Il faut donc régler Ki pour avoir une réponse exacte en peu de temps tout en essayant de minimiser les oscillations apportées par l'intégrateur !
  • Enfin, on peut passer au dernier coefficient Kd qui permet de rendre le système plus stable. Son réglage permet donc de diminuer les oscillations.

En général, pour régler ces coefficients, on donne au système une consigne fixe (exemple : pour un moteur : tourne à 3 tours par seconde) et on observe la réponse du système (exemple : l'évolution du nombre de tours par seconde du moteur au cours du temps). le graph résultant possède donc cette forme :

Image tirée de Wikipédia

Le PID parfait n'existe pas, tout est une question de compromis. Certaines applications autoriseront un dépassement afin d'améliorer le temps de stabilisation, alors que d'autres ne l'autoriseront pas (exemple, contrôler un stylo pour écrire sur une feuille. S'il y a dépassement dans le PID, le stylo traversera la feuille). Tout dépend donc du cahier des charges. Chacun des coefficients à un rôle à jouer sur la réponse à une consigne :

  • L'erreur statique, c'est l'erreur finale une fois que le système est stabilité. Cette erreur doit être nulle. Pour diminuer l'erreur statique, il faut augmenter Kp et Ki.
  • Le dépassement, c'est le rapport entre le premier pic et la consigne. Ce dépassement diminue si Kp ou Ki diminuent ou si Kd augmente.
  • Le temps de montée correspond au temps qu'il faut pour arriver ou dépasser à la consigne. Le temps de montée diminue si Kp ou Ki augmentent ou si Kd diminue.
  • Le temps de stabilisation, c'est le temps qu'il faut pour que le signal commette une erreur inférieure à 5% de la consigne. Ce temps de stabilisation diminue quand Kp et Ki augmentent.

Pour vous donner une petite idée de la valeur des coefficients lors de vos premiers essais, vous pouvez regarder du côté de la méthode Ziegler–Nichols. Cette méthode permet de déterminer Kp, Ki et Kd en fonction de votre cahier des charges.

Attention, les coefficients Ki et Kd dépendent de la fréquence d'échantillonnage du système ! En effet, l'intégrateur fera la somme des erreurs au cours du temps ! Si on échantillonne deux fois plus vite, on sommera deux fois plus d'échantillons. Du coup, le coefficient Ki devra être divisé par 2. A l'inverse, pour le dérivateur, si on double la fréquence d'échantillonnage, il faudra doubler le coefficient Kd afin de garder les mêmes performances du PID. Plus la fréquence d'échantillonnage est élevé et plus le PID sera performant. (En effet, plus on échantillonne souvent et plus l'intégration et la dérivée seront précises).

Voilà, vous savez maintenant comment marche un PID et comment trouver les différents coefficients ! Il ne vous reste plus qu'à tester ce régulateur sur vos différents robots 😉
Sachez aussi qu'il est possible de déterminer automatiquement les coefficients d'un PID grâce à des algorithmes génétiques par exemple. Cela vous évitera ainsi de passer trop de temps à les régler manuellement !

Pour voir une implémentation réelle d'un PID numérique, regardez cette article.

45 commentaires à “Implémenter un PID sans faire de calculs !”

  1. Bonjour Monsieur.

    Je voudrais vous remercier pour l'aide et les explications apportées sur la compréhension du PID numérique.
    Je ne suis plus tout jeune, bientôt 65 ans et je m'intéresse à l'électronique depuis l'âge de 10 ans, j'ai donc commencé avec les tubes.
    Je ne suis qu'un autodidacte et donc limité par rapport à vrai électronicien et encore bien plus par rapport à votre bagage.
    Cependant, je fais de la régulation de vitesse mais en analogique, les valeurs des composants notamment pour le "PI" ne sont pas calculés mais ajusté par l'observation des résultats à l'oscilloscope.
    Je voulais passer à la régulation par microcontrôleur (je suis sur AVR d'Atmel, Atmega 8535, Atmega 32 et pour un projet en cours d'éolienne, un Atmega 1284) et j'étais bloqué par l'application de "I" et éventuellement de "D".
    Grâce à vous, je vais pouvoir m'aventurer en régulation par uC.

    Je reviendrai sur votre site pour apprendre d'avantage.
    Encore tous mes remerciements.

    Cordialement, Léon.

  2. Je sors d'un baccalauréat en "informatique et systèmes, finalité Automatique" où un de nos cours principal est la régulation. Je trouve que le cours devrait commencer par ton article. C'est clair et ça aide vraiment à bien visualiser ce qu'il se passe. Merci pour ce partage !

  3. Salut! très bon article de vulgarisation, c'est simple et intéressant, merci beaucoup!
    Par contre l'image tirée de Wikipédia ne s'affiche pas chez moi...

  4. Bonjour,
    Chapeau pour cette vulgarisation du régulateur PID!
    la comparaison avec l'accélérateur la rend beaucoup plus clair et compréhensible!
    cela fait quelques temps que je cherche à quoi cela correspond exactement, et me voila servi!
    bonne continuation!

  5. Très bon article pour introduire le sujet.

    Plus qu'a tester des Kx ...

    Pour information, tu as quelques fautes :
    Dans ton exemple d'implémentations : commande = Kp * erreur + Ki * somme_erreurs + Ki * variation_erreur; c'est Kd.
    Et dans ta remarque sur la fréquence d’échantillonnage, "Attention, les coefficients Ki et Kp", c'est aussi Kd au lieu de Kp.

    Concernant la fréquence d’échantillonnage, si la valeur régulée varie peu , en augmentant la fréquence, la dérivée est quasiment lisse. Du coup soit PI au lieu de PID, soit réduire l'importance de la dérivée, soit réduire la fréquence d’échantillonnage.
    Y a-t-il une autre solution ?

    • Merci pour ces corrections !

      Si on augmente la fréquence, la valeur de la dérivé ne change pas. Ce qui change (et qui tend vers 0 pour une fréquence tendant vers l'infini), c'est la différence entre l'échantillon courant et le précédent.

      La dérivé est calculé en divisant cette différence par le pas d'échantillonnage (qui est implicitement inclut dans Kd).
      Donc si on augmente la fréquence d'échantillonnage, il faut augmenter proportionnellement le coefficient Kd ! On ne réduit donc pas l'importance de la dérivé. Celle-ci aura toujours autant d'importance.

      • Dans un domaine continu oui, mais pas dans un domaine discret.

        Je m'explique : j'ai un capteur de température, il a une précision de 0,1 ° mettons.
        si j'augmente ma fréquence, au bout d'un moment, mes valeurs lues seront "en escalier" alors que globalement j'ai une augmentation ou une diminution. De ce fait je vais avoir un terme dérivatif nul la plupart du temps et une fois de temps en temps Kd * 0,1.

        Vous voyez ce que je veux dire ?

        • Oui, je vois ce que vous voulez dire.

          Du fait de la quantification du système, on ne peut pas mesurer une faible variation. Du coup, lorsque la variation sera suffisante dans le monde continue, on verra un "saut" dans le monde discret.

          Je n'avais pas songé à ce problème et ne vois pas de solutions. Il faudrait y réfléchir plus en détail.

  6. Merci Ferdinand pour cet exposé simple et clair !
    En espérant que je serai à la hauteur pour en tirer parti...

  7. Bonjour et merci pour ces instructions.En fait j'ai un petit soucis pour limiter un dépassement je souhaiterais que lorsque j approche de ma consigne je commence à fermer ma vanne vapeur car en été j ai une faible inertie sur ma boucle fermée

    • Bonjour,

      La façon de régler le PID est le même, quelque soit le système.
      S'il y a trop de dépassement, il faut réduire Ki.
      Voir, augmenter Kd afin d'anticiper les choses.

      Bonne soirée

  8. Bonjour,
    Dans votre article on trouve ceci:
    ___________________________________________
    Tous les x millisecondes, faire :
    erreur = consigne - mesure;
    somme_erreurs += erreur;
    variation_erreur = erreur - erreur_précédente;
    commande = Kp * erreur + Ki * somme_erreurs + Kd * variation_erreur;
    erreur_précédente = erreuruy
    ___________________________________________

    Ne manque'il pas qqc au niveau de la ligne "sommes_erreurs += erreur" ?
    Je veux dire après le "+" ?
    Ne serait-ce pas "sommes_erreurs + erreur précédente = erreur" ou qqc comme ça ?

    Par avance merci de votre réponse et en tout les cas, merci pour cet article simple et limpide.

  9. Bonjour Ferdinand
    Merci pour cet article qui m'a permis de comprendre un peu mieux la régulation PID (l'article de wiki est trop ardu pour moi). Ceci dit, pourrais-tu éclairer ma lanterne. Intuitivement, la commande que tu définis comme
    commande = Kp * erreur + Ki * somme_erreurs + Kd * (erreur - erreur_précédente)
    est bien en réalité la "correction" à apporter au système pour qu'il corresponde au mieux à ta consigne non ? Si oui, alors cette commande au fil du temps, avec les erreurs qui s'additionnent dans le terme "Ki * somme_erreurs" , ne peut que croitre ? Or y'a un truc qui m'échappe, c'est qu'en principe, plus le temps avance, plus cette correction doit diminuer non ? Merci de tes éclaircissements car je suis un peu perdu.
    Emmanuel

    • Bonjour,

      La "commande" correspond bien à la commande à appliquer au système et non au terme de correction.
      "Ki * somme_erreurs" n'augmente pas forcement. Il se peut que l'erreur soit négative 😉

      Donc si ton système est au repos et que tu lui appliques une consigne possitive, l'erreur sera > 0, la somme des erreurs augmentera avec le temps.
      Lorsque le système dépassera la consigne, alors l'erreur est < 0 et la somme des erreurs commencera à diminuer. Ferdinand

      • Bonjour,
        En fait vous avez tous les deux raison.
        Ce que Ferdinand explique est juste, et les doutes de M4nux sont fondés.
        Ce qu'il faut comprendre c'est que la commande est la dérivée de l'évolution du système. Sur un moteur ou un système de chauffage, la commande rajoute (ou pas) de l'énergie et le système l’intègre.
        C'est une intégration mécanique (ou thermique) et non numérique.
        Ainsi si un moteur c'est stabilisé avec une erreur nulle et bien la commande va devenir nulle... le moteur va un petit peu ralentir et a ce moment la, la commande va renvoyer un peu de courant.

        J'ai eu les mêmes doutes que M4nux car j'utilise les PID dans des simulations numériques (comme par exemple des simulations d'ABS), et dans ce cas la nous devons "dans le code" considérer que cette commande est un delta de commande et garder la commande dans une autre variable.

        Sinon un grand merci pour cet article; je l'ai conseillé a des gens qui ont du mal avec les PID 🙂

        Cordialement.

      • Oubliez ma réponse.
        c'est bien le terme "Ki * somme_erreurs" qui permet d'obtenir une commande qui se stabilise autour d'une valeur moyenne et donc ne converge pas à zero quand le système atteint la consigne.

        Cela revient a peu prés à la même chose que si cette commande n'était q'une variation de commande et si seul Kp était utilisé(c'est d'ailleurs comme ça que je faisais la majorité de mes PID quand je voulais utiliser un minimum de multiplications).

        en gros, ça donne ça:

        commande = 0
        Tous les x millisecondes, faire :
        erreur = consigne - mesure;
        variation_commande = CoefQuiVaBien * erreur ;
        commande = commande + variation_commande

        ça a l'avantage de remplacer deux multiplications par une multiplication + une addition (sur certains systèmes ça compte) , mais ça prive d'une souplesse de réglage qu'on avais avec Kp et Ki séparés, car ça revient à un Kp = Ki = CoefQuiVaBien

        Vous aviez fait le tour de la question.

        Cordialement

  10. Bonjour !

    Bravo pour le partage (toujours du succès 2 ans plus tard 😉
    et félicitations pour la clarté ! merci

    Pour approfondir ensuite le sujet, il y a un article de vulgarisation qui met en avant les différences de régulation entre 3 systèmes (moteur, positionnement de précision, thermique) en anglais ici PID-Without-a-PhD

  11. Bonjour,
    Merci pour cette explication, qui m'a rafraîchit la mémoire. D'accord avec l'élève qui dit qu'on devrait commencer la matière avec cet article.

  12. Coucou ! Je te connais...Ailleurs...
    Si tu en a d'autres...des explications aussi lumineuses. Et ban, on est toujours preneurs.
    C'est si agréable de comprendre...Gros: Merci !

  13. Merci pour ce tuto... c'est exactement ce que je cherchais pour réguler le ventilateur de mon système de chauffage qui pulse de l'air dans ma salle de bain

  14. Bonjour Ferdinand,

    Merci pour le partage de ton travail et ta générosité.
    Je commençais à écrire un TP pour mes étudiants sur une régulation PID de moteur avec Arduino: ton projet tombe à pic.
    Lorsque j'ai fini d'écrire mon TPet que celui-ci a tourné, je t'envoie mon .doc: échange de bon procédé. 😉
    Je te souhaite une bonne journée, à bientôt,
    Lionel Fillon.

  15. Bonjour
    Je suis du même avis que tous ici pour la clareté et l'interet de cet article. Merci!

    Je suis arrivé ici car je cherchais des informations pour modifier de paramètres de régulation sur un PID. Je travail sur un process qui chauffe un produit dans une cuve grâce à une double envellope où circule soit de l'eau chauffer soit refroidie.
    Il est très difficile d'obtenir une température produit suffisament stable.
    Le premier problème, c'est que le régulateur ne commence à inverser les vannes de chaud/froid que lorsque la T° de la cuve arrive à la consigne. L'inertir présente dans l'eau de la double envellope continue dont de modifier la température produit le temps que le cycle s'inverse.
    Je pense qu'intervenir sur le D permettrait de régler cela.
    Etes-vous en accord avec mon idée? Avez-vous d'autres solutions?
    Merci
    Manu

  16. slt ,je suis vraiment emerveiller de ton article ,parceque cela ma permis d'enlever certaine embiguites que j'avais sur le regulateur PID

  17. Une précision,
    de plus en plus Kd est appliqué uniquement à la variation de la mesure et non pas à l'écart mesure-consigne, et ce, afin d'éviter un gros accoup sur la sortie (accélérateur) en cas de changement de consigne...

  18. Bonsoir,

    Testé avec de bon résultat sur une régulation de niveau d'une cuve avec un automate industriel,
    avec l'avantage de pouvoir voir comment se comporte les paramètres P I D contrairement
    au régulateur intégré (C'est beaucoup plus facile a régler ainsi)

    Cela permet de bien comprendre le comportement du régulateur dans les différentes phases
    de régulation

  19. Bonjour

    je travaille sur un projet fin d’étude qui est intitule d'enregistrer d’événement sur un reseau triphase, mon probleme que je vais utiliser carte arduino et je choisis la methode PLL pour detecter la perturbation dans le reseau ,j'ai le programme mais je ne peux pas l'inserer sur la carte parce que je ne comprends pas la programmation.pouvez vous me donner une solution ou des conseils peux m'aider à resoudre ce probleme
    contatez moi sur mon email
    merci d'avance

  20. Article génial!!! La comparaison du début est très représentative de la régulation.

  21. Merci beaucoup,
    article explicite j'adore ! je suis en plein dedans ca m'a vraiment éclairé 🙂

  22. Merci bien pour le calcul !!

    J'ai testé le code sur arduino. Je ne trouve pas une régulation "idéale".
    Donc, j'ai placé avec une résistance 10ohm chauffant une thermistance.
    La puissance est réglée par pwm sur une mosfet régulant la résistance.

    Je calibre Kp : OK
    Je calibre Ki : là, on monte très haut au dessus de la consigne et on revient toujours se stabiliser en dessous.
    Je rajoute Kd au précédent système : il rajoute de la souplesse mais garde les défauts des résultats précédents.

    J'ai donc gardé Ki à 0. Je reprends un Kp qui marche assez bien et j'ai simplement élevé la température de consigne "virtuelle" afin que la température réelle se stabilise à la consigne souhaitée.
    On a donc de la sorte le "remplacement" de la fonction de Ki.
    Ensuite je rajoute un Kd.

    Je reste sur une courbe qui monte, qui dépasse la température de consigne de 3°C environs, et vient se stabiliser.

    Si d'autres font des essais, je serais curieux de voir vos résultats !

    Merci !
    Et bonne continuation 😉

  23. Super ! Merci Beaucoup !!!

  24. Franchement TIP TOP ! ça fait deux ans que je fait de l'auto dans le cadre de mes études et je ne comprends que maintenant. Bravo ! C'est grâçe a des gens comme vous que le monde avance !

  25. Superbe esprit de synthèse et de pédagogie, je vous remercie.

    Je vais travailler sur les régulations de mon installation de biogaz de façon un peu plus raisonnée.
    Le raisonnement est un peu plus délicat quand on a plusieurs régulations PID à gérer et pour l'instant, je n'ai pas la main sur le paramètre Kd

  26. Super. Je prépare un TP sur la régulation PID et tu as déjà tout fait.. ou presque! J'aimerai utiliser ce que tu as fait... avec ton consentement.
    Merci beaucoup pour ce partage.

  27. Super article, il est parfois difficile de visualiser certaines choses, heureusement que des gens comme toi existent.

  28. Bonjour,
    article très très intéressant !!!
    Merci beaucoup !!!

    Je suis face à un process très lent et je souhaiterais aller plus loin et programmer en C un prédicteur de Smith...
    Avez-vous une idée de comment le programmer 🙂 🙂

    Merci pour vos conseils !!!
    Julien

  29. bonjour
    super article bien expliquer (merci)
    j ai une question : je veux implémenter une autre régulation autre que le pid dont j ai besoin de calculer la dérive et l’intégral du signal,
    pour calculer la dérive il faut qu'on devise par le pas et de mémé pour l’intégral ?

  30. Bonjour a tous. Je suis vraiment émerveillé après la lecture de l'article ainsi que vos differentes discussions. Moi je travail en ce moment sur un project de regulation de tem'expliquempérature avec un capteur lm35 pid. J'ai un souci majeur sur la communication avec la sorti. Je m'explique. En effect je doit modifié la consigne a tout instant, le circuit de puissant est formé du triac et des lampes chauffante. Je ne parvient pas a faire stabilité la température ambiante d'un box par example a celle de la consigne. Mon program prend en compte les parametres P, I et D. SVP si quelqu'un a une idee ou a deja fait cela, son aide sera la bien venu. Je programme en C dans le ccs. Merci

  31. Oui merci beaucoup + parlant 🙂

  32. Bonjour
    Je dois faite une régulation de température sur un circuit d'huile avec une vanne 3 voies et un sonde pt100.J'utilise une fonction pid sur un automate programmable et la vanne est réglable en position sur une plage de 0 a 100% non pas par une sortie analogique mais en pilotant deux sorties tout ou rien ouverture et fermeture.Le problème c'est que je n'ais pas d'information de retour de la position de la vanne.Si la valeur de sortie du pid est par exemple de 70% ,comment fixer l'ouverture de la vanne a cette valeur?

  33. Tous ce qui disent super, c bon, merci tout est fait ce sont ceux qui n'ont pas compris l'asservissement

Laisser un commentaire

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=""> <s> <strike> <strong>

(required)

(required)

© 2011-2012 Ferdinand Piette