Table équatoriale : Pilotage moteur pas à pas

[soulearth]

Bonjour,
J'en ai déjà un peu parlé, mais je bosse sur la construction d'une table équatoriale pour mon dobson. Entre le boulot et mon fils d'un an qui ne pense qu'a une chose ( faire passer le fer à souder par sa bouche ), je n'avance pas vite, mais j'avance.

Quand on creuse un peu la question de la motorisation d'une table équatoriale sur internet, c'est un peu le grand débat et on retrouve :
- ceux qui pensent qu'un moteur courant continu ( type moteur de suivi d'EQ1 ) est suffisant
- ceux qui pensent qu'un moteur pas à pas c'est mieux
- ceux qui trouvent que pas à pas c'est mieux et tellement simple ( corolaire: pas d'explication supplémentaire )

Moi au milieu de tout ça, j'avais l'air de con ( , ma mère )...
Cependant, après calcul il était évident que le moteur de suivi d'une EQ1 serait encore trop rapide pour ma table. Seconde chose, le moteur de l'EQ1 fait l'unanimité concernant le manque de régularité de sa vitesse, ce qui n'a rien d'étonnant concernant un moteur courant continu sur piles, en plein froid, et souvent sous alimenté pour arriver à une vitesse assez basse pour une table équatoriale.
Par conséquent, je suis parti sur un moteur pas à pas, sans savoir comment ça fonctionnait. Voici ce que j'ai fait. J'espère que cette synthèse pourra aider d'autres bricoleurs.

