Maîtriser les moteurs pas à pas avec Arduino : guide complet

Dans ce tutoriel, nous apprendrons tout ce qu'il faut savoir pour contrôler des moteurs pas à pas avec Arduino. Nous couvrirons le contrôle d'un moteur pas à pas NEMA17 en combinaison avec un pilote A4988, un DRV8825 et un TMC2208.

Cette combinaison de moteurs et pilotes est utilisée dans d'innombrables applications où le contrôle de position est nécessaire : imprimantes 3D, machines CNC, robotique, machines d'automatisation, etc.

Je l'ai moi-même utilisée dans plusieurs de mes projets Arduino, comme :

• Slider caméra DIY
• Machine à plier fil 3D
• Machine de découpe mousse DIY
• Graveur laser DIY
• Traceur à stylo avec changeur automatique
• Bras robot SCARA

J'expliquerai en détail leur fonctionnement, comment connecter les moteurs pas à pas à Arduino, comment régler la limite de courant des pilotes et comment les programmer avec ou sans bibliothèque Arduino. Je montrerai aussi comment contrôler facilement plusieurs moteurs pas à pas en utilisant un shield CNC Arduino pour tout type de projet.

Nous avons beaucoup à couvrir. Vous pouvez regarder la vidéo suivante ou lire le tutoriel écrit ci-dessous qui inclut tous les codes d'exemple et schémas de câblage.

Qu'est-ce qu'un moteur pas à pas et comment fonctionne-t-il ?

Je commence par expliquer brièvement ce qu'est un moteur pas à pas et son fonctionnement, ce qui aidera à mieux comprendre la suite.

Un moteur pas à pas est un type unique de moteur DC sans balais dont la position peut être contrôlée avec précision même sans retour d'information (feedback).

Son principe repose sur les champs magnétiques. Il a deux composants principaux : un stator et un rotor. Le rotor est généralement un aimant permanent entouré de bobines sur le stator.

Quand on alimente les bobines (courant traversant), des champs magnétiques spécifiques sont générés dans le stator, attirant ou repoussant le rotor. En activant les bobines étape par étape, l'une après l'autre dans un ordre précis, on obtient un mouvement continu du rotor, mais on peut aussi l'arrêter à n'importe quelle position.

C'est pourquoi on les appelle moteurs pas à pas : ils se déplacent par pas discrets.

En augmentant le nombre de pôles magnétiques sur le rotor, on augmente le nombre de positions d'arrêt possibles, donc la résolution ou la précision. Notez que c'est une explication basique ; plus de détails dans mon tutoriel « Comment fonctionnent les moteurs pas à pas ».

Un moteur pas à pas typique, NEMA17 par exemple, a 50 points d'arrêt ou pas sur le rotor. Le stator peut avoir plusieurs bobines organisées en deux phases offrant quatre orientations de champ magnétique différentes.

Les 50 pas du rotor multipliés par les 4 orientations donnent 200 pas pour une rotation complète. Soit 360° / 200 = 1,8° par pas.

J'ai dit que les bobines du stator sont en deux phases, ce qu'on voit aussi au nombre de fils : 4 fils, deux par phase. Les 4 orientations sont possibles car on peut faire circuler le courant dans les deux sens dans chaque phase.

Il existe aussi des moteurs à 5, 6 ou 8 fils, mais ils fonctionnent toujours sur deux phases ou se contrôlent avec quatre bornes. Ils offrent des caractéristiques différentes (couple, vitesse) selon le câblage sur les quatre bornes de contrôle.

Bref, pour piloter un moteur pas à pas, on ne peut pas juste brancher l'alimentation : il faut alimenter les deux phases dans les deux sens et envoyer des impulsions dans un ordre et une séquence temporelle précis. D'où la nécessité de pilotes.

Il existe de nombreux types et tailles de pilotes, correspondant aux moteurs. Mais le principe de base est le même : ils ont deux ponts en H permettant d'alimenter les phases dans les deux sens. Bien sûr, ils ont d'autres fonctions : micro-pas, limitation de courant, etc., qui facilitent le contrôle.

Comment contrôler un moteur NEMA17 avec Arduino et pilote A4988

Passons au premier exemple : contrôler un moteur NEMA17 avec un pilote A4988.

Le NEMA17 est le moteur pas à pas le plus populaire chez les makers, offrant de bonnes performances à prix abordable. On le trouve dans presque toutes les imprimantes 3D de bureau et graveurs laser.

