ModelleisenbahN

Accueil > La technologie > Arduino > Manœuvre des aiguilles avec des servo-moteurs > Réglage des butées des servomoteurs

Manœuvre des aiguilles en analogique avec des servo-moteurs

Réglage des butées des servomoteurs

publié par Jean-Luc, le dimanche 1er décembre 2013

Tags aiguille - arduino - servo

Nous voici enfin à l’avant dernière étape de développement de notre système. Dans « Sélection d’un servomoteur pour le réglage des butées », nous avons vu la mise en œuvre d’un codeur pour désigner le servomoteur à régler, dans « Clavier de réglage des butées », nous avons vu l’ajout d’un second clavier analogique destiné à permettre le réglage des butées et, comme nous avions déjà un clavier analogique, la généralisation de la gestion de ce type de clavier par le biais d’une classe C++.

Nous allons maintenant voir comment intégrer cette fonction de réglage au programme de pilotage des 8 servos. Mais tout d’abord quelques éclaircissement sur la fonction désirée.

Le fonctionnement du réglage

Lorsqu’un des servo est désigné au moyen du codeur, le mouvement des servos restent actif. En effet, le réglage ne porte que sur la butée actuelle du servo désigné.

Si le servo est en butée dans le sens horaire, une pression sur le poussoir de droite doit déplacer la butée horaire un peu plus dans le sens horaire. Une pression sur le poussoir de gauche déplace la butée un peu moins. De même, si le servo est en butée dans le sens trigonométrique, une pression sur le poussoir de gauche déplace un peu plus la butée dans le sens trigonométrique et une pression sur le poussoir de droite un peu moins.

Pour passer du réglage d’une butée au réglage de l’autre butée, il suffit de presser le poussoir commandant le mouvement du servomoteur.

Une tentative de réglage alors que le servo est en mouvement est ignorée.

Le réglage en lui même va donc augmenter ou diminuer les angles minimum et maximum. Si on veut un réglage précis, il faut régler de pas en pas [1]. Mais régler de pas en pas risque d’être long. On veut donc pouvoir décider de combien de pas la butée est augmentée ou diminuée lors d’une pression sur un des poussoirs de réglage. Voici donc le rôle des 2 boutons supplémentaires du clavier de réglage, ils servent à augmenter et diminuer le nombre de pas de réglage.

Par défaut, lorsqu’on désigne un servo à régler, le nombre de pas sera de 8. Une pression sur le poussoir d’augmentation du pas le multipliera par 2 avec un maximum de 32. Une pression sur le poussoir de diminution du pas le divisera par 2 avec un minimum de 1. Le fait de désigner un nouveau servo réinitialisera le pas de réglage à 8.

Modification de la classe DescripteurServo

