Moteurs pas à pas

Les moteurs pas à pas sont très utilisé pour les mouvements précis, comme le déplacement de la tête d’une imprimante 3D.
Pour les contrôler il faut envoyer des impulsions selon une séquence prédéfinie : ceci peut être fait par la carte Arduino ou un driver dédié.

Driver moteur A4988 #

Caractéristiques #

Driver reconnaissable à sa couleur rouge ou verte, il est très souvent utilisé sur les shields CNC (3 pour le shield CNC NANO, 4 pour le shield CNC UNO, et 5 pour le shield CNC Mega). L’utilisation de ces shields simplifie les branchements, il est intéressant de les utiliser même si vous voulez contrôler les moteurs sans passer par GRBL ou Marlin.

Régler le courant limite #

Le potentiomètre à la surface du driver permet de définir le courant maximum que le driver va délivrer au moteur. Augmenter le courant augmente la puissance au prix d’un échauffement supplémentaire pouvant causer une dégradation du moteur, et du driver s’il n’est pas équipé d’un dissipateur thermique.

Dans un premier temps identifiez la résistance R_cs du driver. Les valeurs courantes sont : 0.050 Ω, 0.068 Ω ou 0.1 Ω. Le mieux est d’obtenir cette information de votre vendeur. Sinon vous pouvez vous armer d’une bonne loupe (ou une caméra en mode macro) et lire le code à 4 caractères sur la résistance. Oui c’est très petit une résistance CMS !
Un code « R100 » indique une résistance de 0.1 Ω, pour 0.068 Ω vous lirez « R068 » et pour 0.050 Ω « R050 ».

Pour obtenir le courant limite, divisez la valeur mesurée par 8 fois R_cs : I_max = V_mesure / (8 * R_cs)
Ajustez le potentiomètre jusqu’à obtenir la valeur souhaitée. Attention à ne pas toucher et court-circuiter d’autres parties du driver pendant la manipulation.

Exemple d’utilisation #

#define PIN_DIR 2   //permet d'indiquer la direction de rotation du moteur
#define PIN_STEP 3  //y envoyer une impulsion effectue une step.
#define STEPS_PAR_REVOLUTION 200   //200 pour un moteur NEMA17 en full step ; 2048 pour un 28BYJ-48

void setup() {
    pinMode(PIN_DIR, OUTPUT);
    pinMode(PIN_STEP, OUTPUT);
}

void loop() {
    digitalWrite(PIN_DIR, HIGH); //sens horaire, LOW pour inverser

    //Ces 4 lignes commandent 1 step
    digitalWrite(PIN_STEP, HIGH);
    delayMicroseconds(2000); //lent. 500 est rapide
    digitalWrite(PIN_STEP, LOW);
    delayMicroseconds(2000);
}

En savoir plus : cet article explique en détail le fonctionnement du driver.

Un autre driver, le DRV8825 #

MS1	MS2	MS3	Résolution
0	0	0	1 step
1	0	0	1/2 step
0	1	0	1/4 step
1	1	0	1/8 step
0	0	1	1/16 step
1	0	1	1/32 step

Ce driver est interchangeable avec le A4988 : les branchements et codes évoqués précédemment fonctionnent aussi.
Il permet d’augmenter le microstepping à 1/32.
De plus la puissance maximum est augmentée : ce module accepte de 8.2 à 45V et une intensité jusqu’à 1,5A par phase, 2,2A à 2,5A avec un refroidissement adapté.

Pour régler l’intensité maximum vous pouvez mesurer la tension entre le point de référence (ou le corps du potentiomètre) et la masse, et diviser cette valeur par 2 (ou par 4, selon le vendeur…).

En apprendre plus avec cet article.

Utiliser plusieurs moteurs : la librairie Accel Stepper #

Cette librairie permet de contrôler jusqu’à 10 moteurs et prend en charge aussi bien un moteur connecté à un driver ou un moteur connecté sans driver sur un simple relai pour lequel il faut piloter 2, 3 ou 4 fils.
Un descriptif plus complet des fonctionnalités de la librairie est disponible ici : https://www.airspayce.com/mikem/arduino/AccelStepper/classAccelStepper.html

#include <AccelStepper.h> //sur platformIO ajouter à lib_deps :	"waspinator/AccelStepper"
#define PIN_DIR 2   //permet d'indiquer la direction de rotation du moteur
#define PIN_STEP 3  //y envoyer une impulsion effectue une step.
#define TYPE_INTERFACE_MOTEUR 1  //1 pour un moteur contrôlé par un driver
                                 //2, 3 et 4 pour des moteurs à respectivement 2, 3 ou 4 fils
#define STEPS_PAR_REVOLUTION 200 //200 pour un moteur NEMA17 en full step ; 2048 pour un 28BYJ-48

AccelStepper monMoteur = AccelStepper(TYPE_INTERFACE_MOTEUR , PIN_STEP, PIN_DIR);

void setup() {
  monMoteur.setMaxSpeed(200);     //définir la vitesse maximum, en step/s
  monMoteur.setAcceleration(30);  //définir l'accélération, en step/s²
}

void loop() {
  monMoteur.setCurrentPosition(0);  //définir la position actuelle du moteur, en step
  monMoteur.moveTo(2 * STEPS_PAR_REVOLUTION);	//choisir une position cible en step, ici 2 tours
  monMoteur.runToPosition();	//déplacement avec accélération
}

Il y a 4 fonctions pour commander le déplacement du moteur : celle utilisée dans l’exemple, « runToPosition() », ainsi que « runSpeedToPosition() », « run() » et « runSpeed() ».
« Speed » indique que le déplacement se fait à la vitesse maximum sans prendre en compte l’accélération.
« ToPosition » indique que la fonction est bloquante, le programme ne continuera que quand la position sera atteinte. Au contraire pour « run() » et « runToPosition() » seul une step en direction de la position est effectuée par appelle de la fonction, il faut donc l’appeler en boucle jusqu’à ce que la position soit atteinte (ces fonctions retournent 1 tant que le moteur est en mouvement).

La librairie contient un autre fichier, « MultiStepper.h » qui permet de contrôler plus facilement de nombreux moteurs à la fois. Le code cis dessous ne fonctionne pas en l’état, il faut commencer par déclarer les moteurs « moteur1 » et « moteur2 » comme décrit dans l’exemple précédent.
Plus d’informations sur cette librairie : https://www.airspayce.com/mikem/arduino/AccelStepper/classMultiStepper.html

#include <AccelStepper.h>   //sur platformIO ajouter à lib_deps :	"waspinator/AccelStepper"
#include <MultiStepper.h>
long positions[2]; //2 pour 2 moteurs

//  /!\ définir les moteurs, CF exemple précédent

MultiStepper mesMoteurs; //jusqu’à 10 moteurs pris en charge
void setup() {
  mesMoteurs.addStepper(moteur1);
  mesMoteurs.addStepper(moteur2);

  positions[0] = 1000;    positions[1] = 50;
  mesMoteurs.moveTo(positions);
  mesMoteurs.runSpeedToPosition(); //déplacement sans accélération
}
void loop() {
}

En utilisant ainsi les moteurs il n’est pas possible de prendre en compte l’accélération. Seules deux fonctions permettent de les déplacer :
« runSpeedToPosition() » fonction bloquante, déplace les moteurs en faisant en sorte qu’ils arrivent en même temps.
« run() » fonction qui aurait dû s’appeler « runSpeed() » pour plus de cohérence, elle appelle la fonction « runSpeed() » pour chacun des moteurs. Cette fonction est donc non bloquante et n’utilise pas l’accélération.