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.