L’algorithme de rotation du 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 :

chemin 1 se calcule en soustrayant la position courante à la position destination : chemin 1 = position destination — positition 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 :

chemin 1 se calcule également en soustrayant la position courante à la position destination : chemin 1 = position destination — positition 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 :

int chemin1 = positionDestination - positionCourante;
int chemin2;
if (positionDestination > positionCourante)
  chemin2 = - (positionCourante + 12800 - positionDestination);
else
  chemin2 = 12800 - positionCourante + positionDestination;
 
int chemin;
int dir;
if (abs(chemin1) > abs(chemin2))
  chemin = chemin2;
else
  chemin = chemin1;
 
/* Si chemin < 0, la direction est mise à 1 */
if (chemin < 0)
  dir = HIGH;
else
  dir = LOW;

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.

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 :

for (microPas = 0; microPas < distance; microPas++)
{
  digitalWrite(stepPin, LOW);
  delay(1);
  digitalWrite(stepPin, HIGH);
  delay(delaiInterMicroPas - 1);
}

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 :

int delai = delaiInterMicroPas - 1 + microPasAcceleration;
for (microPas = 0; microPas < microPasAcceleration; microPas++) {
  digitalWrite(stepPin, LOW);
  delay(1);
  digitalWrite(stepPin, HIGH);
  delay(delai);
  delai-- ;
}

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

for (microPas = 0;
     microPas < (distance - microPasAcceleration - microPasDeceleration);
     microPas++)
{
  digitalWrite(stepPin, LOW);
  delay(1);
  digitalWrite(stepPin, HIGH);
  delay(delaiInterMicroPas - 1);
}

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 :

for (microPas = 0; microPas < microPasDeceleration; microPas++) {
  digitalWrite(stepPin, LOW);
  delay(1);
  digitalWrite(stepPin, HIGH);
  delay(delai);
  delai ++;
}

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

Sketch de démonstration

Voici le câblage :

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