Comment utiliser Moteur pas à pas 28BYJ-48 avec pilote ULN2003 et tutoriel Arduino

Composants matériels

1. Moteur pas à pas 28BYJ-48
2. Carte pilote ULN2003
3. Arduino Uno Rev 3
4. Fils de cavalier (mâle à femelle)
5. Breadboard (en option, facilite le câblage)
6. Câble USB type A / B
7. Alimentation 5V (alimenter le moteur pas à pas directement depuis l’Arduino peut l’endommager!)

Informations sur le moteur pas à pas 28BYJ-48 et la carte de commande ULN2003

Le 28BYJ-48 est l’un des moteurs pas à pas les moins chers que vous puissiez trouver . Bien qu’il ne soit pas super précis ou puissant, c’est un excellent moteur à utiliser pour les petits projets ou si vous voulez simplement en savoir plus sur les moteurs pas à pas.

Ce moteur est souvent utilisé pour ajuster automatiquement les aubes d’un climatiseur. Il dispose d’une boîte de vitesses intégrée, ce qui lui confère un couple supplémentaire et réduit considérablement la vitesse.

Vous trouverez ci-dessous les spécifications du moteur pas à pas et du pilote utilisés dans ce didacticiel.

Spécifications du moteur pas à pas 28BYJ-48

Pour plus d’informations, vous pouvez consulter la fiche technique ici.

Remarque importante : les fabricants spécifient généralement que les moteurs ont une réduction de 64: 1. Certains membres des  forums Arduino ont  remarqué que ce n’était pas correct et ont donc démonté certains moteurs pour vérifier le rapport de vitesse réel. Ils ont déterminé que le rapport de démultiplication exact est en fait de  63,68395: 1 , ce qui donne environ  4076  pas par tour complet (en mode demi-pas).

Je ne sais pas si tous les fabricants utilisent exactement la même boîte de vitesses, mais vous pouvez simplement ajuster les pas par tour dans le code, pour correspondre à votre modèle.

Le  moteur pas à pas à petite réduction Adafruit Industries  utilise le même facteur de forme que le 28BYJ-48, mais a un rapport de démultiplication différent. Il a un ensemble d’engrenages réducteurs d’environ 1/16, ce qui donne 513 pas par tour (en mode pas complet). Vous pouvez télécharger la fiche technique  ici .

Pour plus d’informations sur le pilote, vous pouvez consulter la fiche technique ci-dessous.

Câblage – Connexion du moteur pas à pas 28BYJ-48 et de la carte pilote ULN2003 à Arduino UNO

Le schéma de câblage / schéma ci-dessous vous montre comment connecter la carte pilote ULN2003 au moteur pas à pas 28BYJ-48 et à l’Arduino. Les connexions sont également données dans le tableau ci-dessous.

J’ai utilisé une planche à pain et des fils de cavalier pour connecter la carte de commande à une alimentation externe.

Connexions ULN2003 et 28BYJ-48 vers Arduino

Remarque : il est possible d’alimenter directement le moteur pas à pas à partir de la sortie 5 V de l’Arduino. Ceci n’est cependant pas recommandé. Lorsque le moteur pas à pas consomme trop de courant, vous pouvez  endommager l’Arduino . J’ai également constaté que lorsque j’alimentais l’Arduino avec une alimentation USB uniquement, j’obtiendrais un comportement incohérent et de mauvaises performances du moteur pas à pas.

Je recommande d’alimenter la carte de commande / le moteur pas à pas avec  une alimentation externe 5 V, comme celle-ci . Il doit être livré avec un connecteur DC femelle, vous pouvez donc le connecter facilement à certains fils (cavaliers). Notez que vous devez également connecter le GND de l’Arduino à la broche – sur la carte pilote ULN2003.

Après avoir téléchargé le code,  vous devez également alimenter l’Arduino , soit avec un câble USB de type B, soit via la prise d’alimentation de 5,5 mm.