Le pilotage d’un moteur pas à pas nécessite la génération d’un signal carré à la fréquence souhaitée puis l’utilisation d’un driver de moteur pas à pas qui va prendre en charge la gestion des micro-pas ( division d'un pas complet ) et la génération du courant envoyé au moteur.
En gros, un moteur pas à pas avance par petit palier qui sont les pas. En fonction des modèles les moteurs ont plus ou moins de pas. Le mien possède 200 pas. Il fait donc un tour complet en parcourant ses 200 pas. Pour ceci il faut générer 200 signaux carrés. Plus les 200 signaux carrés sont générés rapidement, et plus le moteur tourne vite.

Les mode de demi-pas, c'est pas beaucoup plus compliqué. Lorsqu'un signal carré est généré, le moteur n'avance plus que d'une moitié de pas. Pour faire un pas complet il lui faut donc deux signaux carré. La conséquence directe, c'est que les demi-pas sont 2 fois plus petits et le moteur va deux fois moins vite. Dans cet exemple, j'utilise le mode 1/32eme de pas.

La chaîne minimale de pilotage se résume donc à :
Microcontroleur ( génère le signale carré ) → driver moteur (génère le courant en fonction du signale carré ) → moteur ( tourne en cadence )

Pour faire ceci nous allons utiliser :
- 1 microcontroleur : arduino nano ( pour générer le signal carré )
- 1 driver : un chipset a4988 ou un DRV8825 ( reçoit le signal carré et envoi le courant au moteur )
- 1 tl-smoother : ce composant aide à avoir un signal plus propre ( optionnel )
- 1 convertisseur de tension DC DC : LM2596S
- Une batterie 20V

Schéma électrique :

moteur.png (26.2 Kio) Consulté 3234 fois

La tension d’alimentation d’un moteur pas à pas est assez souple car un moteur pas à pas est alimenté en courant ( sa vitesse dépend principalement de l’intensité ). Cependant, il faut tout de même ne pas dépasser la capacité du moteur à dissiper la chaleur car sinon il sera détruit.

A l’inverse, si la tension est trop basse, le moteur risque de « décrocher » avant d’atteindre la vitesse souhaitée. Le couple max du moteur est également lié à la tension d’alimentation du moteur.

Quelle est la tension maximum du moteur ? Nous appellerons cette tension maximum Umax. Il faut connaître l’inductance du moteur pour calculer Umax.

Umax = 32 ∙ √L
L = la valeur de l’inductance en miliHenry.

Pour mon moteur L=3.2
Umax = 32 ∙ √3.2 = 57V

Dans la plupart des cas, Umax correspond à 20 ou 25 fois la tension nominale du moteur.

Dans le cas d’une table équatoriale nous ne cherchons pas à aller vite ni à avoir un couple énorme. C’est même l’inverse, il nous faut une vitesse basse et un mouvement le plus fluide possible alors qu’un couple moteur important risque d’entraîner des à-coup à chaque pas. Nous pouvons donc alimenter bien en dessous de Umax.
J’ai à ma disposition le driver a4988 et le DRV8825. Le a4988 accepte jusqu’à 35V et le DRV8825 jusqu’à 45V. Pour garder la compatibilité avec les deux chipsets on peut donc considérer que 35V sera la tension maximum matérielle. Dans mon cas, ma batterie me fourni une sortie 20V, j’alimenterais donc en 20V pour des raisons pratiques.

Choix du driver

Pour piloter l’alimentation en courant des bobines moteurs j’utilise un driver. Il existe plusieurs modèle de driver mais le a4988 et le DRV8825 sont des modèles assez répandu qui ont été très utilisé dans les imprimantes 3D.
Le a4988 et le DRV8825 se ressemblent beaucoup et sont « PIN compatible ». Sans rentrer dans le détails, le DRV8825 supporte une tension et une puissance plus élevée et propose le mode micropas 1/32eme alors que le a4988 s’arrête au 1/16ème.
Sur le papier, le DRV8825 est donc plus performant. En réalité c’est un peu plus complexe que ça. Tout d’abord, au-delà du 1/8 de micro-pas, le déplacement devient plus petit que la précision mécanique du moteur donc on ne peut pas considérer que le mode 1/32 soit réellement plus précis que le 1/16.
De plus, les comparatifs entre le a4988 et le drv8825 montrent que le DRV8825 est plus imprécis que le a4988. Pour palier cette imprécision, il est conseiller d’utiliser le DRV8825 avec un tl-smoother qui a pour fonction de minimiser les erreurs de signal. Le tl-smoother est aussi compatible avec le a4988 mais dans ce cas, la différence est moins flagrante.

Voici les relevé d’oscilloscope que j’ai pu trouver sur internet.

drv8825-8-microstep-5rpm-24volts.png (27.97 Kio) Consulté 3234 fois

DRV8825 - 5 RPM - 24V

drv8825-8-microstep-5rpm-24volts-smoother.png (28.39 Kio) Consulté 3234 fois

DRV8825 - 5 RPM - 24V + Smoother

a4988-8-microstep-5rpm-24volts.png (29.41 Kio) Consulté 3234 fois

a4988 - 5 RPM - 24V

a4988-8-microstep-5rpm-24volts-smoother.png (29.81 Kio) Consulté 3234 fois

a4988 - 5 RPM - 24V + Smoother

Sources :
- https://embeddedtronicsblog.wordpress.c ... r-testing/
- https://embeddedtronicsblog.wordpress.c ... r-testing/

Comme on peut le constater, en mode 8eme de pas, à 5RMP et alimenté à 24V le signal du DRV8825 est totalement imprécis et il faut bien le tl-smoother pour améliorer la situation. Concernant le a4988, la situation est très différente et le signale est propre avec ou sans tl-smoother.
Évidement, dans mon cas, le moteur est alimenté à 20V et le choix se fera entre le mode 16eme ou 32eme de pas car pour atteindre une vitesse moteur suffisamment basse, il faut soit que :
- Le moteur soit piloté à une fréquence de 68Hz en mode 1/16eme de pas
- Le moteur soit piloté à une fréquence de 137Hz en mode 1/32 de pas ;

Le moteur possède un moto-réducteur 100x. Ce qui explique pourquoi j'arrive à atteindre les 137Hz en mode 1/32eme.


Au delà de la théorie, ce sont surtout les essais sur le terrain qui déterminerons le choix.

Réglage du stepper

Que ce soit le a4988 ou le DRV8825, les drivers doivent être réglés pour délivrer l’intensité adéquat au moteur. Le calcul n’est pas très complexe mais la formule est propre à chaque modèle de driver.
Tout d’abord il faut savoir qu’il est recommandé de prendre comme valeur d’intensité maximum environ 71% ( précisement 1/√2 ) de l’intensité donnée dans les spec du moteur.

Mon moteur est donné pour 1.68A.
Imax = 1.68 ∙ 71/100
Imax = 1.19A
Le driver devra donc fournir 1.19A au moteur. Pour ce faire il faut régler la tension entre le potentiomètre et la masse. Tension que l’on nomme Vref.

Vref sur le A4988
Pour le a4988, la formule de Vref est la suivante :
VREF = Imax x 8 x Rsense

Rsense correspond à la valeur d’une ou deux résistance qu’on retrouve sur le chipset. Malheureusement en fonction des modèles la valeur change, il faut donc chercher un peu directement sur le driver. Heureusement, on trouve souvent les même résistances qui sont :
a4988 Polulu: 0.05 Ω → R050
Clone chinois :0.1 Ω → R100
Autre clone Chinois : 0.2 Ω → R200

Dans mon cas, il est noté R100 sur la résistance ce qui correspond à une résistance de 0.1 Ω. Donc :
Vref = 1.19 ∙ 8 ∙ 0.1 = 0.952V

Il faut donc tourner le potentiomètre afin que la tension prise entre le centre du potentiomètre et la masse soit de 0.95V.

Vref sur le DRV8825

Sur le DRV8825, le calcul est encore plus simple, déjà car il n’y a pas d’incertitude sur la valeur des résistances. La formule de Vref est :
VREF = Current Limit / 2
Notre courant max étant toujours 1.19A.
Vref = 1.19 / 2 = 0.595A

Tableau récapitulatif:

tableau_a4988_drv8825.png (31.11 Kio) Consulté 3234 fois

Attention : La partie en surligné jaune nécessite un système de refroidissement du chipset. Mieux vaut ne pas y aller.

Code de l'arduino :
Pour generer le signale carré, l'arduino à besoin d'un petit programme. Vous trouverez ce code source en pièce jointe. J'utilise la librairie StepperDriver. Ça facilite bien les choses, du coup le programme est assez court.

sources.txt

(1.72 Kio) Téléchargé 162 fois

Réalisation :

Une petite photo du circuit actuel.

PXL_20201101_200203041 - Copie.jpg (200.05 Kio) Consulté 1427 fois

Voila c’était à peu prêt tout. Toutes mes excuses à ceux qui se sont endormi avant la fin. J’espère que ce post bricolage sera peut être un jour utile à quelqu'un.
Pour le moment le moteur fonctionne mais la table n'existe toujours pas et nul doute que j'aurai encore des surprises à découvrir et résoudre.

Il y a encore pas mal de chose à faire sur le circuit et le code pour qu'il soit totalement intégré à la table. Je pense notamment à un réglage de la vitesse via potentiomètre et aussi des fins de courses déclenchées par capteurs de position, mais ce sera pour plus tard.

N’hésitez pas à critiquer, corriger et ajoutez vos remarques.

[Guimby]

J'étais passé à côté de ce post! Très intéressant! Je me le met de côté pour finir de le lire ce soir...

[Obititi]

Bonjour,
Whaouu, tu vas loin
Moi, je me suis pas embêté autant et ca fonctionne bien, un petit TB6600 et ca suffit, en plus de l'arduino nano.
J'ai opté pour une vis sans fin pour la démultiplication.
Et j'en ai 2 autres pour le goto qui fonctionne pas mal du tout.
Je mettrais bien des photos mais impossible avec mon téléphone.
Thierry.

[Obititi]

Le code, un peu long, car j'ai ajouté des fonctions de pilotage. J'utilise AccelStepper :

#include <AccelStepper.h>
#define C_MotorAzimuteStepPin 2
#define C_MotorAzimuteDirPin 3
#define C_MotorHauteurStepPin 4
#define C_MotorHauteurDirPin 5
#define C_MotorSideralStepPin 6
#define C_MotorSideralDirPin 7
#define motorInterfaceType 1
String V_SerialInput; String V_SerialCmd; String V_Hauteur; long V_HauteurLong; String V_Azimute; long V_AzimuteLong;
AccelStepper V_StepperAzimute = AccelStepper(motorInterfaceType, C_MotorAzimuteStepPin, C_MotorAzimuteDirPin);
AccelStepper V_StepperHauteur = AccelStepper(motorInterfaceType, C_MotorHauteurStepPin, C_MotorHauteurDirPin);
AccelStepper V_StepperSideral = AccelStepper(motorInterfaceType, C_MotorSideralStepPin, C_MotorSideralDirPin);
void setup() {
Serial.begin(57600);
V_StepperHauteur.setMaxSpeed(1000);
V_StepperHauteur.setAcceleration(100);
V_StepperAzimute.setMaxSpeed(1000);
V_StepperAzimute.setAcceleration(100);
V_StepperSideral.setMaxSpeed(10000); // Retour sidérale / Avance sidéral=272
V_StepperSideral.setAcceleration(1000);
}
void loop() {
if (Serial.available() > 0) { // Test si texte présent dans liaison série
while (Serial.available() > 0){
V_SerialCmd = Serial.readStringUntil(':'); // Doit être de la forme exemple goto:10:-20
V_Hauteur = Serial.readStringUntil(':'); V_HauteurLong = V_Hauteur.toInt(); // Séparation de la chaine de caractères.
V_Azimute = Serial.readStringUntil(':'); V_AzimuteLong = V_Azimute.toInt();
}
if (V_SerialCmd == "goto"){
Serial.println(V_SerialCmd); // Si la commande débute par goto
V_StepperHauteur.setMaxSpeed(1000);
V_StepperHauteur.setAcceleration(100);
V_StepperHauteur.move(V_HauteurLong); Serial.println(V_HauteurLong); //Positif = Descend / Déplace étoile vers le haut
V_StepperAzimute.setMaxSpeed(1000);
V_StepperAzimute.setAcceleration(100);
V_StepperAzimute.move(V_AzimuteLong); Serial.println(V_AzimuteLong); //Positif = Anti-horaire / Déplace etoile vers la droite
}
if (V_SerialCmd == "retour"){
V_StepperSideral.setAcceleration(1000); // Retour rapide de la table
V_StepperSideral.setMaxSpeed(20000);
V_StepperSideral.move(-9000000); Serial.println("Retour");
}
if (V_SerialCmd == "sideral"){ // Avance de la table vitesse sidérale
V_StepperSideral.setAcceleration(1000);
V_StepperSideral.setMaxSpeed(272); Serial.println("Sideral");
V_StepperSideral.move(9000000);
}
if (V_SerialCmd == "rapide"){ // Avance rapide de la table
V_StepperSideral.setAcceleration(1000);
V_StepperSideral.setMaxSpeed(20000); Serial.println("Rapide");
V_StepperSideral.move(9000000);
}
if (V_SerialCmd == "stop"){ // Arrêt d'urgence des mouvements
V_StepperHauteur.setAcceleration(100); Serial.println("Stop");
V_StepperHauteur.setMaxSpeed(0);
V_StepperHauteur.move(0);
V_StepperAzimute.setAcceleration(100);
V_StepperAzimute.setMaxSpeed(0);
V_StepperAzimute.move(0);
V_StepperSideral.setAcceleration(100);
V_StepperSideral.setMaxSpeed(0);
V_StepperSideral.move(0);
}
}
V_StepperAzimute.run(); // Avance de 1 pas à chaque Loop
V_StepperHauteur.run();
V_StepperSideral.run();
}

[lordzurp]

Le code, un peu long, car j'ai ajouté des fonctions de pilotage. J'utilise AccelStepper :

Code : Tout sélectionner

#include <AccelStepper.h>
#define C_MotorAzimuteStepPin 2
#define C_MotorAzimuteDirPin 3
#define C_MotorHauteurStepPin 4
#define C_MotorHauteurDirPin 5
#define C_MotorSideralStepPin 6
#define C_MotorSideralDirPin 7
#define motorInterfaceType 1
String V_SerialInput; String V_SerialCmd; String V_Hauteur; long V_HauteurLong; String V_Azimute; long V_AzimuteLong;
AccelStepper V_StepperAzimute = AccelStepper(motorInterfaceType, C_MotorAzimuteStepPin, C_MotorAzimuteDirPin);
AccelStepper V_StepperHauteur = AccelStepper(motorInterfaceType, C_MotorHauteurStepPin, C_MotorHauteurDirPin);
AccelStepper V_StepperSideral = AccelStepper(motorInterfaceType, C_MotorSideralStepPin, C_MotorSideralDirPin);
void setup() {
  Serial.begin(57600);
  V_StepperHauteur.setMaxSpeed(1000);
  V_StepperHauteur.setAcceleration(100);
  V_StepperAzimute.setMaxSpeed(1000);
  V_StepperAzimute.setAcceleration(100);
  V_StepperSideral.setMaxSpeed(10000); // Retour sidérale / Avance sidéral=272
  V_StepperSideral.setAcceleration(1000);
}
void loop() {
  if (Serial.available() > 0) { // Test si texte présent dans liaison série
      while (Serial.available() > 0){
      V_SerialCmd = Serial.readStringUntil(':'); // Doit être de la forme exemple goto:10:-20
      V_Hauteur = Serial.readStringUntil(':'); V_HauteurLong = V_Hauteur.toInt(); // Séparation de la chaine de caractères.
      V_Azimute = Serial.readStringUntil(':'); V_AzimuteLong = V_Azimute.toInt();
      }
        if (V_SerialCmd == "goto"){
        Serial.println(V_SerialCmd); // Si la commande débute par goto
        V_StepperHauteur.setMaxSpeed(1000);
        V_StepperHauteur.setAcceleration(100);
        V_StepperHauteur.move(V_HauteurLong); Serial.println(V_HauteurLong); //Positif = Descend / Déplace étoile vers le haut
        V_StepperAzimute.setMaxSpeed(1000);
        V_StepperAzimute.setAcceleration(100);
        V_StepperAzimute.move(V_AzimuteLong); Serial.println(V_AzimuteLong); //Positif = Anti-horaire / Déplace etoile vers la droite
        }
        if (V_SerialCmd == "retour"){
        V_StepperSideral.setAcceleration(1000); // Retour rapide de la table
        V_StepperSideral.setMaxSpeed(20000);
        V_StepperSideral.move(-9000000); Serial.println("Retour");
        }
        if (V_SerialCmd == "sideral"){ // Avance de la table vitesse sidérale
        V_StepperSideral.setAcceleration(1000);
        V_StepperSideral.setMaxSpeed(272); Serial.println("Sideral");
        V_StepperSideral.move(9000000);
        }
        if (V_SerialCmd == "rapide"){ // Avance rapide de la table
        V_StepperSideral.setAcceleration(1000);
        V_StepperSideral.setMaxSpeed(20000); Serial.println("Rapide");
        V_StepperSideral.move(9000000);
        }
        if (V_SerialCmd == "stop"){ // Arrêt d'urgence des mouvements
        V_StepperHauteur.setAcceleration(100); Serial.println("Stop");
        V_StepperHauteur.setMaxSpeed(0);
        V_StepperHauteur.move(0);
        V_StepperAzimute.setAcceleration(100);
        V_StepperAzimute.setMaxSpeed(0);
        V_StepperAzimute.move(0);
        V_StepperSideral.setAcceleration(100);
        V_StepperSideral.setMaxSpeed(0);
        V_StepperSideral.move(0);
        }
    }
  V_StepperAzimute.run(); // Avance de 1 pas à chaque Loop
  V_StepperHauteur.run();
  V_StepperSideral.run();
}

mieux avec la balise qui va bien

@soulearth j'avais zappé ce post aussi !

pour les drivers stepper, il y a la gamme au dessus, les TMC, qui montent à 256 microsteps si besoin

[Obititi]

Je ne sais pas si tu parles de la même chose, mes drivers fonctionnent en 64 000 pas. Ma vitesse en mode sidéral est à 272 pas / sec, j'ai de la marge pour descendre si besoin.

[soulearth]

Noël oblige. Réponse rapide.
Merci messieurs. Effectivement j'ai essayé d'aller loin car l'aspect théorique me plaît autant que la pratique. Je voulais surtout apprendre et comprendre.
Je regarderai les TMC. Cependant sauf si je me plante, il me semble de mémoire que la précision mécanique ( limité ) de mon moto réducteur ne permet pas de vraiment exploiter un résolution moteur bien meilleure. Le moto-réducteur devenant l'élément limitant.

Niveau code pour l'instant c'est très basique effectivement. J'aimerais inclure des interruptions pour arrêter le déplacement lors d'une détection de fin de course... A réfléchir.

Après je découvre, donc je suis sur qu'il y avait certainement mieux a faire sur plein de points.@lordzurp le circuit électronique doit te faire sourire tellement c'est amateur. Tu aurais fait bien mieux.

[lordzurp]

@lordzurp le circuit électronique doit te faire sourire tellement c'est amateur. Tu aurais fait bien mieux.

l'important c'est de faire !
peu importe le niveau, faire avec ce qu'on a, ce qu'on sait, et apprendre ce qu'on ne sait pas

ya plein de domaines où je suis une quiche