Qu'est-ce qu'un moteur pas à pas ? Rotation précise avec le 28BYJ-48 et le ULN2003 sur Arduino

Un moteur pas à pas découpe sa rotation en petits pas égaux. À chaque commande, il tourne d'un angle fixe : tu sais donc exactement où il s'est arrêté, sans aucun capteur. Les imprimantes 3D, les machines CNC, les sliders de caméra et les rideaux automatiques utilisent des moteurs pas à pas pour cette précision. Le moyen le moins cher de débuter avec Arduino, c'est le moteur 28BYJ-48 et la carte driver ULN2003 vendue avec.

Comment fonctionne un moteur pas à pas ?

Un moteur pas à pas contient plusieurs bobines disposées autour d'un rotor aimanté et denté. Quand on alimente les bobines dans un ordre précis, le rotor est attiré à chaque fois vers la bobine la plus proche et avance d'un pas. Si la séquence défile vite, le moteur tourne vite ; lentement, il tourne lentement ; si tu l'inverses, il tourne dans l'autre sens. Comme le moteur compte chaque pas, sa position est connue, mais s'il est surchargé il peut sauter des pas sans s'en rendre compte.

Moteur pas à pas, servo ou moteur à courant continu ?

S'il suffit d'aller à un angle et de le tenir, un servo est plus simple ; tous les détails sont dans Qu'est-ce qu'un servomoteur ? Pour une rotation rapide et continue, un moteur à courant continu avec un driver L298N convient mieux. Pour les tâches qui demandent à la fois plusieurs tours et une position connue, le moteur pas à pas est imbattable.

Caractéristiques techniques du 28BYJ-48

Câblage du driver ULN2003

La prise 5 fils du moteur ne s'enfiche sur la carte ULN2003 que dans un seul sens : impossible de se tromper. Relie les broches IN1–IN4 de la carte aux broches 8–11 de l'Arduino, et ses bornes + et – à une alimentation 5 V. Le ULN2003 est un réseau de transistors Darlington qui amplifie le petit signal de la broche Arduino jusqu'au courant dont la bobine a besoin ; les quatre LED de la carte montrent les bobines qui s'activent tour à tour.

Premier tour avec la bibliothèque Stepper

La bibliothèque Stepper est fournie avec l'Arduino IDE, rien à installer. Le seul piège est l'ordre des broches : pour le 28BYJ-48, l'objet doit être déclaré dans l'ordre 8, 10, 9, 11 (IN1, IN3, IN2, IN4). Si tu écris 8, 9, 10, 11, le moteur vibre sur place au lieu de tourner ; c'est l'erreur la plus fréquente.

1#include <Stepper.h>
2
3const int STEPS_PER_REV = 2048;                  // 28BYJ-48 tam tur / full revolution
4Stepper motor(STEPS_PER_REV, 8, 10, 9, 11);      // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
5
6void setup() {
7  motor.setSpeed(10);                            // devir/dakika, en fazla ~15 / RPM, max ~15
8}
9
10void loop() {
11  motor.step(STEPS_PER_REV);        // bir yönde tam tur / one full turn
12  delay(1000);
13  motor.step(-STEPS_PER_REV / 2);   // ters yönde yarım tur / half a turn back
14  delay(1000);
15}

Contrôle de position avec un potentiomètre

Si tu mémorises la position actuelle du moteur dans une variable, tu peux l'envoyer où tu veux. Le code ci-dessous convertit la position du potentiomètre en 0 à 2048 pas, et le moteur se place au même endroit, comme s'il suivait le bouton. Une tolérance de 10 pas ignore les petites fluctuations. Le branchement du potentiomètre est expliqué dans Qu'est-ce qu'un potentiomètre ?

1#include <Stepper.h>
2
3Stepper motor(2048, 8, 10, 9, 11);
4int position = 0;                                    // şu anki adım / current step
5
6void setup() {
7  motor.setSpeed(12);
8}
9
10void loop() {
11  int target = map(analogRead(A0), 0, 1023, 0, 2048);  // potansiyometre → hedef / pot → target
12  if (abs(target - position) > 10) {                 // küçük titreşimleri yok say / ignore jitter
13    motor.step(target - position);
14    position = target;
15  }
16}

AccelStepper : accélération douce sans bloquer le programme

La commande step() de la bibliothèque Stepper bloque le programme jusqu'à la fin du mouvement ; pendant ce temps, impossible de lire un bouton ou de rafraîchir un écran. AccelStepper, à installer depuis le gestionnaire de bibliothèques, fait avancer le moteur pas à pas en arrière-plan et ajoute accélération et décélération pour éviter les démarrages brusques. Pour le 28BYJ-48, on utilise le mode demi-pas (HALF4WIRE), où un tour fait 4096 pas :

1#include <AccelStepper.h>
2
3// 28BYJ-48 + ULN2003, yarım adım: tur başına 4096 / half-step: 4096 per turn
4AccelStepper motor(AccelStepper::HALF4WIRE, 8, 10, 9, 11);
5
6void setup() {
7  motor.setMaxSpeed(1000);      // adım/saniye / steps per second
8  motor.setAcceleration(400);   // adım/saniye² / steps per second²
9  motor.moveTo(4096);           // bir tur ileri / one turn forward
10}
11
12void loop() {
13  if (motor.distanceToGo() == 0) {
14    motor.moveTo(-motor.currentPosition());   // geri dön / go back
15  }
16  motor.run();                  // her döngüde çağır, bekletmez / call every loop, non-blocking
17}

