Contrôler un moteur pas à pas 28BYJ-48 avec Arduino en C++

Publié le 18 septembre 202518 septembre 2025 par geo

Le moteur 28BYJ-48, associé au module de pilotage ULN2003, est l’un des plus utilisés dans les projets Arduino. Peu coûteux et facile à mettre en œuvre, il permet de réaliser des mouvements précis ou continus dans les deux sens de rotation.

Cet article présente une classe C++ complète permettant de contrôler ce moteur, ainsi qu’un gestionnaire pour simplifier la coordination de plusieurs moteurs dans un même projet.

Matériel nécessaire

1 moteur pas à pas 28BYJ-48
1 module de commande ULN2003
1 carte Arduino (Uno, Mega, Nano, etc.)
Des câbles de connexion

Le moteur est généralement vendu avec son module ULN2003, qui comporte 4 entrées IN1 à IN4 reliées aux bobines du moteur, ainsi qu’un connecteur 5 fils spécifique.

Principe de fonctionnement

Un moteur pas à pas fonctionne grâce à une séquence d’activation de ses bobines. Dans le cas du 28BYJ-48, il possède quatre bobines qu’il faut exciter successivement selon une séquence de 8 pas.

La séquence utilisée est la suivante (chaque ligne indique l’état des quatre sorties) :

1,0,0,0
1,1,0,0
0,1,0,0
0,1,1,0
0,0,1,0
0,0,1,1
0,0,0,1
1,0,0,1

Cette logique d’activation permet une rotation fluide et contrôlée du moteur.

Organisation du programme

Le programme est composé de deux classes principales :

1. La classe Stepper28BYJ48

Elle représente un moteur unique et gère :

La séquence des pas
Le sens de rotation (horaire ou antihoraire)
La vitesse, définie par un délai en millisecondes entre deux pas
Le démarrage et l’arrêt du moteur
La fonction release qui coupe l’alimentation des bobines pour économiser de l’énergie

Les principales méthodes sont :

start(direction) : démarre le moteur dans le sens choisi
stop() : arrête le moteur et coupe les bobines
setSpeed(delayMs) : change la vitesse en ajustant le délai entre les pas
update() : à appeler régulièrement dans la boucle loop() pour faire avancer le moteur
release() : coupe toutes les bobines
isMoving() : indique si le moteur est en mouvement

2. La classe StepperManager

C’est un gestionnaire capable de piloter plusieurs moteurs à la fois (jusqu’à 4 par défaut). Elle permet :

D’ajouter un moteur
De démarrer un moteur avec startMotor
De l’arrêter avec stopMotor
De modifier sa vitesse avec setMotorSpeed
De mettre à jour tous les moteurs avec updateAll
D’arrêter tous les moteurs avec stopAll
De vérifier si au moins un moteur est en mouvement avec anyMoving

Cette structure est idéale si l’on veut synchroniser plusieurs moteurs sans complexité supplémentaire.

Exemple pratique

Dans l’exemple fourni :

Le moteur est connecté aux broches 47, 49, 51 et 53 de l’Arduino Mega.
Le moteur est ajouté au gestionnaire.
Il est démarré en sens antihoraire avec une vitesse correspondant à un délai de 2 millisecondes par pas.
La fonction updateAll() est appelée dans la boucle principale pour assurer la continuité du mouvement.
Après 10 secondes de fonctionnement, le moteur est automatiquement arrêté.

Cette organisation permet aussi d’exécuter d’autres tâches dans la boucle principale sans bloquer le programme.

Schéma de principe

Par exemple, connecter les broches IN1 à IN4 aux broches 11 à 8 d’un Arduino Uno.

Relier le moins de l’alimentation à la masse de l’Arduino pour avoir une référence commune

Câblage

Connecter les quatre broches IN1 à IN4 du module ULN2003 aux broches digitales de l’Arduino (dans l’exemple : 47, 49, 51 et 53 d’un Arduino Mega 2560).
Relier l’alimentation 5V et la masse (GND) de l’ULN2003 à celles de l’Arduino.
Brancher le moteur sur le connecteur 5 fils du module ULN2003.

Important : le moteur peut consommer jusqu’à 240 mA. Si plusieurs moteurs sont utilisés, il est conseillé d’avoir une alimentation externe 5V plutôt que de dépendre uniquement du régulateur intégré de l’Arduino.

Points forts de cette approche

Modularité grâce à une classe par moteur
Simplicité d’utilisation avec le gestionnaire multi-moteurs
Souplesse puisque l’on peut changer le sens et la vitesse à la volée
Économie d’énergie avec la fonction release() qui coupe les bobines à l’arrêt