Généralement, le NEMA17 a 200 pas (1,8°/pas), mais il existe des modèles 400 pas (0,9°/pas). Notez que la désignation NEMA17 décrit seulement la taille de la face avant : le chiffre divisé par 10 donne la taille en pouces (1,7 pouces pour NEMA17, 2,3 pour NEMA23). La taille de face est fixe, mais la longueur varie de 20 à 60 mm, tout comme la consommation de courant (0,3 A à 2,5 A).

Selon le courant nominal du moteur, il faut choisir un pilote capable de le gérer. Le plus populaire pour NEMA17 est l'A4988.

L'A4988 a un courant max de 2 A par bobine (pic), mais il est recommandé de rester vers 1 A, sauf bon refroidissement. Une excellente fonction : la limitation de courant. On peut régler le courant que le moteur tirera, indépendamment de son nominal. Exemple : on peut brancher un moteur 2,5 A mais limiter le pilote à 1,5 A. Le moteur ne sera pas à pleine capacité, mais utilisable. Inversement, si le moteur est nominalement plus bas que la limite du pilote, il surchaufferait. Il est recommandé d'assurer la correspondance entre nominal moteur et pilote.

Connexion A4988 et Arduino

Voyons comment connecter le pilote A4988, le moteur et l'Arduino.

Composants nécessaires (liens affiliés) :

• Moteur pas à pas NEMA 17 – Amazon / Banggood / AliExpress
• Pilote A4988 – Amazon / Banggood / AliExpress
• Pilote DRV8825 – Amazon / Banggood / AliExpress
• Pilote TMC2208 – Amazon / Banggood / AliExpress
• Shield CNC Arduino – Amazon / Banggood / AliExpress
• Arduino Uno – Amazon / Banggood / AliExpress

Note : liens affiliés. En tant qu'associé Amazon, je gagne sur les achats qualifiants.

En haut à droite du pilote : broches VMOT et GND pour l'alimentation moteur (8-36 V). Un condensateur de découplage (≥ 47 µF) est recommandé entre ces broches pour protéger des pics de tension.

Ensuite, 4 broches pour le moteur : une phase sur 1A/1B, l'autre sur 2A/2B.

Parfois difficile d'identifier quels fils forment une phase. Méthodes simples : tourner l'axe à la main, puis relier deux fils ensemble ; si c'est une phase, la rotation devient plus difficile. Ou utiliser un multimètre en mode continuité : bip = court-circuit = phase. Une fois identifiée, on la connecte à n'importe quelle position (ordre indifférent).

Broches d'alimentation logique : VDD et GND (3-5 V). Côté opposé : broches Step et Direction, à connecter sur n'importe quelle broche Arduino. Direction = sens de rotation ; Step = impulsions de pas. Chaque impulsion sur Step avance d'un pas dans la direction choisie.

Au-dessus : broches Sleep et Reset (actives à l'état bas). Sleep est HIGH par défaut, Reset flottant. Pour activer le pilote simplement, reliez Sleep et Reset ensemble (si on n'utilise pas ces fonctions).

Broche Enable aussi active bas : tant qu'on ne la met pas HIGH, le pilote est activé.

Broches MS1, MS2, MS3 : sélection de la résolution de pas (micro-pas). Le moteur a sa résolution propre (200 pas/révolution pour NEMA17). Mais les pilotes ont le micro-pas : alimenter les bobines à des niveaux de courant intermédiaires pour créer des positions intermédiaires. Exemple : quart de pas → 200 × 4 = 800 micro-pas/révolution. L'A4988 va jusqu'à 1/16 de pas (3200 pas/révolution, 0,1125°/pas). Il existe des pilotes jusqu'à 256 micro-pas (51200 pas/révolution, 0,007°/pas).

Ces trois broches ont des résistances de pull-down : si laissées déconnectées, mode pas complet. Pour autre résolution, appliquer 5 V sur les broches selon le tableau.

Limitation de courant A4988

Avant de programmer, une étape cruciale : régler la limite de courant du pilote.

Il faut la régler en dessous du courant nominal du moteur, sinon surchauffe. Un petit potentiomètre sur l'A4988 permet ce réglage. Sens horaire = augmente, anti-horaire = diminue. Deux méthodes pour déterminer la valeur réelle :

Méthode 1 : Mesurer la tension de référence (Vref) aux bornes du potentiomètre et GND. Formule :

Limite de courant = Vref / (8 × Rcs)