Des moteurs plus puissants : NEMA 17 et A4988

Pour les tâches qui demandent de la force, comme les imprimantes 3D et les CNC, on utilise des moteurs pas à pas bipolaires comme le NEMA 17. Ils font 200 pas par tour (1,8°) et sont bien plus puissants que le 28BYJ-48. On les pilote avec des drivers comme l'A4988 ou le DRV8825 : à chaque impulsion sur STEP, le moteur avance d'un pas, et la broche DIR fixe le sens. Le driver s'alimente en 8–35 V et, grâce au micro-pas, divise chaque pas jusqu'à 16 fois pour un mouvement plus fluide.

1const int STEP_PIN = 3;
2const int DIR_PIN = 4;
3
4void setup() {
5  pinMode(STEP_PIN, OUTPUT);
6  pinMode(DIR_PIN, OUTPUT);
7}
8
9void loop() {
10  digitalWrite(DIR_PIN, HIGH);          // yön / direction
11  for (int i = 0; i < 200; i++) {       // NEMA 17'de 200 adım = 1 tur / 200 steps = 1 turn
12    digitalWrite(STEP_PIN, HIGH);
13    delayMicroseconds(800);             // küçüldükçe hız artar / smaller = faster
14    digitalWrite(STEP_PIN, LOW);
15    delayMicroseconds(800);
16  }
17  delay(1000);
18}

Moteur pas à pas avec l'ESP32 et le Raspberry Pi Pico

Les entrées du ULN2003 fonctionnent sans souci avec des signaux 3,3 V ; alimente quand même le moteur séparément en 5 V. Sur l'ESP32, la bibliothèque AccelStepper fonctionne telle quelle ; utilise des broches hors de 6–11 et 34–39, par exemple GPIO 19, 18, 5 et 17. Sur le Pico en MicroPython, tu fais tourner le moteur en écrivant tour à tour la séquence demi-pas sur les quatre broches :

1from machine import Pin
2import time
3
4pins = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]      # IN1–IN4 → GP2–GP5
5SEQ = [[1,0,0,0],[1,1,0,0],[0,1,0,0],[0,1,1,0],
6       [0,0,1,0],[0,0,1,1],[0,0,0,1],[1,0,0,1]]    # yarım adım dizisi / half-step sequence
7
8def rotate(steps, delay_ms=2):
9    direction = 1 if steps > 0 else -1
10    for i in range(abs(steps)):
11        for pin, value in zip(pins, SEQ[(i * direction) % 8]):
12            pin.value(value)
13        time.sleep_ms(delay_ms)
14    for pin in pins:
15        pin.value(0)                                   # bobinleri bırak / release coils
16
17rotate(4096)        # bir tur / one turn (half-step)
18rotate(-1024)       # çeyrek tur geri / quarter turn back

Idées de projets avec un moteur pas à pas

• Horloge analogique : une horloge de bureau dont les aiguilles sont entraînées par des moteurs pas à pas.
• Slider de caméra : un rail qui déplace la caméra très lentement pour des timelapses.
• Distributeur de nourriture pour poissons : un mécanisme qui fait tourner sa trémie deux fois par jour pour libérer de la nourriture.
• Panneau qui suit le soleil : oriente un panneau vers le côté le plus lumineux avec deux capteurs de lumière ; pour la partie lumière, vois Capteur de lumière LDR.
• Plateau tournant : un plateau qui fait tourner un objet par angles égaux pour des photos produit ou un scan 3D.
• Rideau automatique : un moteur qui ouvre et ferme le rideau en enroulant sa cordelette et mémorise sa position.

Erreurs fréquentes et solutions

• Le moteur vibre mais ne tourne pas : l'ordre des broches dans la bibliothèque Stepper est faux ; écris 8, 10, 9, 11 au lieu de 8, 9, 10, 11.
• Le moteur saute des pas : la vitesse est trop élevée ou la charge trop lourde ; reste sous 15 tr/min avec le 28BYJ-48 et ajoute une accélération avec AccelStepper.
• L'Arduino redémarre : l'alimentation ne suffit pas ; alimente le moteur avec une source 5 V externe et relie les masses.
• Le moteur chauffe à l'arrêt : les bobines restent alimentées ; mets les quatre broches à LOW une fois le mouvement terminé.
• Le nombre de tours ne colle pas : il y a 2048 pas en pas entier et 4096 en demi-pas, contre 200 pour un NEMA 17. Ne confonds pas le mode et le moteur.
• Le moteur ne tourne pas avec un A4988 : la limite de courant est trop basse, l'alimentation du moteur manque, ou les broches RESET et SLEEP ne sont pas reliées.

Le moteur pas à pas est le moyen le plus simple de dire « tourne exactement de tant », et il est à la base de machines comme les fraiseuses CNC et les imprimantes 3D. Dans l'application BlueGrays, tu trouveras des projets d'utilisation du 28BYJ-48 et de fabrication d'un servo 360 degrés à partir d'un moteur pas à pas, pas à pas avec schémas et code.