Le cavalier à côté des connexions d’alimentation sur la carte de commande peut être utilisé pour déconnecter l’alimentation du moteur pas à pas.

Exemple de code Arduino de base pour contrôler un moteur pas à pas 28BYJ-48

Vous pouvez télécharger l’exemple de code suivant sur votre Arduino à l’aide de l’  IDE Arduino .

Cet exemple utilise la  bibliothèque Stepper.h , qui devrait être préinstallée avec l’IDE Arduino. Cette esquisse fait tourner le moteur pas à pas d’un tour dans un sens, s’arrête, puis fait un tour dans l’autre sens.

// Inclut la bibliothèque Arduino Stepper.h:
#include <Stepper.h>
// Définit le nombre de pas par rotation:
const int stepsPerRevolution = 2048;
// Câblage:
// Broche 8 à IN1 sur le pilote ULN2003
// Broche 9 à IN2 sur le pilote ULN2003
// Broche 10 à IN3 sur le pilote ULN2003
// Broche 11 à IN4 sur le pilote ULN2003
// Créez un objet stepper appelé 'myStepper', notez l'ordre des broches:
Stepper myStepper = Stepper ( stepsPerRevolution, 8, 10, 9, 11 ) ;
void setup() {
// Réglez la vitesse sur 5 tr / min:
  myStepper.setSpeed(5);
// Commencez la communication série à une vitesse de transmission de 9600:
  Serial.begin(9600);
}
void loop() {
// Étape d'une révolution dans une direction:
Serial.println("clockwise");
  myStepper.step(stepsPerRevolution);
  delay(500);
// Étape d'une révolution dans l'autre sens:
Serial.println("counterclockwise");
  myStepper.step(-stepsPerRevolution);
  delay(500);
}

Explication du code ::

L’esquisse commence par inclure la bibliothèque Arduino Stepper.h. Plus d’informations sur cette bibliothèque peuvent être trouvées sur le  site Web Arduino .

Ensuite, j’ai défini le nombre de pas nécessaires au moteur pour faire tourner 1 tour. Dans cet exemple, nous utiliserons le moteur en  mode pas à pas . Cela signifie qu’il faut 2048 pas pour tourner à 360 degrés (voir les spécifications du moteur ci-dessus).

Ensuite, vous devez créer une nouvelle instance de la classe Stepper, qui représente un moteur pas à pas particulier connecté à l’Arduino. Pour cela, nous utilisons la fonction  Stepper(steps, pin1, pin2, pin3, pin4) où étapes est le nombre de pas par tour et pin1 à pin4 sont les broches auxquelles le moteur est connecté. Pour obtenir la séquence d’étapes correcte, nous devons définir les broches dans l’ordre suivant: 8, 10, 9, 11.

Dans ce cas , j’ai appelé le moteur pas à pas « myStepper » mais vous pouvez utiliser d’ autres noms aussi, comme « z_motor » ou « liftmotor » , etc.  Stepper liftmotor = Stepper(stepsPerRevolution, 8, 10, 9, 11);. Vous pouvez créer plusieurs objets de moteur pas à pas avec des noms et des broches différents. Cela vous permet de contrôler facilement 2 moteurs pas à pas ou plus en même temps.

Dans la configuration, vous pouvez régler la vitesse en tr / min avec la fonction  setSpeed(rpm). La  vitesse maximale  d’un moteur pas à pas 28byj-48 est d’ environ  10 à 15 tours par minute à 5 V .

Dans la section de code en boucle, nous appelons simplement la  step(steps) fonction qui fait tourner le moteur d’un nombre spécifique de pas à une vitesse déterminée par la  setSpeed(rpm) fonction. Le passage d’un nombre négatif à cette fonction inverse le sens de rotation du moteur.

Exemples de codes pour moteur pas à pas 28BYJ-48 avec bibliothèque Arduino et AccelStepper