Rcs = résistance de détection de courant (valeur des résistances de détection près de la puce). Selon fabricants : 0,05, 0,1 ou 0,2 Ω. Il faut vérifier la valeur sur la carte. Dans mon cas, résistances marquées R100 = 0,1 Ω.

Exemple : Vref = 0,7 V, Rcs = 0,1 Ω → limite = 0,875 A. Pour limiter à 1 A, régler Vref à 0,8 V.

Méthode 2 : Mesurer directement le courant dans les bobines. Brancher moteur et pilote comme expliqué. Pas besoin de contrôleur, mais connecter 5 V sur Step et Direction pour que le moteur maintienne une position. Broches MS déconnectées (mode pas complet). Débrancher une bobine et insérer un ampèremètre en série. Alimenter le pilote (logique 5 V, moteur 12 V) et lire le courant.

Attention : en mode pas complet, le courant dans les bobines n'atteint que 70 % de la limite réelle. En mode micro-pas, multiplier la lecture par 1,3 pour obtenir la limite réelle.

Les deux méthodes m'ont donné des résultats approximativement identiques.

Moteurs pas à pas et Arduino – Codes d'exemple

Passons à la programmation Arduino, avec plusieurs codes d'exemple.

Exemple 1 : contrôle basique sans bibliothèque

/* 
 * Exemple basique contrôle moteur pas à pas sans bibliothèque
 * par Dejan, https://howtomechatronics.com
 */
// définition des broches
#define stepPin 2
#define dirPin 5
void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}
void loop() {
  digitalWrite(dirPin, HIGH); // direction
  // 200 impulsions = 1 tour complet (mode pas complet)
  for(int x = 0; x < 800; x++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(700); // changer ce délai change la vitesse
    digitalWrite(stepPin, LOW);
    delayMicroseconds(700);
  }
  delay(1000);
  digitalWrite(dirPin, LOW); // inverse direction
  // 400 impulsions = 2 tours
  for(int x = 0; x < 1600; x++) {
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  delay(1000);
}

Description du code :

On définit les broches STEP et DIR comme sorties. Dans loop, on met Direction HIGH, puis une boucle « for » envoie 200 impulsions sur STEP pour un tour complet (mode pas complet). Les impulsions sont générées en basculant STEP HIGH/LOW avec un délai entre elles. Ce délai définit la vitesse : plus court = plus rapide. Puis on inverse la direction et on envoie 400 impulsions pour deux tours. Si on change le micro-pas (ex. quart de pas → 800 pas/révolution), la première boucle ne fera que 90° et la seconde un demi-tour.

Exemple 2 : contrôle de vitesse par potentiomètre

/* Exemple contrôle vitesse par potentiomètre sans bibliothèque
 * par Dejan, https://howtomechatronics.com
 */
#define stepPin 2
#define dirPin 5
int customDelay, customDelayMapped;
void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}
void loop() {
  speedControl();
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(customDelayMapped);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(customDelayMapped);
}
void speedControl() {
  customDelay = analogRead(A0); // lecture potentiomètre
  customDelayMapped = map(customDelay, 0, 1023, 300, 3000); // conversion 0-1023 → 300-3000 µs
}

Description :

On lit la valeur du potentiomètre (0-1023) et on la convertit en délai en microsecondes pour les impulsions Step. J'ai trouvé 300 µs comme minimum ; en dessous, le moteur saute des pas. Cette méthode est simple mais limitée aux contrôles simples. Pour du complexe, mieux vaut utiliser une bibliothèque.

Contrôler les moteurs pas à pas avec Arduino et la bibliothèque AccelStepper – Exemples

La bibliothèque la plus populaire est AccelStepper de Mike McCauley. Extrêmement polyvalente : contrôle vitesse, accélération/décélération, positions cibles, contrôle simultané de plusieurs moteurs, etc. Documentation excellente. Je l'ai utilisée pour mes projets (slider caméra, machine pliage fil 3D, bras SCARA, etc.). Détails et codes sur le site.

Exemple : contrôle vitesse moteur par potentiomètre avec AccelStepper

/* 
 * Exemple basique contrôle pas à pas avec AccelStepper
 * par Dejan, https://howtomechatronics.com
 */
#include 
// Définition moteur et broches
AccelStepper stepper1(1, 2, 5); // (Type pilote: 2 broches STEP, DIR)
void setup() {
  stepper1.setMaxSpeed(1000); // vitesse max en pas/seconde
}
void loop() {
  stepper1.setSpeed(analogRead(A0)); // vitesse selon potentiomètre (0-1023)
  stepper1.runSpeed(); // fait tourner à vitesse constante
}

