ModelleisenbahN

Accueil > La technologie > L’algorithme de rotation du pont tournant

Pont tournant et moteurs pas-à-pas

L’algorithme de rotation du pont tournant

publié par Jean-Luc, le mercredi 1er janvier 2014

Tags arduino - moteur pas-à-pas - pont tournant

Après avoir présenté le matériel nécessaire au pilotage du moteur pas-à-pas par µPas et le choix de la DRV8824 de Pololu pour sa meilleure résolution et la fluidité de mouvement qui en résulte, il est temps de se pencher sur l’algorithme qui permet de décider du sens de rotation et de la décomposition du mouvement en phase d’accélération, en régime permanent et en phase de décélération.

Calcul du sens de rotation pour le plus court chemin

Le pont est bien évidemment orienté. C’est à dire que les positions p et p+180° sont différentes. Avec la DRV8824, nous avons 12800 positions possibles que nous allons numéroter de 0 à 12799. Partant de la position courante, le pont devant aller dans une nouvelle position, il faut décider dans quel sens tourner pour minimiser la distance parcourue. C’est à dire que partant de la position courante 12799 et allant à la position 0, il n’y a qu’un µPas à effectuer et non 12799.

On va distinguer deux cas :

  1. La position à atteindre à un numéro > à la position courante ;
  2. La position à atteindre à un numéro < à la position courante.

Par convention, on va également décider qu’un déplacement positif se fait dans le sens horaire et un déplacement négatif dans le sens trigonométrique.

La position à atteindre à un numéro supérieur à la position courante

Ce cas correspond à la figure ci-dessous :

PNG - 41.1 ko

chemin 1 se calcule en soustrayant la position courante à la position destination : chemin 1 = position destinationpositition courante.
Il est bien positif, la rotation pour parcourir chemin 1 se fait dans le sens horaire.

chemin 2 doit être négatif puisque la rotation de fait dans le sens trigonométrique et il se décompose en deux : d’une part la portion entre la position courante et 0 et d’autre part la portion entre 12800 et la position destination.
On a donc chemin 2 = — (positition courante + 12800 — position destination)

La position à atteindre à un numéro inférieur à la position courante

Ce cas correspond à la figure ci-dessous :

PNG - 46.5 ko

chemin 1 se calcule également en soustrayant la position courante à la position destination : chemin 1 = position destinationpositition courante.
Comme la position courante est plus grande que la position destination, il est bien négatif, la rotation pour parcourir chemin 1 se fait dans le sens trigonométrique.

chemin 2 doit être positif et se décompose en deux : d’une part la portion entre la position courante et 12800 et d’autre part la portion entre 0 et la position destination.
On a donc chemin 2 = 12800 — positition courante + position destination.

Pour choisir le chemin, il suffit de comparer les valeurs absolues de chemin 1 et chemin 2 et de choisir le chemin ayant la plus petite. Le signe du chemin donne le sens de rotation.

Le code correspondant est le suivant :

  1. int chemin1 = positionDestination - positionCourante;
  2. int chemin2;
  3. if (positionDestination > positionCourante)
  4. chemin2 = - (positionCourante + 12800 - positionDestination);
  5. else
  6. chemin2 = 12800 - positionCourante + positionDestination;
  7.  
  8. int chemin;
  9. int dir;
  10. if (abs(chemin1) > abs(chemin2))
  11. chemin = chemin2;
  12. else
  13. chemin = chemin1;
  14.  
  15. /* Si chemin < 0, la direction est mise à 1 */
  16. if (chemin < 0)
  17. dir = HIGH;
  18. else
  19. dir = LOW;

Télécharger

Le nombre de µPas à parcourir sera mis dans une variable distance calculée comme suit : distance = abs(chemin);.

Vitesse de rotation, accélération et décélération

La vitesse de rotation d’un pont tournant est assez faible. On peut par exemple voir dans cette vidéo qu’il faut environ 2 minutes (entre 45" et 2’45") pour que la 141TD 740 fasse son demi-tour, ce qui donne 4 minutes pour un tour.

La 141TD 740 s’engage sur le pont tournant et fait un demi-tour

