Screenshoot

Sommaire:
      Vidéo de démonstration
      Step et Dir
      Commande directe des enroulements
      Impulsions Step retardées
      Impulsion Step manquante
      Mouvements rapides enchaînés
      Deux moteurs sur un seul timer, avec Step
      Deux moteurs sur un seul timer, commande directe
      Deux moteurs, mais trop vite
      Quatre moteurs

 

Vidéo de démonstration

 

Step et Dir

Soit le petit programme suivant:

/*Rappels sur la configuration:
#define step1 2
#define dir1 3
#define ORDRES_TABLE1 4
*/

#include "QuickStep.h"
void setup() { quickStepInit(); }

void loop()
{
  quickStepDeplacement1(3, 1, 20);
  quickStepDeplacement1(3, 0, 20);
  while (quickStepReste1() > 0);
}
Voici le chronogramme que l'on obtient:

Analysons ce chronogramme:
(1) A cet instant le mouvement est préparé pour le premier déplacement, Dir est mis à 1, les paramètres passés sont mis dans des variables.
(2) 40µs après la première impulsion arrive. Elle dure 1,188µs par défaut. C'est sous interruption, Step est mis à 1, le nombre de pas restant à faire est décrémenté, un test est fait pour savoir si il reste des pas, et comme il en reste 2, on ne fait rien de plus. Step repasse à 0. L'impulsion d'après arrive 10µs après (base de temps par défaut 0,5µs, multiplicateur 20).
(3) La troisième impulsion est la dernière. Ce mouvement est donc fini dans 10µs (à partir du front montant). On va donc aller dans la table pour lire les données des pas suivants. On prépare le pas suivant en positionnant Dir à 0. Ce calcul est plus long, il dure environ 4µs. L'impulsion est plus large. Suit trois impulsions pour le sens inverse.
(4) La dernière impulsion est un peu pls large (2,6µs) car comme il ne reste plus de pas à faire pour cet ordre, il faut voir si il reste de nouveaux ordres dans la table. Ce n'est pas le cas, on met en place l'arrêt.
(5) Tour recommence.

Si on regarde l'instant des fronts montants de Step, on peut voir qu'ils sont réguliers. En fait il peut y avoir une petite fluctuation en fonction du moment de l'interruption. Il faut alors finir l'instruction en cours qui peut durer un, deux ou trois cycle d'horloge.

Cette bibliothèque est écrite pour des drivers pour lesquels Step est actif sur front montant. Si Step est actif sur front descendant, il y a un problème pour la direction: près un arrêt Dir est le même pour les deux fronts pour la première impulsion, alors que Dir est mis à jour pendant l'impulsion si deux ordres sont enchaînés. La valeur de Dir peut donc être fausse. Si Step est actif sur front descendant, le dernier pas d'un ordre se fera dans le mauvais sens si cet ordre s'enchaîne avec un ordre de sens contraire. Si on ne fait que des ordres séparés par un arrêt (même de 50µs comme dans le chronogramme) ou si les ordres enchaînés sont dans le même sens, on peut utiliser Step sur front descendant.

 

Commande directe des enroulements

Soit le petit programme suivant:

/*Rappels sur la configuration:
#define premBobine1 2
#define deuxBobine1 3
#define ORDRES_TABLE1 4
*/

#include "QuickStep.h"
void setup() { quickStepInit(); }

void loop()
{
  quickStepDeplacement1(3, 1, 20);
  quickStepDeplacement1(3, 0, 20);
  while (quickStepReste1() > 0);
}
Voici le chronogramme que l'on obtient:

Il se passe exactement la même chose dans ce chronogramme que dans le précédent, mais les front montants sont remplacés par un changement sur une des deux bobines. Et les fronts montants étant réguliers, le chronogramme ne laisse rien apparaître. Dir n'existe plus et on n'a donc pas le problème que l'on avait avec Step et Dir.

Quand on tourne dans le sens positif, le signal de la deuxième bobine est comme le signal de la première mais en retard (plus à droite). Si on tourne dans le sens négatif, le signal de la deuxième bobine est comme le signal de la première mais en avance (plus à gauche). Un nouveau pas arrive quand un des deux signaux change.