Description :

Inclure la bibliothèque (installer via gestionnaire bibliothèques Arduino IDE : rechercher « AccelStepper »). Créer une instance AccelStepper : premier paramètre = type pilote (1 pour 2 broches), les deux suivants = numéros broches. Si plusieurs moteurs, définir chacun (ex. stepper1, stepper2). Dans setup, setMaxSpeed (pas/seconde), max 4000 mais >1000 peut être instable. Dans loop, setSpeed() avec la lecture analogique, puis runSpeed() à chaque intervalle. Valeur négative = rotation inverse.

Exemple : contrôle de deux moteurs avec accélération/décélération

/* Contrôle de deux moteurs avec AccelStepper
 * par Dejan, https://howtomechatronics.com
 */
#include 
AccelStepper stepper1(1, 2, 5);
AccelStepper stepper2(1, 3, 6);
void setup() {
  stepper1.setMaxSpeed(1000);
  stepper1.setAcceleration(500);
  stepper1.setCurrentPosition(0);
  stepper2.setMaxSpeed(1000);
  stepper2.setAcceleration(500);
  stepper2.setCurrentPosition(0);
}
void loop() {
  stepper1.moveTo(800); // 800 pas = 1 tour (quart de pas)
  stepper1.runToPosition(); // mouvement bloquant jusqu'à position
  stepper2.moveTo(1600);
  stepper2.runToPosition();
  // Retour position 0 avec run() non-bloquant : les deux bougent simultanément
  stepper1.moveTo(0);
  stepper2.moveTo(0);
  while (stepper1.currentPosition() != 0 || stepper2.currentPosition() != 0) {
    stepper1.run(); // non-bloquant, implémente accel/decel
    stepper2.run();
  }
}

Description :

Définir deux moteurs. Dans setup, setAcceleration() et setCurrentPosition(0). Dans loop, moveTo() dit au moteur quelle position cible (800 pas = 1 tour en quart de pas). runToPosition() déplace avec accel/decel mais bloque jusqu'à arrivée. Pour mouvement simultané non-bloquant, utiliser run() dans une boucle while jusqu'à ce que les deux atteignent 0. On peut ajouter d'autres instructions dans le while. La doc de la bibliothèque détaille toutes les méthodes.

Exemple : contrôle coordonné de plusieurs moteurs avec AccelStepper et MultiStepper

/* Contrôle multiple coordonné avec AccelStepper et MultiStepper
 * par Dejan, https://howtomechatronics.com
 */
#include 
#include 
AccelStepper stepper1(1, 2, 5);
AccelStepper stepper2(1, 3, 6);
AccelStepper stepper3(1, 4, 7);
MultiStepper steppersControl;
long gotoposition[3]; // tableau positions cibles
void setup() {
  stepper1.setMaxSpeed(1000);
  stepper2.setMaxSpeed(1000);
  stepper3.setMaxSpeed(1000);
  steppersControl.addStepper(stepper1);
  steppersControl.addStepper(stepper2);
  steppersControl.addStepper(stepper3);
}
void loop() {
  gotoposition[0] = 800;  // 1 tour
  gotoposition[1] = 1600; // 2 tours
  gotoposition[2] = 3200; // 3 tours
  steppersControl.moveTo(gotoposition); // calcule vitesses requises
  steppersControl.runSpeedToPosition(); // bloque jusqu'à position
  delay(1000);
  gotoposition[0] = 0;
  gotoposition[1] = 0;
  gotoposition[2] = 0;
  steppersControl.moveTo(gotoposition);
  steppersControl.runSpeedToPosition();
  delay(1000);
}

Description :

Inclure MultiStepper, créer instance, définir tableau « long » pour positions cibles. Dans setup, setMaxSpeed et ajouter les steppers à l'instance MultiStepper. Dans loop, remplir le tableau avec positions cibles (1, 2, 3 tours), moveTo() calcule les vitesses pour arrivée simultanée, runSpeedToPosition() bloque jusqu'à arrivée. On pourrait utiliser run() pour non-bloquant. Attention : MultiStepper ne gère pas l'accélération/décélération. Pour plus d'exemples avancés, voir mes projets Arduino sur le site.

Shield CNC pour contrôler plusieurs moteurs pas à pas sur tout projet Arduino