Applications possibles

Bras robotisés
Plateformes rotatives
Petits robots mobiles
Positionnement précis d’une caméra ou d’un capteur
Projets pédagogiques pour apprendre le pilotage des moteurs pas à pas

Source

#define MAX_MOTORS 4

class Stepper28BYJ48 {
  private:
    int pin1, pin2, pin3, pin4;
    int sequence[8][4] = {
      {1,0,0,0}, {1,1,0,0}, {0,1,0,0}, {0,1,1,0},
      {0,0,1,0}, {0,0,1,1}, {0,0,0,1}, {1,0,0,1}
    };
    int currentStep;
    long lastStepTime;
    int stepDelay;     // vitesse en ms entre chaque pas
    int stepDirection; // 1 = horaire, -1 = antihoraire
    bool moving;       // vrai si le moteur tourne

    void setStep(int step) {
      digitalWrite(pin1, sequence[step][0]);
      digitalWrite(pin2, sequence[step][1]);
      digitalWrite(pin3, sequence[step][2]);
      digitalWrite(pin4, sequence[step][3]);
    }

  public:
    Stepper28BYJ48(int p1, int p2, int p3, int p4, int delayMs=2) {
      pin1 = p1; pin2 = p2; pin3 = p3; pin4 = p4;
      stepDelay = delayMs;
      currentStep = 0;
      lastStepTime = 0;
      stepDirection = 1;
      moving = false;
      pinMode(pin1, OUTPUT);
      pinMode(pin2, OUTPUT);
      pinMode(pin3, OUTPUT);
      pinMode(pin4, OUTPUT);
    }

    // Démarrer la rotation continue
    void start(int direction = 1) {
      stepDirection = (direction >= 0) ? 1 : -1;
      moving = true;
    }

    // Arrêter le moteur
    void stop() {
      moving = false;
      release();
    }

    // Changer la vitesse à la volée
    void setSpeed(int delayMs) {
      stepDelay = delayMs;
    }

    // Mise à jour à appeler dans loop()
    void update() {
      if(!moving) return;
      long now = millis();
      if(now – lastStepTime >= stepDelay) {
        currentStep = (currentStep + stepDirection + 8) % 8;
        setStep(currentStep);
        lastStepTime = now;
      }
    }

    // Relâcher les bobines pour économiser de l’énergie
    void release() {
      digitalWrite(pin1, LOW);
      digitalWrite(pin2, LOW);
      digitalWrite(pin3, LOW);
      digitalWrite(pin4, LOW);
    }

    bool isMoving() {
      return moving;
    }
};

class StepperManager {
  private:
    Stepper28BYJ48* motors[MAX_MOTORS];
    int motorCount;

  public:
    StepperManager() {
      motorCount = 0;
      for(int i = 0; i < MAX_MOTORS; i++) motors[i] = nullptr;
    }

    bool addMotor(Stepper28BYJ48* motor) {
      if(motorCount >= MAX_MOTORS) return false;
      motors[motorCount++] = motor;
      return true;
    }

    void startMotor(int index, int direction = 1) {
      if(index < motorCount) motors[index]->start(direction);
    }

    void stopMotor(int index) {
      if(index < motorCount) motors[index]->stop();
    }

    void setMotorSpeed(int index, int delayMs) {
      if(index < motorCount) motors[index]->setSpeed(delayMs);
    }

    void updateAll() {
      for(int i = 0; i < motorCount; i++) motors[i]->update();
    }

    void stopAll() {
      for(int i = 0; i < motorCount; i++) motors[i]->stop();
    }

    bool anyMoving() {
      for(int i = 0; i < motorCount; i++) {
        if(motors[i]->isMoving()) return true;
      }
      return false;
    }
};

Stepper28BYJ48 moteur1(47,49,51,53, 3);
StepperManager manager;
long top,duree;

void setup() {
  manager.addMotor(&moteur1);
  manager.startMotor(0,-1); // moteur1 sens antihoraire
  manager.setMotorSpeed(0,2);
  top=millis();
}

void loop() {
  manager.updateAll();
  duree=millis()-top;
  if(duree > 10000) { 
    manager.stopMotor(0);  
  }
  // Ici on peut faire autre chose
}

Conclusion

Grâce à cette organisation orientée objet, le pilotage du moteur 28BYJ-48 devient simple, clair et extensible. Vous pouvez commencer avec un seul moteur puis en ajouter d’autres sans changer la logique générale.

Ce code constitue une excellente base pour vos projets Arduino nécessitant un ou plusieurs moteurs pas à pas légers.