Dans les trois exemples suivants, je vais vous montrer comment contrôler à la fois la vitesse, la direction et le nombre de pas que le moteur pas à pas doit faire. Dans ces exemples, j’utiliserai la  bibliothèque AccelStepper .

La bibliothèque AccelStepper écrite par Mike McCauley est une bibliothèque géniale à utiliser pour votre projet. L’un des avantages est qu’il prend en charge l’accélération et la décélération, mais il a également beaucoup d’autres fonctions intéressantes.

Vous pouvez télécharger la dernière version de cette bibliothèque  ici  ou cliquer sur le bouton ci-dessous.

Vous pouvez installer la bibliothèque en allant dans  Sketch> Inclure la bibliothèque> Ajouter une bibliothèque .ZIP…  dans l’IDE Arduino.

Une autre option consiste à naviguer vers  Outils> Gérer les bibliothèques…  ou tapez Ctrl + Maj + I sous Windows. Le gestionnaire de bibliothèque ouvrira et mettra à jour la liste des bibliothèques installées.

Vous pouvez rechercher «accelstepper» et chercher la bibliothèque de Mike McCauley. Sélectionnez la dernière version, puis cliquez sur Installer.

1. Exemple de code de rotation continue

L’esquisse suivante peut être utilisée pour faire fonctionner un ou plusieurs moteurs pas à pas en continu à une vitesse constante. (Aucune accélération ou décélération n’est utilisée).

Vous pouvez copier le code en cliquant sur le bouton dans le coin supérieur droit du champ de code.

// Inclut la bibliothèque AccelStepper:
#include <AccelStepper.h>
// Définitions des broches du moteur:
#define motorPin1  8      // IN1 on the ULN2003 driver
#define motorPin2  9      // IN2 on the ULN2003 driver
#define motorPin3  10     // IN3 on the ULN2003 driver
#define motorPin4  11     // IN4 on the ULN2003 driver
// Définit le type d'interface AccelStepper; Moteur 4 fils en mode demi-pas:
#define MotorInterfaceType 8
// Initialisation avec la séquence de broches IN1-IN3-IN2-IN4 pour utiliser la bibliothèque AccelStepper avec le moteur pas à pas 28BYJ-48:
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Définit le nombre maximum de pas par seconde:
  stepper.setMaxSpeed(1000);
}
void loop() {
// Réglez la vitesse du moteur en pas par seconde:
  stepper.setSpeed(500);
// Faire avancer le moteur avec une vitesse constante définie par setSpeed ​​():
  stepper.runSpeed();
}

Comment fonctionne le code:

Encore une fois, la première étape consiste à inclure la bibliothèque avec  #include <AccelStepper.h>.

L’étape suivante consiste à définir les connexions ULN2003 à Arduino.

L’instruction  #define est utilisée pour donner un nom à une valeur constante. Le compilateur remplacera toutes les références à cette constante par la valeur définie lors de la compilation du programme. Ainsi, partout où vous parlez  motorPin1, le compilateur le remplacera par la valeur 8 lorsque le programme sera compilé.

L’étape suivante consiste à spécifier le type d’interface moteur pour la bibliothèque AccelStepper. Dans ce cas, nous allons piloter un moteur pas à pas à 4 fils en  mode demi-pas , nous définissons donc le type d’interface sur «8». Vous pouvez trouver les autres types d’interface  ici . Si vous souhaitez faire fonctionner le moteur en mode pas-à-pas complet (moins de pas par tour), changez simplement le 8 en 4.

Ensuite, vous devez créer une nouvelle instance de la classe AccelStepper avec le type d’interface moteur et les connexions appropriés. Pour obtenir la séquence d’étapes correcte, nous devons définir les broches dans l’ordre suivant:  motorPin1, motorPin3, motorPin2, motorPin4 .

Dans ce cas , j’ai appelé le moteur pas à pas « pas à pas » , mais vous pouvez utiliser d’ autres noms aussi, comme « z_motor » ou « liftmotor » , etc.  AccelStepper liftmotor = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);. Vous pouvez créer plusieurs objets de moteur pas à pas avec des noms et des broches différents. Cela vous permet de contrôler facilement 2 moteurs pas à pas ou plus en même temps.