Le shield CNC Arduino sert principalement à contrôler des machines CNC 2 ou 3 axes, mais c'est une excellente option pour tout projet nécessitant plusieurs moteurs pas à pas : compact, connexions faciles pour pilotes et moteurs.

Ce shield s'emboîte sur un Arduino UNO, contrôle jusqu'à 4 moteurs pas à pas individuels, et laisse toutes les autres broches Arduino disponibles. Je l'ai utilisé avec un Arduino UNO pour mon bras robot SCARA 4 axes.

Je mettrai à jour cette section avec plus de détails sur l'utilisation du shield CNC avec Arduino prochainement.

DRV8825 vs A4988

Passons au DRV8825. Tout ce qu'on a expliqué pour l'A4988 s'applique au DRV8825 : principe, connexions, code presque identiques. Différences techniques :

• Courant max sans refroidissement additionnel : 1,5 A (DRV8825) vs 1 A (A4988)
• Tension d'alimentation max : 45 V vs 35 V
• Résolution micro-pas max : 1/32 vs 1/16

Autres différences mineures : potentiomètre de limite de courant à emplacement différent, relation Vref/courant différente. Le DRV8825 n'a pas besoin d'alimentation logique, cette broche devient sortie FAULT. On peut connecter FAULT directement à 5 V pour l'utiliser en remplacement direct de l'A4988.

Attention : quand on remplace un A4988 par un DRV8825, bien vérifier l'orientation. Potentiomètre sous la puce sur A4988, au-dessus sur DRV8825 – confusion facile, montage à l'envers possible.

Pour régler la limite de courant, mesurer Vref (sonde sur GND, autre sur potentiomètre). Formule :

Limite de courant = Vref × 2

Pour le micro-pas, utiliser le tableau correspondant.

Globalement, le DRV8825 est meilleur que l'A4988 : courant et tension plus élevés, micro-pas plus fin → fonctionnement plus fluide et silencieux.

Pilote TMC2208

Pour encore plus de fluidité et silence, regardons le TMC2208. Puce de Trinamic (Allemagne), spécialiste électronique de mouvement. Pilote silencieux, remplacement direct pour systèmes A4988/DRV8825. Largement utilisé dans imprimantes 3D, graveurs laser, scanners.

Ce qui le distingue : unité d'interpolation intégrée offrant 256 subdivisions (micro-pas). Contrôle sinusoïdal parfait généré en interne. Le pilote sort 256 micro-pas au moteur, quelle que soit la résolution sélectionnée via les deux broches MS (2, 4, 8, 16 micro-pas). Cela donne un fonctionnement plus fluide et allège la charge du microcontrôleur.

Cette caractéristique, combinée à la technologie StealthChop2 de contrôle de courant sans bruit, assure un contrôle ultra-silencieux.

Niveaux de bruit des pilotes : A4988 ~65 dB, DRV8825 ~67 dB, TMC2208 ~41 dB. Le TMC2208 pilote les moteurs en silence total, impressionnant.

Courant nominal TMC2208 : 1,2 A (pic 2 A), légèrement supérieur à l'A4988. Réglage limite de courant : même méthode, mesurer Vref (sonde GND, autre sur le plot près de la broche Enable). Formule :

Limite de courant = Vref × 0,71

Bien que remplacement direct, le TMC2208 a un brochage légèrement différent : seulement deux broches MS pour la résolution, et pour activer le pilote il faut connecter Enable à GND.

Côté code, c'est identique aux deux autres.

Le TMC2208 a d'autres fonctions avancées : interface UART simple pour contrôler le pilote sur une seule ligne (au lieu de Step/Dir), plus d'options de réglage et contrôle.

Globalement, le TMC2208 est supérieur à l'A4988 et au DRV8825, mais plus cher. Si vous n'avez pas besoin de ces extras et que le bruit ne vous gêne pas, les deux autres restent d'excellents choix.

Conclusion

Nous avons couvert l'essentiel pour contrôler des moteurs pas à pas avec Arduino. Le NEMA17 et les trois pilotes (A4988, DRV8825, TMC2208) sont incroyablement polyvalents pour toutes applications nécessitant un contrôle de position. Pour en savoir plus, explorez mes projets Arduino.

Si vous voulez apprendre à contrôler des moteurs plus gros (NEMA23, NEMA34), j'aurai un tutoriel dédié.

J'espère que ce tutoriel vous a plu et apporté de nouvelles connaissances. N'oubliez pas de vous abonner et n'hésitez pas à poser vos questions dans les commentaires.