Cet article contient tout ce que vous devez savoir pour contrôler un moteur pas à pas avec le A4988 driver de moteur pas à pas et Arduino. J’ai inclus un schéma de câblage, un tutoriel sur la façon de régler la limite de courant ainsi que de nombreux exemples de code.
Bien que vous puissiez utiliser ce driver sans bibliothèque Arduino, je vous recommande vivement de jeter un œil au code d’exemple pour la bibliothèque AccelStepper à la fin de ce tutoriel. Cette bibliothèque est assez facile à 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.
Pièces requises
Composants matériels
 | A4988 stepper motor driver | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (8-35 V) | × 1 | Amazon | |
| Breadboard | × 1 | Amazon | |
 | Capacitor (100 µF) | × 1 | Amazon |
| Jumper wires | ~ 10 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
J’aime utiliser ce driver en combinaison avec un CNC-shield ou expansion board. Un tel shield inclut déjà des condensateurs et offre un moyen simple de sélectionner la résolution du micro-pas. Cela facilite grandement le câblage et constitue une excellente option si vous cherchez une solution plus permanente qu’une breadboard.
Outils
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.
À propos du driver
Au cœur du driver A4988 se trouve une puce fabriquée par Allegro MicroSystems : le A4988 DMOS Microstepping Driver avec traducteur et protection contre les surintensités. Ce driver intégré facilite grandement l’interface avec un microcontrôleur car vous n’avez besoin que de deux broches pour contrôler à la fois la vitesse et la direction du moteur pas à pas.
Le driver supporte une tension maximale de sortie de 35 V et un courant de ± 2 A, ce qui est idéal pour piloter des moteurs pas à pas petits à moyens comme un NEMA 17 moteur pas à pas bipolaire.
Si vous devez contrôler des moteurs plus gros comme les NEMA 23, regardez du côté du driver TB6600. Ce driver peut être utilisé avec le même code que l’A4988 et supporte un courant de 3,5 A.
La puce A4988 intègre plusieurs fonctions de sécurité telles que la protection contre les surintensités, les courts-circuits, la coupure sous-tension et la protection contre la surchauffe. Vous trouverez plus de spécifications dans le tableau ci-dessous.
Spécifications du A4988
| Tension minimale de fonctionnement | 8 V |
| Tension maximale de fonctionnement | 35 V |
| Courant continu par phase | 1 A |
| Courant maximal par phase | 2 A |
| Tension logique minimale | 3 V |
| Tension logique maximale | 5,5 V |
| Résolution micro-pas | pas complet, 1/2, 1/4, 1/8 et 1/16 |
| Protection contre la tension inverse ? | Non |
| Dimensions | 15,5 × 20,5 mm (0,6″ × 0,8″) |
| Coût | Check price |
Pour plus d’informations, vous pouvez consulter la fiche technique ici.
Différences entre l’A4988 et le DRV8825
Le DRV8825 est assez similaire à l’A4988 mais présente quelques différences clés :
- Le DRV8825 offre un micro-pas jusqu’à 1/32, alors que l’A4988 ne descend qu’à 1/16. Un micro-pas plus fin permet un fonctionnement plus fluide et silencieux, mais n’est pas toujours nécessaire.
- Le potentiomètre de réglage du courant est situé à un endroit différent
- La relation entre la tension de référence et la limite de courant est différente.
- Le DRV8825 nécessite une durée minimale d’impulsion STEP de 1,9 µs ; l’A4988 nécessite un minimum de 1 µs.
- Le DRV8825 peut être utilisé avec une alimentation moteur à tension plus élevée (45 V contre 35 V). Cela le rend moins sensible aux pics de tension LC.
- Le DRV8825 peut fournir un courant légèrement supérieur à celui de l’A4988 sans refroidissement supplémentaire.
Notez que le brochage du DRV8825 est exactement le même que celui de l’A4988, il peut donc être utilisé en remplacement direct !
Réglages du micro-pas
Les moteurs pas à pas ont généralement un pas de 1,8° ou 200 pas par révolution, ce qui correspond aux pas complets. Un driver micro-pas comme l’A4988 permet d’obtenir des résolutions plus fines en autorisant des positions intermédiaires. Cela se fait en alimentant les bobines avec des niveaux de courant intermédiaires.
Par exemple, en mode quart de pas, un moteur de 200 pas par révolution aura 800 micro-pas par révolution en utilisant quatre niveaux de courant différents.
Les broches de sélection de résolution (MS1, MS2 et MS3) permettent de choisir l’une des cinq résolutions de pas selon le tableau ci-dessous.
| MS1 | MS2 | MS3 | Résolution micro-pas |
|---|---|---|---|
| Bas | Bas | Bas | Pas complet |
| Haut | Bas | Bas | 1/2 pas |
| Bas | Haut | Bas | 1/4 pas |
| Haut | Haut | Bas | 1/8 pas |
| Haut | Haut | Haut | 1/16 pas |
Les trois entrées ont des résistances de tirage internes de 100 kΩ vers la masse, donc laisser les trois broches de sélection micro-pas déconnectées active le mode pas complet.
J’utilise souvent un CNC-shield ou une carte d’extension en combinaison avec ces drivers. La carte d’extension possède 3 interrupteurs DIP pour régler MS1 – MS3 en haut ou bas, et sur le CNC-shield vous pouvez installer des cavaliers. Si vous utilisez le driver sur une breadboard, vous pouvez simplement utiliser des fils de connexion pour relier les broches de sélection à 5 V (c’est-à-dire les mettre à HIGH).
Câblage – Connexion de l’A4988 à l’Arduino et au moteur pas à pas
Le schéma ci-dessus montre comment connecter le driver A4988 à un moteur pas à pas et à l’Arduino. Les connexions sont également listées dans le tableau suivant :
Connexions de l’A4988
| A4988 | Connexion |
|---|---|
| VMOT | 8-35V |
| GND | Masse moteur |
| SLP | RESET |
| RST | SLP |
| VDD | 5V |
| GND | Masse logique |
| STP | Broche 3 |
| DIR | Broche 2 |
| 1A, 1B, 2A, 2B | Moteur pas à pas |
- L’alimentation du moteur est connectée à GND et VMOT (en haut à droite).
- Les deux bobines du moteur pas à pas sont connectées à 1A, 1B et 2A, 2B (voir ci-dessous).
- La broche GND (en bas à droite) est reliée à la masse du microcontrôleur et VDD est connecté au 5V.
- Les broches STP (step) et DIR (direction) sont connectées respectivement aux broches numériques 3 et 2. Vous pouvez choisir d’autres broches numériques si vous le souhaitez, mais ce sont celles que j’ai utilisées pour ce tutoriel et les exemples de code.
- La broche SLP est une entrée active basse. Cela signifie que la mettre à LOW met le driver en mode veille, réduisant la consommation d’énergie. RST est aussi une entrée active basse. Lorsqu’elle est mise à LOW, toutes les entrées STEP sont ignorées jusqu’à ce qu’elle soit remise à HIGH. Si vous n’utilisez pas cette broche, vous pouvez la connecter à la broche SLP/SLEEP adjacente pour la mettre à HIGH et activer le driver.
- La broche EN (enable) peut rester déconnectée, elle est tirée à LOW par défaut. Lorsque cette broche est mise à HIGH, le driver est désactivé.
Dans le reste de ce tutoriel j’ai laissé MS1, MS2 et MS3 déconnectés, donc le driver fonctionne en mode pas complet. Cela facilite l’explication du code. Normalement, j’utiliserais le micro-pas 1/8 ou 1/16 et connecterais les broches appropriées à 5V (voir le tableau en introduction).
Attention
La carte porteuse A4988 utilise des condensateurs céramiques à faible ESR, ce qui la rend sensible aux pics de tension LC destructeurs, surtout avec des câbles d’alimentation plus longs que quelques centimètres.
Pour protéger le driver, vous pouvez connecter un condensateur électrolytique entre VMOT et GND. Pololu recommande un condensateur de 47 µF ou plus (j’ai utilisé un condensateur de 100 µF).
Comment déterminer le câblage correct du moteur pas à pas ?
Si vous ne trouvez pas la fiche technique de votre moteur pas à pas, il peut être difficile de savoir comment le câbler correctement. J’utilise l’astuce suivante pour identifier les connexions des moteurs bipolaires à 4 fils :
La seule chose à identifier est les deux paires de fils qui sont connectées aux deux bobines du moteur. Les fils d’une bobine sont connectés à 1A et 1B, et ceux de l’autre à 2A et 2B, la polarité n’a pas d’importance.
Pour trouver les deux fils d’une bobine, procédez comme suit moteur déconnecté :
- Essayez de faire tourner l’axe du moteur pas à pas à la main et notez la résistance au mouvement.
- Prenez ensuite une paire de fils au hasard et touchez leurs extrémités dénudées ensemble.
- Essayez à nouveau de faire tourner l’axe du moteur.
Si vous ressentez une forte résistance, vous avez trouvé une paire de fils de la même bobine. Si l’axe tourne librement, essayez une autre paire. Connectez ensuite les deux bobines aux broches indiquées dans le schéma de câblage ci-dessus.
Comment régler la limite de courant ?
Avant de commencer à programmer votre Arduino et utiliser le driver, il y a une chose très importante que beaucoup oublient : régler la limite de courant !
Cette étape n’est pas compliquée mais absolument nécessaire pour protéger votre moteur pas à pas et le driver. Si vous ne réglez pas une limite de courant appropriée, votre moteur peut tirer plus de courant que ce que lui ou le driver peuvent supporter, ce qui risque d’endommager l’un ou l’autre, voire les deux.
Pour régler la limite de courant, vous devez mesurer une tension de référence et ajuster le potentiomètre embarqué en conséquence. Vous aurez besoin d’un petit tournevis, d’un multimètre pour mesurer la tension de référence, et de câbles crocodiles (optionnels mais très pratiques).
Pour mesurer la tension de référence, le driver doit être alimenté. L’A4988 nécessite uniquement une alimentation via VDD (5V) et il faut connecter RST et SLP ensemble, sinon le driver ne s’allumera pas. Il est préférable de déconnecter le moteur pas à pas pendant cette opération.
Si vous avez déjà câblé le driver, vous pouvez laisser tout connecté sauf le moteur pas à pas. Vous pouvez alimenter via le port USB de l’Arduino.
| A4988 | Connexion |
|---|---|
| VDD | 5V |
| RST | SLP |
| SLP | RESET |
| GND | Masse |
Formule de la limite de courant
L’étape suivante est de calculer la limite de courant avec la formule suivante :
Limite de courant = Vref ÷ (8 × Rcs)
Rcs est la résistance de détection de courant. Si vous avez acheté un driver A4988 chez Pololu avant janvier 2017, Rcs vaut 0,050 Ω. Les drivers vendus après cette date ont une résistance de détection de courant de 0,068 Ω.
Cela signifie que pour une limite de courant de 1A sur une carte avec des résistances de 0,068 Ω, la Vref doit être de 540 mV.
Pour choisir la bonne limite de courant, consultez la fiche technique de votre moteur pas à pas. Si vous ne trouvez pas la valeur du courant, je recommande de commencer avec une limite de 1A. Vous pourrez toujours l’augmenter plus tard si votre moteur/driver rate des pas.
En mode pas complet, le courant dans chaque bobine est limité à environ 70 % de la limite de courant réglée. Cela signifie qu’il faut régler la limite de courant 40 % plus élevée, soit 1,4 A en mode pas complet. En micro-pas, la formule ci-dessus s’applique.
Notez que vous devez recalibrer la limite de courant si vous changez la tension d’alimentation du moteur. Si votre moteur fait beaucoup de bruit, essayez de baisser la limite de courant. Il est préférable de régler la limite juste assez haute pour que le moteur ne rate pas de pas.
Mesurer Vref
Vous devez maintenant mesurer la tension de référence (Vref) entre les deux points indiqués sur la photo ci-dessous (GND et potentiomètre) et l’ajuster à la valeur calculée.
Je recommande d’utiliser des câbles crocodiles fixés au tournevis pour régler la limite de courant. Cela vous permet d’ajuster le potentiomètre et de mesurer la tension de référence en même temps.
Note : Il existe une autre méthode pour mesurer la limite de courant, qui consiste à mesurer directement le courant consommé par le moteur pas à pas. Personnellement, je trouve la méthode ci-dessus beaucoup plus simple.
Pololu mentionne sur son site web :
Note : Le courant dans la bobine peut être très différent du courant d’alimentation, donc vous ne devez pas utiliser le courant mesuré à l’alimentation pour régler la limite de courant. Le bon endroit pour placer votre ampèremètre est en série avec une des bobines du moteur pas à pas.
FAQ sur la limite de courant
Dois-je avoir le moteur pas à pas connecté ou non ?
Non, vous n’avez pas besoin de connecter le moteur au driver pour régler la limite de courant. Pour être sûr, déconnectez votre moteur, il peut parfois perturber la mesure de la tension Vref.
Dois-je faire tourner le moteur en lançant le sketch Arduino ?
Non, voir la question précédente.
Dois-je tourner le potentiomètre dans le sens horaire ou antihoraire pour augmenter Vref ?
Cela dépend du fabricant du driver. Si vous avez une carte Pololu originale DRV8825 ou A4988, tournez le potentiomètre dans le sens horaire pour augmenter Vref et dans le sens antihoraire pour la diminuer.
Refroidissement du driver
Le circuit intégré A4988 supporte un courant maximal de 2 A par bobine, mais sans dissipateur thermique, il ne peut fournir qu’environ 1 A par bobine avant de surchauffer.
Le driver est généralement livré avec un petit dissipateur thermique autocollant, que je vous recommande d’installer immédiatement. Vous pouvez aussi acheter plusieurs petits heat sinks sur Amazon pour pas cher.
Exemple de code Arduino basique pour contrôler un moteur pas à pas
Maintenant que vous avez câblé le driver et réglé la limite de courant, il est temps de connecter l’Arduino à l’ordinateur et de téléverser du code. Vous pouvez téléverser le code d’exemple suivant sur votre Arduino en utilisant le Arduino IDE. Pour cet exemple précis, vous n’avez pas besoin d’installer de bibliothèque.
Ce sketch contrôle la vitesse, le nombre de tours et le sens de rotation du moteur pas à pas.
// Example sketch to control a stepper motor with A4988 stepper motor driver
// and Arduino without a library.
// https://www.makerguides.com
// Define stepper motor connections and steps per revolution:
#define dirPin 2
#define stepPin 3
#define stepsPerRevolution 200
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
void loop() {
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
// Spin the stepper motor 1 revolution quickly:
for (int i = 0; i < stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(1000);
digitalWrite(stepPin, LOW);
delayMicroseconds(1000);
}
delay(1000);
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 5 revolutions fast:
for (int i = 0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
// Set the spinning direction counterclockwise:
digitalWrite(dirPin, LOW);
//Spin the stepper motor 5 revolutions fast:
for (int i = 0; i < 5 * stepsPerRevolution; i++) {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
delay(1000);
}
Fonctionnement du code :
Le sketch commence par définir les broches step et direction. Je les ai connectées aux broches 3 et 2 de l’Arduino.
L’instruction #define sert à donner un nom à une valeur constante. Le compilateur remplacera toute référence à cette constante par la valeur définie lors de la compilation. Ainsi, partout où vous mentionnez dirPin, le compilateur le remplacera par la valeur 2 lors de la compilation.
J’ai aussi défini une constante stepsPerRevolution . Comme j’ai réglé le driver en mode pas complet, je l’ai mise à 200 pas par révolution. Changez cette valeur si votre configuration est différente.
// Define stepper motor connections and steps per revolution #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 200
setup
Dans la section setup() du code, toutes les broches de contrôle du moteur sont déclarées en sortie digitale avec la fonction pinMode().
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
loop
Dans la section loop() du code, on fait tourner le moteur lentement d’un tour dans le sens horaire, puis rapidement d’un tour dans le sens antihoraire. Ensuite, on fait tourner le moteur 5 tours dans chaque direction à grande vitesse. Comment contrôler la vitesse, le sens de rotation et le nombre de tours ?
// Set the spinning direction clockwise:
digitalWrite(dirPin, HIGH);
// Spin the stepper motor 1 revolution slowly:
for(int i = 0; i < stepsPerRevolution; i++)
{
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(2000);
digitalWrite(stepPin, LOW);
delayMicroseconds(2000);
}
Contrôle du sens de rotation :
Pour contrôler le sens de rotation du moteur pas à pas, on met la broche DIR soit à HIGH soit à LOW. Pour cela, on utilise la fonction digitalWrite(). Selon la façon dont vous avez connecté le moteur, mettre DIR à HIGH fera tourner le moteur dans le sens horaire ou antihoraire.
Contrôle du nombre de pas ou de tours :
Dans ce sketch d’exemple, les boucles for contrôlent le nombre de pas que le moteur effectuera. Le code dans la boucle for correspond à 1 pas du moteur. Comme la boucle s’exécute 200 fois (stepsPerRevolution), cela fait 1 tour. Dans les deux dernières boucles, le code s’exécute 1000 fois, soit 1000 pas ou 5 tours.
Notez que vous pouvez changer le second terme dans la boucle for pour le nombre de pas souhaité. for(int i = 0; i < 100; i++) donnerait 100 pas, soit un demi-tour.
Contrôle de la vitesse :
La vitesse du moteur pas à pas est déterminée par la fréquence des impulsions envoyées à la broche STEP. Plus la fréquence est élevée, plus le moteur tourne vite. Vous pouvez contrôler la fréquence des impulsions en modifiant delayMicroseconds() dans le code. Plus le délai est court, plus la fréquence est élevée, plus le moteur tourne vite.
Tutoriel sur la bibliothèque AccelStepper
La bibliothèque AccelStepper écrite par Mike McCauley est une excellente bibliothèque pour vos projets. 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 utiles.
Vous pouvez télécharger la dernière version de cette bibliothèque en cliquant sur le bouton ci-dessous.
Vous pouvez installer la bibliothèque en allant dans Sketch > Include Library > Add .ZIP Library… dans l’IDE Arduino.
Une autre option est d’aller dans Tools > Manage Libraries… ou de taper 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 chercher la bibliothèque de Mike McCauley. Sélectionnez 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).
/* Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: continuous rotation.Homepage*/ // Include the AccelStepper library: #include "AccelStepper.h" // Define stepper motor connections and motor interface type. // Motor interface type must be set to 1 when using a driver #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1 // Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin); void setup() { // Set the maximum speed in steps per second: stepper.setMaxSpeed(1000); } void loop() { // Set the speed in steps per second: stepper.setSpeed(400); // Step the motor with a constant speed as set by setSpeed(): stepper.runSpeed(); }
Fonctionnement du code :
La première étape est 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 A4988 vers Arduino et le type d’interface moteur. Le type d’interface doit être réglé à 1 pour un driver step and direction. Vous pouvez trouver les autres types d’interface here.
L’instruction #define sert à donner un nom à une valeur constante. Le compilateur remplacera toute référence à cette constante par la valeur définie lors de la compilation. Ainsi, partout où vous mentionnez dirPin, le compilateur le remplacera par la valeur 2 lors de la compilation.
// Define stepper motor connections and motor interface type. // Motor interface type must be set to 1 when using a driver #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1
Ensuite, vous devez créer une nouvelle instance de la classe AccelStepper avec le type d’interface moteur et les connexions appropriées.
Dans ce cas, j’ai appelé le moteur pas à pas ‘stepper’ mais vous pouvez utiliser d’autres noms, comme ‘z_motor’ ou ‘liftmotor’, etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. Le nom que vous donnez au moteur sera utilisé plus tard pour régler la vitesse, la position et l’accélération de ce moteur. Vous pouvez créer plusieurs instances de la classe AccelStepper avec des noms et broches différents. Cela vous permet de contrôler facilement 2 moteurs pas à pas ou plus en même temps.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
Dans la section setup(), on définit la vitesse maximale en pas/seconde. Des vitesses supérieures à 1000 pas par seconde peuvent être peu fiables, donc je mets cette valeur comme maximum. Notez que je spécifie le nom du moteur (‘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 :
void setup() {
// Set the maximum speed in steps per second:
stepper.setMaxSpeed(1000);
stepper2.setMaxSpeed(500);
}
Dans la loop() on définit d’abord la vitesse à laquelle on veut que le moteur tourne. Pour cela, on utilise la fonction setSpeed(). (vous pouvez aussi placer cela dans la section setup du code).
stepper.runSpeed() interroge le moteur et, lorsqu’un pas est dû, exécute 1 pas. Cela dépend de la vitesse définie et du temps écoulé depuis le dernier pas. Si vous voulez changer le sens du moteur, vous pouvez mettre une vitesse négative : stepper.setSpeed(-400); fait tourner le moteur dans l’autre sens.
void loop() {
// Set the speed in steps per second:
stepper.setSpeed(400);
// Step the motor with a constant speed as set by setSpeed():
stepper.runSpeed();
}
2. Exemple de code pour contrôler le nombre de pas ou de tours
Pour faire tourner le moteur d’un nombre précis de pas, je préfère utiliser une boucle while en combinaison avec stepper.currentPosition(). Vous pouvez utiliser le code d’exemple suivant pour faire tourner le moteur d’avant en arrière.
/* Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: number of steps or revolutions.Homepage*/ // Include the AccelStepper library: #include "AccelStepper.h" // Define stepper motor connections and motor interface type. // Motor interface type must be set to 1 when using a driver #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1 // Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin); void setup() { // Set the maximum speed in steps per second: stepper.setMaxSpeed(1000); } void loop() { // Set the current position to 0: stepper.setCurrentPosition(0); // Run the motor forward at 200 steps/second until the motor reaches 400 steps (2 revolutions): while(stepper.currentPosition() != 400) { stepper.setSpeed(200); stepper.runSpeed(); } delay(1000); // Reset the position to 0: stepper.setCurrentPosition(0); // Run the motor backwards at 600 steps/second until the motor reaches -200 steps (1 revolution): while(stepper.currentPosition() != -200) { stepper.setSpeed(-600); stepper.runSpeed(); } delay(1000); // Reset the position to 0: stepper.setCurrentPosition(0); // Run the motor forward at 400 steps/second until the motor reaches 600 steps (3 revolutions): while(stepper.currentPosition() != 600) { stepper.setSpeed(400); stepper.runSpeed(); } delay(3000); }
Explication du 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 fonction currentPosition() . D’abord, je mets la position actuelle du moteur pas à pas à zéro avec stepper.setCurrentPosition(0).
// Set the current position to 0: stepper.setCurrentPosition(0);
Ensuite, on utilise la boucle while. Une boucle while tourne en continu, 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 à 400 pas (!= signifie : n’est pas égal à). Tant que c’est vrai, on fait tourner le moteur à une vitesse constante définie par setSpeed().
// Run the motor forward at 200 steps/second until the motor reaches 400 steps (2 revolutions):
while(stepper.currentPosition() != 400)
{
stepper.setSpeed(200);
stepper.runSpeed();
}
Dans le reste de la boucle, on fait exactement la même chose, juste avec une vitesse et une position cible différentes.
3. Exemple de code avec accélération et décélération
Avec le sketch suivant, vous pouvez ajouter une accélération et une décélération aux mouvements du moteur pas à pas, sans codage compliqué. Dans cet exemple, le moteur tourne d’avant en arrière à 200 pas par seconde avec une accélération de 30 pas par seconde².
/* Example sketch to control a stepper motor with A4988 stepper motor driver, AccelStepper library and Arduino: acceleration and deceleration.Homepage*/ // Include the AccelStepper library: #include "AccelStepper.h" // Define stepper motor connections and motor interface type. // Motor interface type must be set to 1 when using a driver #define dirPin 2 #define stepPin 3 #define motorInterfaceType 1 // Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin); void setup() { // Set the maximum speed and acceleration: stepper.setMaxSpeed(200); stepper.setAcceleration(30); } void loop() { // Set the target position: stepper.moveTo(600); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition(); delay(1000); // Move back to zero: stepper.moveTo(0); stepper.runToPosition(); delay(1000); }
Explication du code :
Dans 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 speed and acceleration:
stepper.setMaxSpeed(200);
stepper.setAcceleration(30);
}
Dans la boucle, j’ai utilisé une autre méthode pour faire tourner le moteur d’un nombre défini de pas. La fonction stepper.moveTo() sert à définir la position cible. La fonction stepper.runToPostion() fait bouger le moteur (avec accélération/décélération) vers la position cible et bloque jusqu’à ce qu’il y soit. Comme cette fonction est bloquante, ne l’utilisez pas si vous devez contrôler d’autres choses en même temps.
// Set the target position: stepper.moveTo(600); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Conclusion
Dans cet article, je vous ai montré comment contrôler un moteur pas à pas avec le driver A4988 et Arduino. J’espère que vous l’avez trouvé utile et instructif. J’ai personnellement beaucoup utilisé ce driver pour plusieurs imprimantes 3D et autres projets CNC.
Si vous souhaitez en savoir plus sur d’autres drivers de moteurs pas à pas, les articles ci-dessous pourraient vous intéresser :
- How to control a stepper motor with DRV8825 driver and Arduino
- 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
- How to control a Stepper Motor with Arduino Motor Shield Rev3
- TB6600 Stepper Motor Driver with Arduino Tutorial
J’ai aussi un article sur How To Drive a Stepper Motor using the A4988 driver and ESP32 si vous voulez travailler avec un microcontrôleur ESP32 à la place.
Si vous avez des questions ou si vous pensez que des choses manquent, n’hésitez pas à laisser un commentaire ci-dessous.
