Cet article contient tout ce que vous devez savoir pour contrôler un 28BYJ-48 moteur pas à pas avec la carte driver ULN2003 et Arduino. J’ai inclus les fiches techniques, un schéma de câblage et de nombreux exemples de code !
Nous commençons par examiner la bibliothèque Arduino Stepper, facile à utiliser. Cette bibliothèque est idéale pour débuter, mais elle ne propose pas beaucoup de fonctionnalités avancées.
Je vous recommande vivement de jeter un œil aux exemples de code pour la bibliothèque AccelStepper à la fin de ce tutoriel. Cette bibliothèque est assez simple à utiliser et peut grandement améliorer les performances de votre matériel.
Après chaque exemple, j’explique en détail le fonctionnement du code, vous ne devriez donc avoir aucun problème à le modifier selon vos besoins.
Matériel nécessaire
Composants matériels
 | 28BYJ-48 stepper motor | × 1 | Amazon |
| ULN2003 driver board | × 1 | Amazon | |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Jumper wires (mâle vers femelle) | × 10 | Amazon | |
| Breadboard (optionnel, facilite le câblage) | × 1 | Amazon | |
| USB cable type A/B | × 1 | Amazon | |
| 5V power supply (alimenter directement le moteur pas à pas depuis l’Arduino peut l’endommager !) | × 1 | Amazon |
Logiciel
Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.
Informations sur le moteur pas à pas 28BYJ-48 et la carte driver ULN2003
Le 28BYJ-48 est l’un des moteurs pas à pas les moins chers que vous puissiez trouver. Bien qu’il ne soit pas très précis ni puissant, c’est un excellent moteur pour les petits projets ou pour apprendre à connaître les moteurs pas à pas.
Ce moteur est souvent utilisé pour ajuster automatiquement les volets d’un climatiseur. Il possède une boîte de vitesses intégrée, ce qui lui confère un couple supplémentaire et réduit considérablement sa vitesse.
Vous trouverez ci-dessous les spécifications du moteur pas à pas et du driver utilisés dans ce tutoriel.
Spécifications du moteur pas à pas 28BYJ-48
| Tension nominale | 5 V |
| Résistance de la bobine | 50 Ohms |
| Type de bobine | Unipolaire |
| Diamètre – arbre | 0,197″ (5,00 mm) |
| Longueur – arbre et palier | 0,394″ (10 mm) |
| Caractéristiques | Arbre plat |
| Dimensions | Cylindrique – diamètre 1,100″ (28,00 mm) |
| Espacement des trous de fixation | Arbre plat |
| Réduction | 1/64 (voir note) |
| Angle de pas | Mode demi-pas (recommandé) : 0,0879° Mode pas complet : 0,176° |
| Pas par révolution | Mode demi-pas : 4096 (voir note) Mode pas complet : 2048 |
| Type de terminaison | Fils avec connecteur |
| Type de moteur | Moteur à engrenages à aimant permanent |
| Nombre de phases | 4 |
| Coût | Check price |
Pour plus d’informations, vous pouvez consulter la fiche technique ici.
Note importante: Les fabricants indiquent généralement que les moteurs ont une réduction d’engrenage de 64:1. Certains membres de la Arduino Forums communauté ont remarqué que ce n’était pas exact et ont démonté certains moteurs pour vérifier le rapport réel. Ils ont déterminé que le rapport exact est en fait 63,68395:1, ce qui donne environ 4076 pas par révolution complète (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 le nombre de pas par révolution dans le code pour correspondre à votre modèle.
Le Adafruit Industries Small Reduction Stepper Motor utilise le même format que le 28BYJ-48, mais avec un rapport d’engrenage différent. Il possède un train d’engrenages avec une réduction d’environ 1/16, ce qui donne 513 pas par révolution (en mode pas complet). Vous pouvez télécharger sa fiche technique ici.
Câblage – Connexion du moteur pas à pas 28BYJ-48 et de la carte driver ULN2003 à l’Arduino UNO
Le schéma de câblage ci-dessous montre comment connecter la carte driver ULN2003 au moteur pas à pas 28BYJ-48 et à l’Arduino. Les connexions sont également indiquées dans le tableau ci-dessous.
J’ai utilisé une breadboard et des fils de liaison pour connecter la carte driver à une alimentation externe.
Connexions ULN2003 et 28BYJ-48 vers Arduino
| Carte driver ULN2003 | Connexion |
|---|---|
| IN1 | Broche 8 Arduino |
| IN2 | Broche 9 Arduino |
| IN3 | Broche 10 Arduino |
| IN4 | Broche 11 Arduino |
| – | Masse logique Arduino |
| – | Masse alimentation |
| + | Alimentation 5 V |
Notez bien: Il est possible d’alimenter directement le moteur pas à pas depuis la sortie 5 V de l’Arduino. Cependant, ce n’est pas recommandé. Lorsque le moteur tire trop de courant, vous pouvez endommager l’Arduino. J’ai aussi constaté qu’en alimentant l’Arduino uniquement via USB, le moteur avait un comportement instable et des performances médiocres.
Je recommande d’alimenter la carte driver/moteur pas à pas avec une alimentation externe 5 V, comme celle-ci. Elle devrait être équipée d’un connecteur DC femelle, ce qui facilite la connexion avec des fils (jumpers). Notez qu’il faut aussi connecter la masse de l’Arduino à la borne – de la carte driver ULN2003.
Après avoir téléversé le code vous devez également alimenter l’Arduino, soit avec un câble USB type-B, soit via la prise d’alimentation 5,5 mm.
Le cavalier à côté des connexions d’alimentation sur la carte driver peut être utilisé pour couper l’alimentation du moteur pas à pas.
Exemple de code Arduino basique pour contrôler un moteur pas à pas 28BYJ-48
Vous pouvez téléverser le code exemple suivant sur votre Arduino avec l’IDE Arduino.
Cet exemple utilise la bibliothèque Stepper.h, qui est normalement préinstallée avec l’IDE Arduino. Ce sketch fait tourner le moteur pas à pas d’un tour dans un sens, fait une pause, puis d’un tour dans l’autre sens.
/*
Example sketch to control a 28BYJ-48 stepper motor
with ULN2003 driver board and Arduino UNO.
More info: https://www.makerguides.com
*/
// Include the Arduino Stepper.h library:
#include "Stepper.h"
// Define number of steps per rotation:
const int stepsPerRevolution = 2048;
// Wiring:
// Pin 8 to IN1 on the ULN2003 driver
// Pin 9 to IN2 on the ULN2003 driver
// Pin 10 to IN3 on the ULN2003 driver
// Pin 11 to IN4 on the ULN2003 driver
// Create stepper object called 'myStepper', note the pin order:
Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);
void setup() {
// Set the speed to 5 rpm:
myStepper.setSpeed(5);
// Begin Serial communication at a baud rate of 9600:
Serial.begin(9600);
}
void loop() {
// Step one revolution in one direction:
Serial.println("clockwise");
myStepper.step(stepsPerRevolution);
delay(500);
// Step one revolution in the other direction:
Serial.println("counterclockwise");
myStepper.step(-stepsPerRevolution);
delay(500);
}
Explication du code :
Le sketch commence par inclure la bibliothèque Arduino Stepper.h. Plus d’informations sur cette bibliothèque sont disponibles sur Arduino website.
// Include the Arduino Stepper.h library: #include "Stepper.h"
Ensuite, je définis le nombre de pas que le moteur effectue pour faire une révolution complète. Dans cet exemple, nous utilisons le moteur en mode pas complet. Cela signifie qu’il faut 2048 pas pour faire 360 degrés (voir les spécifications du moteur ci-dessus).
// Define number of steps per rotation: const int stepsPerRevolution = 2048;
Ensuite, vous devez créer une nouvelle instance de la classe Stepper, qui représente un moteur pas à pas connecté à l’Arduino. Pour cela, on utilise la fonction Stepper(steps, pin1, pin2, pin3, pin4)où steps est le nombre de pas par révolution et pin1 à pin4 sont les broches auxquelles le moteur est connecté. Pour obtenir la bonne séquence de pas, il faut définir les broches dans l’ordre suivant : 8, 10, 9, 11.
// Create stepper object called 'myStepper', note the pin order: Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);
Dans ce cas, j’ai nommé le moteur pas à pas ‘myStepper’, mais vous pouvez utiliser d’autres noms, comme ‘z_motor’ ou ‘liftmotor’, etc. Stepper liftmotor = Stepper(stepsPerRevolution, 8, 10, 9, 11);. Vous pouvez créer plusieurs objets moteurs pas à pas avec des noms et broches différents. Cela vous permet de contrôler facilement 2 moteurs pas à pas ou plus en même temps.
Dans la fonction setup, vous pouvez régler la vitesse en tours par minute avec la fonction setSpeed(rpm). La vitesse maximale pour un moteur 28BYJ-48 est d’environ 10-15 rpm à 5 V.
void setup() {
// Set the speed to 5 rpm:
myStepper.setSpeed(5);
// Begin Serial communication at a baud rate of 9600:
Serial.begin(9600);
}
Dans la boucle loop, on appelle simplement la fonction step(steps) qui fait tourner le moteur d’un nombre précis de pas à une vitesse déterminée par la fonction setSpeed(rpm). Passer un nombre négatif à cette fonction inverse le sens de rotation du moteur.
void loop() {
// Step one revolution in one direction:
Serial.println("clockwise");
myStepper.step(stepsPerRevolution);
delay(500);
// Step one revolution in the other direction:
Serial.println("counterclockwise");
myStepper.step(-stepsPerRevolution);
delay(500);
}
Exemples de code pour moteur pas à pas 28BYJ-48 avec Arduino et bibliothèque AccelStepper
Dans les trois exemples suivants, je vous montre comment contrôler la vitesse, la direction et le nombre de pas que le moteur doit effectuer. Dans ces exemples, j’utilise la bibliothèque AccelStepper.
La bibliothèque AccelStepper, écrite par Mike McCauley, est une excellente bibliothèque pour vos projets. L’un de ses avantages est qu’elle supporte l’accélération et la décélération, mais elle offre aussi beaucoup d’autres fonctions intéressantes.
Vous pouvez installer la bibliothèque en allant dans Sketch > Include Library > Add .ZIP Library… dans l’IDE Arduino.
Vous pouvez aussi l’installer en allant dans Tools > Manage Libraries… ou en tapant Ctrl + Shift + I sous Windows. Le gestionnaire de bibliothèques s’ouvre et met à jour la liste des bibliothèques installées.
Vous pouvez chercher ‘accelstepper’ et sélectionner la bibliothèque de Mike McCauley. Choisissez la dernière version puis cliquez sur Installer.
1. Exemple de code pour rotation continue
Le sketch suivant peut être utilisé pour faire tourner un ou plusieurs moteurs pas à pas en continu à vitesse constante (sans accélération ni décélération).
Vous pouvez copier le code en cliquant sur le bouton en haut à droite du champ de code.
/*
Example sketch to control a 28BYJ-48 stepper motor
with ULN2003 driver board, AccelStepper and Arduino UNO:
continuous rotation. More info: https://www.makerguides.com
*/
// Include the AccelStepper library:
#include "AccelStepper.h"
// Motor pin definitions:
#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
// Define the AccelStepper interface type: 4 wire motor in half step mode:
#define MotorInterfaceType 8
// Initialize with pin sequence IN1-IN3-IN2-IN4
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with constant speed as set by setSpeed():
stepper.runSpeed();
}
Fonctionnement du code :
La première étape est encore d’inclure la bibliothèque avec #include "AccelStepper.h« .
// Include the AccelStepper library: #include "AccelStepper.h"
L’étape suivante est de définir les connexions ULN2003 vers 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. Ainsi, partout où vous mentionnez motorPin1, le compilateur le remplacera par la valeur 8 lors de la compilation.
// Motor pin definitions: #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
L’étape suivante est de spécifier le type d’interface moteur pour la bibliothèque AccelStepper. Ici, nous piloterons un moteur pas à pas 4 fils en mode demi-pas, donc nous définissons interface type à ‘8’. Si vous souhaitez faire tourner le moteur en mode pas complet (moins de pas par révolution), changez simplement le 8 en 4.
// Define the AccelStepper interface type: 4 wire motor in half step mode: #define MotorInterfaceType 8
Ensuite, vous devez créer une nouvelle instance de la classe AccelStepper avec le type d’interface moteur approprié et les connexions. Pour obtenir la bonne séquence de pas, il faut définir les broches dans l’ordre suivant : motorPin1, motorPin3, motorPin2, motorPin4.
Dans ce cas, j’ai nommé le moteur pas à pas ‘stepper’, mais vous pouvez utiliser d’autres noms, comme ‘z_motor’ ou ‘liftmotor’, etc. AccelStepper liftmotor = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);. Vous pouvez créer plusieurs objets moteurs pas à pas avec des noms et broches différents. Cela vous permet de contrôler facilement 2 moteurs pas à pas ou plus en même temps.
// Initialize with pin sequence IN1-IN3-IN2-IN4 AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
Dans la fonction setup, on définit la vitesse maximale en pas/seconde avec la fonction setMaxSpeed(). Des vitesses supérieures à 1000 pas par seconde peuvent être instables, donc je fixe cette valeur comme maximum. Notez que je spécifie le nom du moteur pas à pas (‘stepper’) pour lequel je veux définir la vitesse maximale. Si vous avez plusieurs moteurs connectés, vous pouvez définir une vitesse différente pour chacun : stepper2.setMaxSpeed(500);.
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
}
Dans la boucle loop, on définit d’abord la vitesse à laquelle on veut faire tourner le moteur avec la fonction setSpeed(). Vous pouvez aussi placer cette instruction dans la fonction setup.
stepper.runSpeed() interroge le moteur et, lorsqu’un pas est dû, il exécute un pas. Cela dépend de la vitesse définie et du temps écoulé depuis le dernier pas. Pour changer le sens de rotation, vous pouvez définir une vitesse négative : stepper.setSpeed(-400); fait tourner le moteur dans l’autre sens.
void loop() {
// Set the speed of the motor in steps per second:
stepper.setSpeed(500);
// Step the motor with constant speed as set by setSpeed():
stepper.runSpeed();
}
En mode demi-pas, une révolution complète correspond à 4096 pas, donc 500 pas/sec équivaut à environ 7 rpm.
2. Sketch pour contrôler le nombre de pas ou de révolutions
Avec le sketch suivant, vous pouvez contrôler la vitesse, la direction et le nombre de pas/révolutions.
Ici, le moteur effectue 1 révolution dans le sens horaire à 500 pas/sec, puis 1 révolution dans le sens antihoraire à 1000 pas/sec, et enfin 2 révolutions dans le sens horaire à 1000 pas/sec.
/* Example sketch to control a 28BYJ-48 stepper motor with
ULN2003 driver board, AccelStepper and Arduino UNO
More info: https://www.makerguides.com */
#include "AccelStepper.h"
// Motor pin definitions:
#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
// Define the AccelStepper interface type; 4 wire motor in half step mode:
#define MotorInterfaceType 8
// Initialize with pin sequence IN1-IN3-IN2-IN4 for using the AccelStepper library with 28BYJ-48 stepper motor:
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
}
void loop() {
// Set the current position to 0:
stepper.setCurrentPosition(0);
// Run the motor forward at 500 steps/second until the motor reaches 4096 steps (1 revolution):
while (stepper.currentPosition() != 4096) {
stepper.setSpeed(500);
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:
stepper.setCurrentPosition(0);
// Run the motor backwards at 1000 steps/second until the motor reaches -4096 steps (1 revolution):
while (stepper.currentPosition() != -4096) {
stepper.setSpeed(-1000);
stepper.runSpeed();
}
delay(1000);
// Reset the position to 0:
stepper.setCurrentPosition(0);
// Run the motor forward at 1000 steps/second until the motor reaches 8192 steps (2 revolutions):
while (stepper.currentPosition() != 8192) {
stepper.setSpeed(1000);
stepper.runSpeed();
}
delay(3000);
}
Explication du code :
La première partie du code jusqu’à la fonction loop() est identique à l’exemple précédent.
Dans la boucle, j’utilise une boucle while combinée à la fonction currentPosition(). D’abord, je positionne la position actuelle du moteur à zéro avec stepper.setCurrentPosition(0).
// Set the current position to 0: stepper.setCurrentPosition(0);
Ensuite, on utilise la boucle while. Une boucle while s’exécute en continu et indéfiniment tant que l’expression entre parenthèses () est vraie. Ici, je vérifie si la position actuelle du moteur n’est pas égale à 4096 pas (!= signifie : n’est pas égal à). Tant que c’est vrai, on fait tourner le moteur à la vitesse constante définie par setSpeed().
// Run the motor forward at 500 steps/second until the motor reaches 4096 steps (1 revolution):
while (stepper.currentPosition() != 4096) {
stepper.setSpeed(500);
stepper.runSpeed();
}
Dans le reste de la boucle, on fait exactement la même chose, mais avec une vitesse et une position cible différentes.
3. Exemple de code avec accélération et décélération
Avec ce sketch, vous pouvez ajouter facilement accélération et décélération aux mouvements du moteur pas à pas, sans codage compliqué. La première partie du sketch est la même que dans l’exemple 1, mais le setup et la loop sont différents.
Le moteur effectue deux révolutions aller-retour à une vitesse de 1000 pas par seconde et une accélération de 200 pas/seconde².
/*
Example sketch to control a 28BYJ-48 stepper motor with ULN2003 driver board,
AccelStepper and Arduino UNO: acceleration and deceleration.
More info: https://www.makerguides.com
*/
#include "AccelStepper.h"
// Motor pin definitions:
#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
// Define the AccelStepper interface type; 4 wire motor in half step mode:
#define MotorInterfaceType 8
// Initialize with pin sequence IN1-IN3-IN2-IN4
AccelStepper stepper = AccelStepper(MotorInterfaceType, motorPin1, motorPin3, motorPin2, motorPin4);
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
// Set the maximum acceleration in steps per second^2:
stepper.setAcceleration(200);
}
void loop() {
// Set target position:
stepper.moveTo(8192);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
// Move back to original position:
stepper.moveTo(0);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
}
Fonctionnement du code :
Dans le setup, en plus de la vitesse maximale, il faut définir l’accélération/décélération avec la fonction setAcceleration().
void setup() {
// Set the maximum steps per second:
stepper.setMaxSpeed(1000);
// Set the maximum acceleration in steps per second^2:
stepper.setAcceleration(200);
}
Dans la boucle, j’utilise une méthode différente pour faire tourner le moteur d’un nombre prédéfini de pas. D’abord, je définis la position cible avec la fonction moveTo(). Ensuite, on utilise simplement la fonction runToPosition() pour faire tourner le moteur jusqu’à la position cible avec la vitesse et l’accélération définies. Le moteur décélère avant d’atteindre la position cible.
void loop() {
// Set target position:
stepper.moveTo(8192);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
// Move back to original position:
stepper.moveTo(0);
// Run to position with set speed and acceleration:
stepper.runToPosition();
delay(1000);
}
Enfin, on remet la position cible à zéro pour revenir à l’origine.
Conclusion
Dans cet article, je vous ai montré comment contrôler un moteur pas à pas 28BYJ-48 avec un driver ULN2003 et Arduino. Nous avons vu 4 exemples, utilisant les bibliothèques Stepper et AccelStepper. J’espère que vous l’avez trouvé utile et instructif.
Si vous souhaitez en savoir plus sur le contrôle de moteurs pas à pas plus puissants et rapides, consultez les articles ci-dessous. J’y explique comment piloter des moteurs NEMA 17 avec des drivers comme le
A4988.
- Control a stepper motor with L298N motor driver and Arduino
- How to control a Stepper Motor with Arduino Motor Shield Rev3
- How to control a stepper motor with A4988 driver and Arduino
- How to control a stepper motor with DRV8825 driver and Arduino
Si vous avez des questions, n’hésitez pas à laisser un commentaire ci-dessous.