Dans la section setup du code, nous définissons la vitesse maximale en pas / seconde avec la fonction  setMaxSpeed(). Des vitesses de plus de 1000 pas par seconde peuvent ne pas être fiables, je l’ai donc définie comme maximum. Notez que je précise le nom du moteur pas à pas (‘stepper’), pour lequel je souhaite définir la vitesse maximale. Si vous avez plusieurs moteurs pas à pas connectés, vous pouvez spécifier une vitesse différente pour chaque moteur:  stepper2.setMaxSpeed(500);.

Dans la boucle, nous définissons d’abord la vitesse à laquelle nous voulons que le moteur fonctionne avec la fonction  setSpeed(). (vous pouvez également le placer dans la section de configuration du code).

stepper.runSpeed() interroge le moteur et lorsqu’une étape est due, il exécute 1 étape. Cela dépend de la vitesse réglée et du temps écoulé depuis la dernière étape. Si vous voulez changer la direction du moteur, vous pouvez régler une vitesse négative: fait  stepper.setSpeed(-400); tourner le moteur dans l’autre sens.

En mode demi-pas, un tour prend 4096 pas, donc 500 pas / s donnent environ  7 tr / min .

2. Esquissez pour contrôler le nombre de pas ou de révolutions

Avec l’esquisse suivante, vous pouvez contrôler à la fois la vitesse, la direction et le nombre de pas / tours.

Dans ce cas, le moteur pas à pas tourne 1 tour dans le sens des aiguilles d’une montre avec 500 pas / s, puis tourne 1 tour dans le sens antihoraire à 1000 pas / s, et enfin fait 2 tours dans le sens horaire à 1000 pas / s.

// Inclut la bibliothèque AccelStepper:
#include <AccelStepper.h>
// Définitions des broches du moteur:
#define motorPin1  8      // IN1 on the ULN2003 driver
#define motorPin2  9      // IN2 on the ULN2003 driver
#define motorPin3  10     // IN3 on the ULN2003 driver
#define motorPin4  11     // IN4 on the ULN2003 driver
// Définit le type d'interface AccelStepper; Moteur 4 fils en mode demi-pas:
#define MotorInterfaceType 8
// Initialisation avec la séquence de broches IN1-IN3-IN2-IN4 pour utiliser la bibliothèque AccelStepper avec le moteur pas à pas 28BYJ-48:
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Définit le nombre maximum de pas par seconde:
  stepper.setMaxSpeed(1000);
}
void loop() {
// Définit la position actuelle sur 0:
  stepper.setCurrentPosition(0);
// Faire avancer le moteur à 500 pas / seconde jusqu'à ce que le moteur atteigne 4096 pas (1 tour):
while (stepper.currentPosition() != 4096) {
    stepper.setSpeed(500);
    stepper.runSpeed();
  }
  delay(1000);
// Remise à 0 de la position:
  stepper.setCurrentPosition(0);
// Faire tourner le moteur en arrière à 1000 pas / seconde jusqu'à ce que le moteur atteigne -4096 pas (1 tour):
 while (stepper.currentPosition() != -4096) {
    stepper.setSpeed(-1000);
    stepper.runSpeed();
  }
  delay(1000);
// Remise à 0 de la position:
  stepper.setCurrentPosition(0);
// Faire avancer le moteur à 1000 pas / seconde jusqu'à ce que le moteur atteigne 8192 pas (2 tours):
while (stepper.currentPosition() != 8192) {
    stepper.setSpeed(1000);
    stepper.runSpeed();
  }
  delay(3000);
}

Comment fonctionne le code:

La première partie du code jusqu’à la section loop () est exactement la même que dans l’exemple précédent.