Si on rajoute les deux lignes suivantes dans la configuration, pour définir le moteur à 4 bobines, on va avoir 4 signaux dont les deux derniers sont l'inverse des deux premiers:

#define troisBobine1 4
#define quatreBobine1 5
En réalité les signaux ne pouvant pas être produits sur des pins quelconques exactement en même temps, il y a un décalage de 62,5µs entre les deux premiers signaux et les deux derniers. Cela donne donc:

 

Impulsions Step retardées

Parfois lorsqu'arrive le temps pour faire une impulsion, il est impossible de la faire. Dans la plupart des cas, l'impulsion aura lieu quand même, mais elle est en retard. L'impulsion ou les impulsions qui suivent seront plus courtes et le retard est rattrapé. Ceci est souvent quasi invisible. Mais si on demande une impulsion sur Step toutes les 6µs, et que l'on change d'ordre, l'impulsion qui précède le changement va avoir plus de calcul à faire et est plus longue. Cela va retarder quelques impulsion, mais on finira par se resynchroniser:

Le même phénomène apparaît pour la commande directe, mais c'est moins facile à analyser.

 

Impulsion Step manquante

La fonction qui génère les impulsions est assez rapide car il s'agit principalement de décompte de pas à faire, et d'envoi de deux niveaux sur la sortie Step. Par contre l'interruption qui compte les millisecondes pour le système dure deux fois plus longtemps (8µs). Pendant cette interruption, on ne peut pas gérer le moteur. Si on va suffisamment vite pendant cette interruption, deux demandes demandes d'interruptions pour avancer peuvent être faites et l'une d'elle est ignorée. Quand arrive la première, un drapeau indiquant une interruption à faire est mis à 1. Quand arrive la deuxième, le drapeau est déjà à 1, il ne se passe rien. On a deux informations, mais il n'y a qu'un bit pour l'enregistrer. Le deuxième ordre n'a pas d'influence. Cela va se traduire par une impulsion manquante. Ce n'est absolument pas catastrophique car on n'a pas fait l'impulsion, mais on a pas non plus compté un pas à faire en moins. Le nombre de pas est donc correct. L'impulsion manquante se traduit par une erreur d'un demi pas, ce qui ne se voit pas. Mais on va avoir un vitesse moindre car il manque une impulsion toutes les 1,024ms. Avec des impulsions toutes les 5,75µs, on perd donc 5,75µs toutes les 1024µs, soit 0,56%.

Le même phénomène apparaît pour la commande directe, mais c'est moins facile à analyser.

 

Mouvements rapides enchaînés

Voici un chonogramme si on demande des ordres rapides et enchaînés avec Step.

Sur ce chronogramme, on peut observer des impulsions régulières. Deux petites irrégularités, la première est due à l'horloge système, la deuxième au changement d'ordre. On peut supprimer la première irrégularité en désactivant l'horloge système, ou en réécrivant correctement les fonctions liées au timer 0 (si on réduit la durée de cette interruption, on n'aura plus de perte d'impulsion).

Le même phénomène apparaît pour la commande directe, mais c'est moins facile à analyser.

 

Deux moteurs sur un seul timer, avec Step

Quand on veut que deux moteurs fonctionnent de façon synchrones, on utilise un seul timer pour les deux. Voici un chronogramme que l'on obtient si un moteur fait 4 pas pendant que l'autre en fait 3, le tout à une vitesse demandée de 20µs/pas:

Le timer utilisé va fournir une impulsion systématiquement au moteur qui va le plus vite (celui qui fait 4 pas quand l'autre en fait 3). Le deuxième moteur aura donc des impulsions manquantes.
(1) Une impulsion sur 4 n'aura lieu que pour un seul des moteurs. L'impulsion manquante est répartie aussi régulièrement que possible. Si on avait un moteur qui avance de 7 pas si l'autre en fait 5, il y aurait 2 pas ensemble, 1 pas seul, 3 pas ensemble 1 pas seul...
(2) Un seul moteur tourne, il y a donc 20µs entre les deux pas; c'est la vitesse programmée.
(3) Maintenant une impulsion pour chaque moteur est générée.
(4) Comme les deux moteurs tournent en même temps, la durée est √2 fois plus grande que la durée programmée (d'où l'importance d'avoir une base de temps petite pour ne pas avoir trop d'arrondis sur la vitesse). La durée programmée est de 20µs par pas, cette durée entre deux fronts montants vaut vaut 28µs.

 

Deux moteurs sur un seul timer, commande directe

Le chronogramme qui suit est obtenu pour deux moteurs sur un seul timer en commande directe à 2 bobines (si on met 4 bobines par moteur, on rajoute 4 signaux inversés, cela embrouille plutôt que d'aider). Le temps programmé est de 17,75µs entre pas, et comme les deux moteurs tournent en même temps, chacun avance d'un pas toutes les 25µs. La "période" des signaux est donc de 100µs:

Pour les détails, voir le paragraphe précédent, la commande directe masque pas mal de choses.
(1) Dans cette première zone, le premier moteur tourne à l'envers (après un front montant sur la première bobine 1A, il y a un front descendant sur la bobine 1B) et le deuxième moteur tourne à l'endroit (après un front montant sur la première bobine 2A, il y a un front descendant sur la bobine 2B).
(2) Changement de sens pour le premier moteur. Il y a changement de pas toutes les 25µs, à chaque fois que le signal d'une des deux bobines d'un moteur change.
Notez aussi qu'il y a de légers retards du fait que deux broches que l'on peut choisir librement ne peuvent pas changer d'état en même temps. Par rapport à un front de la bobine 1A, le signal sur la bobine 2A à un retard d'environ 2µs.

 

Deux moteurs, mais trop vite

Si on utilise deux moteurs (chacun son timer) et que l'on demande 6µs entre pas on obtient:

Si on va trop vite, il va y avoir des demandes d'interruptions quasi permanentes. Si deux demandes d'interruptions ont lieu, le timer de plus faible numéro est prioritaire et sera servi le premier . Supposons que les deux demandes arrivent à l'instant t=0. Le premier timer est servi le premier et le deuxième timer sera servi après. On va donc avoir une impulsion sur Step pour chaque moteur. Mais le traitement pour le deuxième durant pas tout à fait 6µs, dès la sortie de la fonction d'interruption du deuxième, le premier timer sera de nouveau servi car cela fait déjà quelques microsecondes qu'il aurait dû être servi. Son impulsion est décalée. En finissant, il a encore du retard et demende encore à être servi. Au bout d'un moment il se resynchronise et il reste un court instant sans avoir de demande d'interruption. Le deuxième timer peut être alors servi. C'est pour cela que le permier moteur tourne, et de temps en temps le deuxième moteur arrive à en placer une.

Si on demande des pas pour les deux moteurs à 11,94µs (c'est le minimum qui fonctionne bien), on obtient le chronogramme:

On observe une petite irrégularité lors du changement d'ordre quand ils sont enchaînés; cela se voit car une impulsion est plus large. Après cela tout le temps disponible est distribué alternativement aux deux timers. Pendant ce temps les deux timers sont en retard. Quand le premier timer aura rattapé son retard, le deuxième timer pourra avoir deux impulsions qui se suivent et va rattraper son retard, metant de nouveau le premier en retard. Comme il n'y a plus que le premier qui est en retard, lorsqu'il va de nouveau se synchroniser, tout sera parfait. Au passage, il n'y a pas eu de perte d'impulsions, seulement quelques retards.

 

Quatre moteurs

Si on utilise quatre moteurs (chacun son timer) et que l'on demande 23,81µs entre pas (le minimum) on obtient:

On voit que quand pour un moteur deux ordres s'enchaînent, cela augmente la durée de l'interruption, et fait une perturbation. Mais tout rentre dans l'ordre au bout d'un moment sans perte d'impulsions. Il y a juste décalage (retards).

Si va plus vite, le dernier timer commence à perdre des pas, puis les deux derniers...

 


dansetrad.fr Contactez-moi