Introduction.

Lorsque j'envoie la même commande à deux moteurs électriques identique, ils ne tournent pas à la même allure. Cela peut poser problème si le moteur contrôle la vitesse d'un véhicule autonome qui se déplace en pleine ville. Comment alors, puis je être sur de la vitesse de rotation de mes moteurs ?

L'asservissement.

L'asservissement est un mot un peux barbare pour dire que l'on contraint notre moteur à adopter et respecter une vitesse de rotation précise. Pour cela on utilise le retour des capteurs encodeurs intégré dans le moteur, et l’algorithme PID.

Le capteur encodeur.

Nous n'allons pas nous attarder sur le fonctionnement de ce capteur, ce que vous devez savoir c'est que lorsque l'arbre du moteur est en mouvement, l'encodeur génère un message électrique aussi appelé "tic" qui indique le mouvement du moteur et le sens de rotation.

Il y a différent type d'encodeur, mais le plus important est le nombre de "tic par rotation", c'est à dire combien l'encodeur génère t'il de "tic" lorsque l'arbre moteur effectue une rotation. Plus ce nombre est élevé, plus le capteur est précis.

Régularisateur PID.

Premièrement, le temps. Pour échantillonner notre mesures et effectuer l'asservissement il nous faut calculer la durer entre deux échantillonnage, pour cela il y a deux techniques : la première consiste à appliquer l'asservissent à intervalle de temps régulier en utilisant une fonction qui se lance tout les x ms. La deuxième méthode consiste à "chronométré" le temps entre deux lancement de la fonction d'asservissement (avantage ces que si le microcontrôleur et occupé a faire autre chose, il prendra en compte l'augmentation du temps échantillonnage dans le calcul.

Remarque: La fréquence d'échantillonnage est extrêmement importante, plus elle est élevé, plus l'asservissement sera précis, vous devez cependant vérifier que votre micro contrôler est assez puissant. J'ai obtenue de très bon asservissement avec des cadences d'environ 100hz.

Maintenant que nous avons notre temps échantillonnage, on récupère la distance de parcouru par le moteur durant cette interval de temps.

Dans notre cas, nous voulons que notre moteur effectue une rotation complète par seconde Donc nous savons combien de tics il doit effectué par seconde et grâce à un produit en croix, nous pouvons déterminer le nombre de tics qu'ils dois effectué durant le temps échantillonnage.

commandTicPerSample = commandRotationRatePerSec * EncoderTicPerRotation * timeSample

On débute notre PID avec le P, il consiste à calculer l'erreur entre ce que notre consigne attendé en nombre de tics et la réalité obtenue.

errorMotor = commandTicPerSample - counterTicMotor;

Ensuite le I, nous allons faire la somme total des erreurs à chaque asservissement.

errorSumMotor += errorMotor;

enfin le D, nous allons faire la différence entre l'erreur obtenue durant l'asservissement actuel et le précédent.

errorDeltaMotor = errorMotor - errort1Motor;

Déja me dirais vous ? Oui, ce n'ai pas compliqué, maintenant il suffis de reunnir les 3 valeurs que nous avons préalablement calculer, dans une seul formule pour calculer la commande à mon moteur.

commandPwmMotor = kP*errorMotor + kI*errorSumMotor + kD*errorDeltaMotor;

Les variables Kp Ki et Kd permettent de régler l'asservissement, je décris plus loin dans l'article comment ils influents sur le résultat final.

Dans mon cas, pour faire tourner mon moteur, je dois lui envoyé un signal PWM compris entre 0 et 255. Cependant 99% du temps, la valeur généré par notre PID n'ai pas comprise dans cette intervalle. Pour palier à ce problème nous allons borné la commande, si elle est supérieur à 255 nous la ramènerons à 255 et si elle est inférieur à 0 nous la ramènerons à 0.

Code.

Le microcontrôleur que j'utilise est un ESP32 avec une cadence de 400mHz, ce qui me permet d'obtenir une fréquence échantillonnage élevé.

#include <SimpleTimer.h>
SimpleTimer timer;

/* Hardware variable. */
const int pwmMotor =  15;            
const int frontMotor = 13;
const int backMotor = 4;
const int pinEncoderA1Motor = 35;
const int pinEncoderA2Motor = 19;
const double EncoderTicPerRotation = 2096;

/* Encoder variable. */
double counterTicMotor = 0;