Dans la boucle, j’utilise une  boucle while  en combinaison avec la  currentPosition() fonction. Tout d’abord, je règle la position actuelle du moteur pas à pas sur zéro avec  stepper.setCurrentPosition(0).

Ensuite, nous utilisons la boucle while. Une boucle while fera une boucle continuellement, et infiniment, jusqu’à ce que l’expression entre parenthèses, () devienne fausse. Donc dans ce cas je vérifie si la position actuelle du moteur pas à pas n’est pas égale à 4096 pas (! = Signifie: n’est pas égal à). Bien que ce ne soit pas le cas, nous faisons fonctionner le moteur pas à pas à une vitesse constante définie par  setSpeed().

Dans le reste de la boucle, nous faisons exactement la même chose, juste avec une vitesse et une position cible différentes.

3. Exemple de code d’accélération et de décélération

Avec le schéma suivant, vous pouvez ajouter une accélération et une décélération aux mouvements du moteur pas à pas, sans codage compliqué. La première section de cette esquisse est la même que dans l’exemple 1, mais la configuration et la boucle sont différentes.

Le moteur effectuera deux tours d’avant en arrière avec une vitesse de 1000 pas par seconde et une accélération de 200 pas / seconde2.

/* Exemple de croquis pour contrôler un moteur pas à pas 28BYJ-48 avec carte driver ULN2003, AccelStepper et Arduino UNO : accélération et décélération.*/
// Inclut la bibliothèque AccelStepper:
#include <AccelStepper.h>
// Définitions des broches du moteur:
#define motorPin1  8      // IN1 on the ULN2003 driver
#define motorPin2  9      // IN2 on the ULN2003 driver
#define motorPin3  10     // IN3 on the ULN2003 driver
#define motorPin4  11     // IN4 on the ULN2003 driver
// Définit le type d'interface AccelStepper; Moteur 4 fils en mode demi-pas:
#define MotorInterfaceType 8
// Initialisation avec la séquence de broches IN1-IN3-IN2-IN4 pour utiliser la bibliothèque AccelStepper avec le moteur pas à pas 28BYJ-48:
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Définit le nombre maximum de pas par seconde:
  stepper.setMaxSpeed(1000);
// Définit l'accélération maximale en pas par seconde ^ 2:
  stepper.setAcceleration(200);
}
void loop() {
// Définir la position cible:
  stepper.moveTo(8192);
// Course à la position avec vitesse et accélération définies:
  stepper.runToPosition();
  
  delay(1000);
// Revenir à la position d'origine:
  stepper.moveTo(0);
// Course à la position avec vitesse et accélération définies:
  stepper.runToPosition();
  delay(1000);
}

Comment fonctionne le code:

Dans la configuration, outre la vitesse maximale, nous devons également définir l’accélération / la décélération. Pour cela, nous utilisons la fonction  setAcceleration().

Dans la section boucle du code, j’ai utilisé une manière différente de laisser le moteur tourner un nombre prédéfini d’étapes. J’ai d’abord défini la position cible avec la fonction  moveTo(). Ensuite, nous utilisons simplement la fonction  runToPosition() pour laisser le moteur tourner jusqu’à la position cible avec la vitesse et l’accélération définies. Le moteur ralentira avant d’atteindre la position cible.

Enfin, nous remettons la nouvelle position cible à 0, de sorte que nous revenions à l’origine.

Conclusion

Dans cet article, je vous ai montré comment contrôler un moteur pas à pas 28BYJ-48 avec un pilote ULN2003 et Arduino. Nous avons examiné 4 exemples, utilisant à la fois les bibliothèques Stepper et AccelStepper. J’espère que vous l’avez trouvé utile et instructif. Si c’est le cas,  partagez-le avec un ami  qui aime aussi l’électronique!

J’aimerais savoir quels projets vous prévoyez de construire (ou avez déjà construits) avec ce moteur pas à pas.Si vous avez des questions, des suggestions ou si vous pensez que des choses manquent dans ce tutoriel,  veuillez laisser un commentaire ci-dessous .