Modifications

== Référence des commandes QTRSensor ==

== Référence des commandes QTRSensor ==

{{ambox|text=Les précédentes versions de la bibliothèque s'appelaient '''PololuQTRSensors''' mais il a été modifié en '''QTRSensors''' pour la différencier de la bibliothèque senseur QTR [https://www.pololu.com/docs/0J17 Arduino pour le Robot Orangutan et 3pi]. A part ce changement de nom de bibliothèque (et de classe), la nouvelle bibliothèque QTRSensors est fonctionnellement identique aux précédentes versions.}}

{{ambox|text=Les précédentes versions de la bibliothèque s'appelaient '''PololuQTRSensors''' mais il a été modifié en '''QTRSensors''' pour la différencier de la bibliothèque senseur QTR [https://www.pololu.com/docs/0J17 Arduino pour le Robot Orangutan et 3pi]. A part ce changement de nom de bibliothèque (et de classe), la nouvelle bibliothèque QTRSensors est fonctionnellement identique aux précédentes versions.}}

== Note d'usage ==

== Note d'usage ==

=== Calibration ===

=== Calibration ===

La bibliothèque propose la méthode '''calibrate()''' pour facilement calibrer les senseurs dans les conditions particulières qu'il va rencontrer. La calibration des senseurs peu permet de produire des lectures sensiblement plus fiable, ce qui aura pour effet de simplifier votre propre code par la suite. En conséquence, nous recommandons de réaliser une phase de calibration dans la routine d'initialisation de votre application.  

La bibliothèque propose la méthode '''calibrate()''' pour facilement calibrer les senseurs dans les conditions particulières qu'il va rencontrer. La calibration des senseurs peu permet de produire des lectures sensiblement plus fiable, ce qui aura pour effet de simplifier votre propre code par la suite. En conséquence, nous recommandons de réaliser une phase de calibration dans la routine d'initialisation de votre application.  

=== Contrôle PID ===

=== Contrôle PID ===

TLa valeur entière retournée par '''readLine()''' peu facilement être convertie la mesure de notre erreur de position pour les applications de suivit de ligne, comme démontré dans le précédent exemple de code. La fonction utilisée pour générer cette valeur de position/error est conçue pour être monotonique, ce qui signifie que la valeur change toujours dans la même direction au fur et a mesure que que les senseurs croisent la ligne. Cela en fait une grandeur utile pour réaliser un contrôle PID.

TLa valeur entière retournée par '''readLine()''' peu facilement être convertie la mesure de notre erreur de position pour les applications de suivit de ligne, comme démontré dans le précédent exemple de code. La fonction utilisée pour générer cette valeur de position/error est conçue pour être monotonique, ce qui signifie que la valeur change toujours dans la même direction au fur et a mesure que que les senseurs croisent la ligne. Cela en fait une grandeur utile pour réaliser un contrôle PID (''Proportionnel Intégram Dérivé'').

Expliquer la nature du contrôle PID va au delà des objectifs de ce document, mais [https://fr.wikipedia.org/wiki/R%C3%A9gulateur_PID wikipedia offre un bon article] sur le sujet.

Expliquer la nature du contrôle PID va au delà des objectifs de ce document, mais [https://fr.wikipedia.org/wiki/R%C3%A9gulateur_PID wikipedia offre un bon article] sur le sujet.

Le code suivant est un exemple très simple de contrôleur PD pour suivit de ligne (le terme intégrale "I" d'un régulateur PID n'est habituellement pas nécessaire dans le cadre d'un suivit de ligne). Les valeurs des différentes constantes PID (ou PD dans le cas présent) est généralement spécifique à votre propre application mais d'une façon générale vous pourriez noter que la constante de dérivation ''Kd'' est habituellement beaucoup plus grande que la constante proportionnelle ''Kp''. C'est parce que la dérivée de l'erreur (quantification de la ''variation de l'erreur'') est beaucoup plus petite que l'erreur elle même. Par conséquent, pour produire une correction signification il est nécessaire de multiplier le terme dérivé par une constante beaucoup plus grande.

 

The following code gives a very simple example of PD control (I find the integral PID term is usually not necessary when it comes to line following). The specific nature of the constants will be determined by your particular application, but you should note that the derivative constant ''Kd'' is usually much bigger than the proportional constant ''Kp''. This is because the derivative of the error is a much smaller quantity than the error itself, so in order to produce a meaningful correction it needs to be multiplied by a much larger constant.

<syntaxhighlight lang="C">int lastError = 0;

<syntaxhighlight lang="C">int lastError = 0;

{

{

   unsigned int sensors[3];

   unsigned int sensors[3];

   // get calibrated sensor values returned in the sensors array, along with the line position

   // Obtenir les valeurs calibrées retournées dans

   // position will range from 0 to 2000, with 1000 corresponding to the line over the middle

  // tableau de senseur accompagné de la position  

   // sensor

   // de la ligne (valeur entre 0 et 2000) avec

  // 1000 correspondant à la ligne au milieu du

   // senseur

   int position = qtr.readLine(sensors);

   int position = qtr.readLine(sensors);

   

   

   // compute our "error" from the line position. We will make it so that the error is zero when

   // Calculer notre "erreur" depuis la position  

   // the middle sensor is over the line, because this is our goal.  Error will range from

  // de la ligne. Nous allons la calculer de sorte

   // -1000 to +1000. If we have sensor 0 on the left and sensor 2 on the right, a reading of

   // que l'erreur égale 0 si la ligne est sous la

   // -1000 means that we see the line on the left and a reading of +1000 means we see the

   // line on the right.

   // but). L'erreur aura une valeur entre -1000 et

  // +1000. Si nous avons le senseur 0 à gauche et

  // le senseur 2 à droite, alors une valeur lue

   // de -1000 signifie que la ligne est vue sur la

  // gauche du senseur. Une valeur de +1000  

   // signifie que que nous voyons la ligne sur

  // la droite du senseur.

   int error = position - 1000;

   int error = position - 1000;

   

   

   // set the motor speed based on proportional and derivative PID terms

   // Baser la vitesse des moteurs sur base des

   // KP is the a floating-point proportional constant (maybe start with a value around 0.1)

  // termes proportionnel et dérivés d'un PID.

   // KD is the floating-point derivative constant (maybe start with a value around 5)

   // KP est la constante proportionnelle (commencer

   // note that when doing PID, it's very important you get your signs right, or else the

  //    avec une valeur 0.1)

   // control loop will be unstable

   // KD est la constance dérivée (vous pouvez peut-être

  //    commencer avec un valeur autour de 5)

   // Note: lors d'un asservissement PID, il est très

  //  important d'avoir le bon signe pour les valeurs

  //  sinon, la boucle de contrôle sera totalement

   // motorSpeed peut avoir une valeur positive ou

   int motorSpeed = KP * error + KD * (error - lastError);

   int motorSpeed = KP * error + KD * (error - lastError);

   lastError = error;

   lastError = error;

   

   

   // M1 and M2 are base motor speeds.  That is to say, they are the speeds the motors should

   // M1 et M2 sont les vitesses par défaut des moteurs.

   // spin at if you are perfectly on the line with no error. If your motors are well matched,

   // M1 and M2 will be equal. When you start testing your PID loop, it might help to start with

   // small values for M1 and M2.  You can then increase the speed as you fine-tune your

  //    droite.   

   // PID constants KP and KD.

  //    être égale (ou presque, chaque moteur étant un peu

   //   différent de l'autre).  

   // Il est préférable de commencer avec une petite valeur

  //    pour M1 et M2 lorsque vous commencez à tester votre

  //    si la vitesse est plus élevée.

  //    faible vitesse, vous pouvez augmenter les valeurs

   //   de M1 et M2 et poursuivre l'affinement des valeurs

   //   des constantes KP et KD de votre PID.

   int m1Speed = M1 + motorSpeed;

   int m1Speed = M1 + motorSpeed;

   int m2Speed = M2 - motorSpeed;

   int m2Speed = M2 - motorSpeed;

   

   

   // it might help to keep the speeds positive (this is optional)

   // Cela peut aider de maintenir une vitesse positive  

   // note that you might want to add a similiar line to keep the speeds from exceeding

  // pour les moteurs (ce point est optionnel).

   // any maximum allowed value

   // Un test similaire pourrait être ajouté pour garder

   // la vitesse des moteurs en dessous du maximum

   if (m1Speed < 0)

   if (m1Speed < 0)

     m1Speed = 0;

     m1Speed = 0;

     m2Speed = 0;

     m2Speed = 0;

   

   

   // set motor speeds using the two motor speed variables above

   // Fixer la vitesse des mmoteur en utilisant les

  // variables m1Speed et m2Speed

}</syntaxhighlight>

}</syntaxhighlight>

{{Pololu-Senseur-QTR-TRAILER}}

{{Pololu-Senseur-QTR-TRAILER}}