/* PID variable. */
double errorMotor = 0;
double errorSumMotor = 0;
double errorDeltaMotor = 0;
double errort1Motor = 0;
double kP = 200;
double kI = 4;
double kD = 100;
double timeSample = 10;

/* Command variable. */
double commandRotationRatePerSec = 0;
double commandTicPerSample = 0;
double commandPwmMotor = 0;

void setup() {
  Serial.begin(115200);

  /* Setup Hardware, encoder sensor, and timer. */
  ledcSetup(0,4000,8);
  ledcAttachPin(pwmMotor, 0);
  attachInterrupt(pinEncoderA2Motor, new_Tic_Reception, RISING);
  pinMode(pinEncoderA1Motor, INPUT);
  timer.setInterval(timeSample, asservissement_PID);
  pinMode(frontMotor, OUTPUT);
  pinMode(backMotor, OUTPUT);

  /* Setup fixe command. */
  commandRotationRatePerSec = 1;
  commandTicPerSample = (commandRotationRatePerSec*EncoderTicPerRotation*timeSample)/1000;
  digitalWrite(frontMotor, HIGH);
  digitalWrite(backMotor, LOW);

}

void loop() {
  timer.run();
  delay(3);
}

void new_Tic_Reception(){
  if(digitalRead(pinEncoderA1Motor) == HIGH){
      counterTicMotor++;
    }
    else {
      counterTicMotor--;
    }
}

void asservissement_PID(){

  /* Calculation variable. */
  errorMotor = commandTicPerSample - counterTicMotor;
  errorSumMotor += errorMotor;
  errorDeltaMotor = errorMotor - errort1Motor;
  errort1Motor = errorMotor;

  /* Heart of PID. */
  commandPwmMotor = kP*errorMotor + kI*errorSumMotor + kD*errorDeltaMotor;

  if(commandPwmMotor > 255) commandPwmMotor = 255;
  if(commandPwmMotor < 0) commandPwmMotor = 0;

  /* Send command to my motor. */
  ledcWrite(0, cmdM);

  /* --- */
  if(errorSumMotor > 100) errorSumMotor = 100;
  if(errorSumMotor < -100) errorSumMotor = -100;
}

Test et paramétrage.

Normalement, la première fois qu'on choisis les valeurs Kp, Ki et Kd, le résultat est comment dire... Pas très satisfaisant. Cela est normal car ces valeurs ont une importance spécial et un impact bien précis.

Cette courbe représente le la vitesse de rotation en fonction du temps, comme vous pouvez le voir, elle ne colle pas vraiment avec la courbe 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.

Une fois le paramétrage améliorer, j'obtiens une courbe qui colle beaucoup plus avec la réalité.

Remarque, les valeurs de Ki et Kd dépendent de la fréquence d'echantillonnage, si elle augmente par 2, il faudra diviser par 2 Ki et Kd afin d'obtenir le même résultat.

Remarque, il se peut que votre moteur est un temps de réaction de votre moteur sois long, cela peut être du à la charge qu'il déplace, le rapport de réduction des engrenages ou la qualité de votre moteur, dans ce cas vous allez remarquer que durant les premiers moment de l'asservissement, le moteur tournera au maximum pendant quelque seconde, ce qui nuis énormément sur la qualité du PID. Cela est du à la somme total des erreurs, qui dans les premiers instant, augmente énormément car le moteur est quasiment à l’arrêt, du coup l’algorithme "rattrape" son retard en fessant tourner le moteur à plein régime. La solution que j'ai trouvé est de borné la valeur de la somme des erreurs. Cela fonctionne plutôt bien est améliore énormément mon PID.

Conclusion.

Le PID est une technique efficace pour contrôler son moteur, il est employé dans beaucoup de domaine comme la robotique et les véhicules autonome. Il existe des techniques mathématiques pour calculer les valeurs kp, ki et kd en fonction de votre cahier des charges mais elles sont plutôt complexe et n'offre pas un résultat qui mérite qu'on s'y attarde au début. La phase de paramétrage est essentiel afin d'adapter notre régularisateur PID.

J'espère avoir été le plus concis possible. N'hésitez pas à m'envoyer vos questions et remarque, je serai ravis de les lires!

Tutorial réalisé par Thomas Raynal.

Comment asservir simplement la rotation d'un moteur à l'aide d'un PID ?

Tsquared Robotics