Les différents types de mouvements d’un servo-moteur

. Par : Dominique, Guillaume, Jean-Luc. URL : http://www.locoduino.org/spip.php?article80

Introduction

Dans Bibliothèque Servo, nous avons vu comment fonctionnait la librairie Servo et les différentes fonctions permettant d’animer le servo-moteur. Voyons maintenant comment mettre en pratique ces commandes afin d’imiter au plus proche le mouvement d’une aiguille, c’est-à-dire le code dans loop().
Nous allons donc faire des essais et nous passerons donc du mouvement d’un moteur d’aiguillage type électro-aimant (ex : PECO) à un moteur lent d’aiguillage (ex : tortoise).
Nous verrons plusieurs types de mouvements qui ne correspondent pas uniquement à ceux d’une aiguille. Ils pourront correspondre à un signal mécanique, mouvement de barrière...

Attention

Les angles donnés sont à titre d’exemple, ils ne refléteront pas ceux de votre réseau. Les valeurs limites seront à trouver avec une application dédiée.

Aller-retours

La première application est très simple, il s’agit de faire faire au servo des aller-retours de part et d’autre de la position médiane. La méthode write(...) permet de donner l’angle auquel le servo doit se positionner. L’argument est une valeur comprise entre 0 et 180°. L’angle minimum choisi est donc de 70° et l’angle maximum de 110°. On fixe la pause entre 2 changements de position à 1s. La fonction loop() est donc la suivante.

  1. void loop()
  2. {
  3. /* positionne le servo à 70° */
  4. monServo.write(70);
  5. /* attend 1000 ms */
  6. delay(1000);
  7. /* positionne le servo à 110° */
  8. monServo.write(110);
  9. /* attend 1000 ms */
  10. delay(1000);
  11. }

Télécharger

Cette première application ne remplit pas le cahier des charges du mouvement réaliste, à savoir un mouvement lent. Le mouvement a bien lieu toutes les secondes mais il est très rapide, quasi instantané comme un électro-aimant.

Aller-retours lents

Pour obtenir un mouvement lent, il faut faire varier l’angle du servo progressivement. Pour cela, il faut changer l’angle très très peu et le faire plus souvent. Fixons par exemple un changement d’angle de 1°. Si l’on veut que le mouvement, passer de 70° à 110° soit accompli en 1s, il faut augmenter l’angle de 1° toutes les 1000ms / (110 - 70). soit une pause de 25ms. Quand l’angle atteint 110°, il faut inverser le mouvement. Quand l’angle atteint 70°, il faut de nouveau inverser le mouvement. Nous avons donc besoin de deux variables, angle qui contient l’angle courant du servo et vitesse qui contient 1 si on augmente l’angle et -1 si on le diminue. Pour faciliter la programmation, on va placer 70 et 110 dans deux constantes. Le programme est le suivant.

  1. #include <Servo.h>
  2.  
  3. Servo monServo;
  4. int vitesse;
  5. int angle;
  6.  
  7. const int angleMin = 70;
  8. const int angleMax = 110;
  9.  
  10. /*
  11.  * La fonction setup() est exécutée 1 fois
  12.  * au démarrage du programme
  13.  */
  14. void setup()
  15. {
  16. monServo.attach(2);
  17. angle = angleMin;
  18. vitesse = 1;
  19. }
  20.  
  21. /*
  22.  * La fonction loop() est exécutée
  23.  * répétitivement
  24.  */
  25. void loop()
  26. {
  27. monServo.write(angle);
  28. /* calcule le nouvel angle */
  29. angle = angle + vitesse;
  30.  
  31. if (angle > angleMax) {
  32. /*
  33.   * le nouvel angle dépasse le maximum
  34.   * on le recale au maximum et on inverse la vitesse
  35.   */
  36. angle = angleMax;
  37. vitesse = -1;
  38. }
  39. else if (angle < angleMin) {
  40. /*
  41.   * le nouvel angle dépasse le minimum
  42.   * on le recale au minimum et on inverse la vitesse
  43.   */
  44. angle = angleMin;
  45. vitesse = 1;
  46. }
  47. delay(25);
  48. }

Télécharger

Le mouvement est bien lent comme on le désire mais avec une variation de l’angle par degré, le mouvement est un peu saccadé. Une autre méthode permet un positionnement plus précis. Il s’agit de la méthode writeMicroseconds(...). L’argument de cette méthode n’est plus un angle mais la durée de l’impulsion de commande du servo-moteur en micro-secondes. En effet, le signal de commande du servo-moteur est une impulsion dont la largeur détermine la position du servo. Cette impulsion a donc la forme suivante.

PNG - 9.2 ko
La PWM de commande d’un servo
Seuls les durées extrêmes de l’impulsion et la durée médiane sont montrées mais toutes les valeurs entre 0,5 ms et 2,5 ms sont possibles.

Dans Bibliothèque Servo, nous avons vu que les valeurs extrèmes dépendent des paramètres optionnels de la méthode attach(...). Sans spécifier ces valeurs, 544 est la valeur inférieure et 2400 la supérieure.
1472µs est la valeur médiane.

Pour comprendre correctement le code, la valeur médiane est approximativement de 1500µs et les valeurs minimum et maximum pour les angles que nous avions fixés deviennent respectivement et approximativement 1250 et 1750.
Pour avoir les valeurs exactes, il faudra faire les bons calculs.
On va conserver une vitesse de 1 ou -1 et pour avoir un mouvement d’1s alors que l’on franchi 500 pas d’angle on va désormais faire une pause de 2ms. Le programme est donc le suivant.

  1. #include <Servo.h>
  2.  
  3. Servo monServo;
  4. int vitesse;
  5. int angle;
  6.  
  7. const int angleMin = 1250;
  8. const int angleMax = 1750;
  9.  
  10. /*
  11.  * La fonction setup() est exécutée 1 fois
  12.  * au démarrage du programme
  13.  */
  14. void setup()
  15. {
  16. monServo.attach(2);
  17. angle = angleMin;
  18. vitesse = 1;
  19. }
  20.  
  21. /*
  22.  * La fonction loop() est exécutée
  23.  * répétitivement
  24.  */
  25. void loop()
  26. {
  27. monServo.writeMicroseconds(angle);
  28. /* calcule le nouvel angle */
  29. angle = angle + vitesse;
  30.  
  31. if (angle > angleMax) {
  32. /*
  33.   * le nouvel angle dépasse le maximum
  34.   * on le recale au maximum et on inverse la vitesse
  35.   */
  36. angle = angleMax;
  37. vitesse = -1;
  38. }
  39. else if (angle < angleMin) {
  40. /*
  41.   * le nouvel angle dépasse le minimum
  42.   * on le recale au minimum et on inverse la vitesse
  43.   */
  44. angle = angleMin;
  45. vitesse = 1;
  46. }
  47. delay(2);
  48. }

Télécharger

Le résultat est meilleur avec un mouvement plus fluide. Il remplit donc son office de mouvement lent.

Nous avons donc vu différents types de mouvements possibles avec un servo-moteur. A nous de trouver son utilisation, notamment dans le mouvement des aiguilles avec le mouvement réaliste du dernier programme. Nous verrons cela dans d’autres articles.

Attention, les valeurs d’angles en degrés et en µs dans l’article sont mis pour les exemples. Chaque utilisation que vous en ferez nécessitera une connaissance des angles limites afin que le code soit adapté et fasse ce que vous lui ordonnerez.