Dans notre cas, il faut donc passer 12800 µPas en 4 minutes soit 240s, ce qui donne un délai de 18 à 19ms entre deux µPas. Pour clarifier le code, ce délai va être mis dans une variable delaiInterMicropas, ce qui permettra aussi de changer la vitesse de rotation sans avoir à modifier le code.

Si on ne se soucie pas d’avoir des phases d’accélération et de décélération, le code est très simple :

  1. for (microPas = 0; microPas < distance; microPas++)
  2. {
  3. digitalWrite(stepPin, LOW);
  4. delay(1);
  5. digitalWrite(stepPin, HIGH);
  6. delay(delaiInterMicroPas - 1);
  7. }

Télécharger

Mais le mouvement a une allure artificielle. Il est donc préférable de simuler une petite phase d’accélération et de décélération.

Les phases d’accélération vont être réglées en nombre de µPas passés à accélérer et à décélérer. On va donc avoir 2 variables microPasAcceleration et microPasDeceleration pour régler ces phases.

Un mouvement d’une position courante à une position de destination consiste donc à parcourir microPasAcceleration µPas avec un délai variable et décroissant puis à parcourir distance - microPasAcceleration - microPasDeceleration µPas avec un délai delaiInterMicropas et enfin parcourir microPasDeceleration µPas avec un délai variable croissant.

Bien entendu, il ne faut pas que microPasAcceleration + microPasDeceleration soit supérieur à distance. En pratique les phases d’accélération et de décélération seront courte et la distance est supérieur à l’écartement de la voie utilisée. Par exemple pour un pont en N de 150mm de diamètre, les 9mm d’écartement correspondent à 245 µPas.

Le délai initial de la phase d’accélération est calculé est ajoutant microPasAcceleration à delaiInterMicropas. On va ensuite boucler microPasAcceleration fois en diminuant le délai de 1 à chaque tour pour donc terminer sur un délai égal à delaiInterMicropas. Comme ceci :

  1. int delai = delaiInterMicroPas - 1 + microPasAcceleration;
  2. for (microPas = 0; microPas < microPasAcceleration; microPas++) {
  3. digitalWrite(stepPin, LOW);
  4. delay(1);
  5. digitalWrite(stepPin, HIGH);
  6. delay(delai);
  7. delai-- ;
  8. }

Télécharger

Le mouvement a vitesse maximum est accompli par la boucle suivante :

  1. for (microPas = 0;
  2. microPas < (distance - microPasAcceleration - microPasDeceleration);
  3. microPas++)
  4. {
  5. digitalWrite(stepPin, LOW);
  6. delay(1);
  7. digitalWrite(stepPin, HIGH);
  8. delay(delaiInterMicroPas - 1);
  9. }

Télécharger

Enfin, la phase de décélération consiste à boucler microPasDeceleration fois en augmentant le délai de 1 à chaque tour, delai est initialisé à la valeur delaiInterMicropas. Comme ceci :

  1. for (microPas = 0; microPas < microPasDeceleration; microPas++) {
  2. digitalWrite(stepPin, LOW);
  3. delay(1);
  4. digitalWrite(stepPin, HIGH);
  5. delay(delai);
  6. delai ++;
  7. }

Télécharger

Tout cela est mis dans une fonction allerAPosition(...).

Sketch de démonstration

Voici le câblage :

PNG - 295.8 ko

Et le sketch de l’application de démonstration. Il contient la fonction allerAPosition(...) et l’exécution d’un scénario de mouvement.

Zip - 1.3 ko
Sketch de démonstration du pont tournant
(clic sur l'image pour agrandir ou télécharger)

2 Messages

  • L’algorithme de rotation du pont tournant 23 septembre 2016 15:05, par Deuff

    Bonjour,
    Merci pour votre partage. J’ai réalisé votre montage conformément au schéma, j’ai utilisé un arduino nano, j’ai téléchargé votre sketch et quand je lance la démo, le pont tourne par saccade jusqu’aux différentes positions... pouvez vous me renseigner.
    Cordialement

    repondre message

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