La première modification est évidente. Auparavant, les butées étaient déterminées globalement pour les 8 servomoteurs. Maintenant que l’on veut régler les butées de chaque servomoteur individuellement, il faut que le DescripteurServo comporte deux données membres angleMin et angleMax comme ceci :

  1. class DescripteurServo {
  2. Servo objetServo; /* Objet issu de la bibliothèque Servo de l'Arduino */
  3. int vitesse; /* La vitesse de déplacement du servomoteur */
  4. int angle; /* L'angle du servo-moteur */
  5. int angleMin; /* Angle minimum du servo */
  6. int angleMax; /* Angle maximum du servo */
  7. int pin; /* La broche sur laquelle il est connecté */
  8. byte etatServo; /* son état : SERVO_A_ANGLE_MIN, SERVO_A_ANGLE_MAX
  9.   SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX ou
  10.   SERVO_EN_MOUVEMENT_VERS_ANGLE_MIN */
  11. ...

Télécharger

On va bien entendu conserver des constantes minimum et maximum absolues afin de limiter le réglage :

  1. const int ANGLE_MIN = 1000;
  2. const int ANGLE_MAX = 2000;

Télécharger

Ces constantes vont être employées dans le constructeur de DescripteurServo pour initialiser les données membres angleMin et angleMax.

La fonction de réglage

Ensuite, il faut écrire une fonction membre de réglage. Cette fonction est appelée de loop() lorsque le codeur désigne le servo concerné. Cette fonction doit

  • lire un événement sur le clavier de réglage ;
  • si l’événement est un changement de pas de réglage, la variable de pas est multipliée par 2 ou divisée par 2 ;
  • si l’événement est un réglage :
    • si l’état du servo est SERVO_A_ANGLE_MIN, l’angle minimum est ajusté, la vitesse du servo est mise à 1 ou -1 selon le changement pour que le servo vienne de recaler sur l’angle minimum ;
    • si l’état du servo est SERVO_A_ANGLE_MAX, l’angle maximum est ajusté, la vitesse du servo est mise à 1 ou -1 selon le changement pour que le servo vienne de recaler sur l’angle maximum.

Afin de séparer clairement les différents cas, nous allons utiliser des switch ... case.

  1. void regleServo()
  2. {
  3. int numPoussoir;
  4.  
  5. if (clavierReglage.lireEvenement(&numPoussoir) == EVENEMENT_PRESSE) {
  6. switch(numPoussoir) {
  7.  
  8. case 0: /* déplacement de la butée dans le sens trigo */
  9. switch(etatServo) {
  10. case SERVO_A_ANGLE_MIN:
  11. if (angleMin < angleMax)
  12. angleMin += min(pasDeReglage, angleMax - angleMin);
  13. objetServo.attach(pin);
  14. vitesse = 1;
  15. break;
  16. case SERVO_A_ANGLE_MAX:
  17. if (angleMax < ANGLE_MAX)
  18. angleMax += min(pasDeReglage, ANGLE_MAX - angleMax);
  19. objetServo.attach(pin);
  20. vitesse = 1;
  21. break;
  22. }
  23. break;
  24.  
  25. case 1: /* déplacement de la butée dans le sens horaire */
  26. switch(etatServo) {
  27. case SERVO_A_ANGLE_MIN:
  28. if (angleMin > ANGLE_MIN)
  29. angleMin -= min(pasDeReglage, angleMin - ANGLE_MIN);
  30. objetServo.attach(pin);
  31. vitesse = -1;
  32. break;
  33. case SERVO_A_ANGLE_MAX:
  34. if (angleMax > angleMin)
  35. angleMax -= min(pasDeReglage, angleMax - angleMin);
  36. objetServo.attach(pin);
  37. vitesse = -1;
  38. break;
  39. }
  40. break;
  41.  
  42. case 2: /* diminution du pas de réglage */
  43. if (pasDeReglage > 1) pasDeReglage /= 2;
  44. break;
  45.  
  46. case 3: /* augmentation du pas de réglage */
  47. if (pasDeReglage < 32) pasDeReglage *= 2;
  48. break;
  49. }
  50. }
  51. }

Télécharger

La gestion du mouvement

Le réglage est un cas particulier, l’angle du servo peut être en dehors de la fourchette angleMin et angleMax. Or la fonction gereServo() suppose que l’angle est dans la fourchette. Il ne va donc pas fonctionner correctement pour le réglage. Il faut donc l’adapter.

Tout d’abord, il nous faut une variable booléenne qui va indiquer si un réglage est en cours ou non. Cette variable sera modifiée dans loop en fonction de la valeur renvoyée par lireReglage(), la fonction qui renvoie l’état du codeur.

Si il n’y a aucun réglage en cours ou si le servo est dans l’une des états SERVO_EN_MOUVEMENT_VERS_ANGLE_MAX ou SERVO_EN_MOUVEMENT_ VERS_ANGLE_MIN, il s’agit d’un mouvement normal du servo et le code existant fonctionne. Dans l’autre cas, il faut un code spécifique pour gérer le mouvement vers la nouvelle butée. Selon la butée où le servo est et selon le signe de la vitesse, on détermine quand le mouvement doit être arrêté :

  1. if (etatServo == SERVO_A_ANGLE_MIN) {
  2. if (vitesse > 0 && angle >= angleMin) {
  3. angle = angleMin;
  4. vitesse = 0;
  5. objetServo.detach();
  6. }
  7. else if (vitesse < 0 && angle <= angleMin) {
  8. angle = angleMin;
  9. vitesse = 0;
  10. objetServo.detach();
  11. }
  12. }
  13. else if (etatServo == SERVO_A_ANGLE_MAX) {
  14. if (vitesse > 0 && angle >= angleMax) {
  15. angle = angleMax;
  16. vitesse = 0;
  17. objetServo.detach();
  18. }
  19. else if (vitesse < 0 && angle <= angleMax) {
  20. angle = angleMax;
  21. vitesse = 0;
  22. objetServo.detach();
  23. }
  24. }

Télécharger

Le fait de tester l’angle par rapport aux angles minimum et maximum avec des >= et <= est une sécurité. En effet, en testant avec une égalité == et si pour une raison indéterminée l’angle dépassait l’angle min ou max, le servo continuerait sont mouvement et irait en butée mécanique, ce qui pourrait l’endommager.

Modification de loop()

loop() est modifié pour prendre en compte la fonction de réglage.

  1. void loop()
  2. {
  3. int numServo;
  4.  
  5. /* gestion du mouvement des servos */
  6. for (numServo = 0; numServo < 8; numServo++)
  7. servoMoteur[numServo].gereServo();
  8.  
  9. /* lecture d'un ordre de mouvement */
  10. byte evenement = clavierOrdreServo.lireEvenement(&numServo);
  11.  
  12. /* exécution de l'ordre de mouvement */
  13. if (evenement == EVENEMENT_PRESSE)
  14. servoMoteur[numServo].evenementServo();
  15.  
  16. /* lecture du codeur qui désigne le servo à régler */
  17. int servoARegler = lireReglage();
  18. /* si positif ou nul, il y a un servo à régler */
  19. reglageEnCours = (servoARegler >= 0);
  20. /* si on a changé de servo à régler, le pas est remis à 8 */
  21. if (servoARegler != ancienServoARegler) {
  22. ancienServoARegler = servoARegler;
  23. pasDeReglage = 8;
  24. }
  25. /* exécution de réglage */
  26. if (reglageEnCours)
  27. servoMoteur[servoARegler].regleServo();
  28.  
  29. delay(5);
  30. }

Télécharger

Voici le code complet du sketch à télécharger.

Zip - 3.1 ko
Sketch Arduino de l’application avec réglage des butées
(clic sur l'image pour agrandir ou télécharger)

Et une vidéo de la mise en œuvre.

Test de l’application avec le réglage des butées

Comme expliqué dans la vidéo, il reste une paire de détails à régler. Nous verrons cela dans le prochain article mais on commence à voir le bout du tunnel !

Notes

[1Un pas vaut 1µs puisqu’on utilise la fonction writeMicroseconds(...) pour piloter les servos

4 Messages

Répondre à cet article

Les thèmes

Archives

Informations

ModelleisenbahN | publié sous licence Creative Commons by-nc-nd 2.0 fr | généré dynamiquement par SPIP & Blog'n Glop