Cet article contient tout ce que vous devez savoir pour contrôler un moteur pas à pas avec le DRV8825 stepper motor driver 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.
Fournitures
Composants matériels
 | DRV8825 stepper motor driver | × 1 | Amazon |
 | NEMA 17 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (8.2-45 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 microstepping. 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 DRV8825, vous trouverez une puce fabriquée par Texas Instruments : le contrôleur de moteur pas à pas DRV8825. Ce driver intégré facilite grandement l’interface avec un microcontrôleur puisqu’il suffit 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 45 V et un courant de ± 2 A, ce qui est idéal pour piloter des moteurs pas à pas de petite à moyenne taille comme un NEMA 17 moteur pas à pas bipolaire.
Si vous devez contrôler des moteurs plus gros comme un 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 DRV8825 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 DRV8825
| Tension minimale de fonctionnement | 8.2 V |
| Tension maximale de fonctionnement | 45 V |
| Courant continu par phase | 1.5 A |
| Courant maximal par phase | 2.2 A |
| Tension logique minimale | 2.5 V |
| Tension logique maximale | 5.25 V |
| Résolution du microstepping | pas complet, 1/2, 1/4, 1/8, 1/16 et 1/32 |
| Protection contre l’inversion de polarité ? | 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 DRV8825 et A4988
Le DRV8825 est assez similaire au A4988 mais il existe quelques différences clés :
- Le DRV8825 offre un microstepping jusqu’à 1/32, alors que l’A4988 ne descend qu’à 1/16. Un microstepping 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, alors que l’A4988 nécessite 1 µs minimum.
- 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 microstepping
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 microstepping comme le DRV8825 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 (M0, M1 et M2) permettent de choisir l’une des six résolutions de pas selon le tableau ci-dessous.
| M0 | M1 | M2 | Résolution du microstepping |
|---|---|---|---|
| Bas | Bas | Bas | Pas complet |
| Haut | Bas | Bas | 1/2 pas |
| Bas | Haut | Bas | 1/4 pas |
| Haut | Haut | Bas | 1/8 pas |
| Bas | Bas | Haut | 1/16 pas |
| Haut | Bas | Haut | 1/32 pas |
| Bas | Haut | Haut | 1/32 pas |
| Haut | Haut | Haut | 1/32 pas |
Les trois entrées ont des résistances de tirage interne de 100 kΩ vers la masse, donc laisser les trois broches de sélection du microstepping 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 M0 – M2 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 du DRV8825 à l’Arduino et au moteur pas à pas
Le schéma ci-dessus montre comment connecter le driver DRV8825 à un moteur pas à pas et à l’Arduino.
Les connexions sont également indiquées dans le tableau suivant :
Connexions DRV8825
| DRV8825 | Connexion |
|---|---|
| VMOT | 8.2-45 V |
| GND | Masse moteur |
| SLP | 5 V |
| RST | 5 V |
| GND | Masse logique |
| STP | Broche 3 |
| DIR | Broche 2 |
| A1, A2, B1, B2 | Moteur pas à pas |
- L’alimentation moteur est connectée à GND et VMOT (en haut à droite).
- Les deux bobines du moteur pas à pas sont connectées à A1, A2 et B1, B2 (voir ci-dessous).
- La broche GND (en bas à droite) est reliée à la masse du microcontrôleur et VDD est connectée à 5 V.
- 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 le code d’exemple.
- Vous devez connecter RST (reset) et SLP (sleep) à 5 V, sinon le driver ne s’allumera pas.
- La broche EN (enable) peut rester déconnectée, elle est tirée vers le bas par défaut. Lorsque cette broche est mise à HIGH, le driver est désactivé.
- Le DRV8825 dispose également d’une sortie FAULT qui passe à LOW chaque fois que les FETs du pont en H sont désactivés suite à une protection contre les surintensités ou une coupure thermique. Cette broche est laissée déconnectée pour ce tutoriel.
Dans le reste de ce tutoriel, j’ai laissé M0, M1 et M3 déconnectés, donc le driver fonctionne en mode pas complet. Cela facilite l’explication du code. Normalement, j’utiliserais du microstepping 1/16 ou 1/32 en connectant les broches appropriées à 5 V (voir tableau en introduction).
Avertissement
La carte porteuse DRV8825 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 de plus de 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 déterminer comment connecter un moteur pas à pas bipolaire à 4 fils :
La seule chose à identifier est les deux paires de fils qui correspondent aux deux bobines du moteur. Les fils d’une bobine sont connectés à A1 et A2, et ceux de l’autre à B1 et B2, la polarité n’a pas d’importance.
Pour trouver les deux fils d’une même bobine, procédez comme suit avec le moteur déconnecté :
- Essayez de faire tourner l’axe du moteur pas à pas à la main et notez la résistance au mouvement.
- Prenez une paire de fils au hasard du moteur et touchez les 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 d’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.
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é. Le DRV8825 nécessite uniquement une alimentation via VMOT (8.2-45 V) et vous devez appliquer 5 V sur RST et SLP, 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 comme montré précédemment, vous pouvez laisser l’Arduino connecté pour alimenter les broches RST et SLP.
| DRV8825 | Connexion |
|---|---|
| VMOT | 8.2-45 V |
| GND | Masse moteur |
| SLP | 5V |
| RST | 5V |
| GND | Masse logique |
Formule de la limite de courant
L’étape suivante est de calculer la limite de courant avec la formule suivante :
Limite de courant = Vref × 2
Cela signifie que pour une limite de courant de 1 A, la Vref doit être de 0,5 V.
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 nominal, je recommande de commencer avec une limite de courant de 1 A. Vous pourrez toujours l’augmenter plus tard si votre moteur/driver rate des pas.
Info bonus : En mode pas complet, le courant dans chaque bobine est limité à environ 70 % de la limite de courant réglée. Cela signifie que vous devrez régler la limite de courant 40 % plus élevée, soit 1,4 A en mode pas complet. En microstepping, la formule ci-dessus s’applique.
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 indique sur son site :
Note : Le courant dans la bobine peut être très différent du courant à l’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.
Pololu
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 pour 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 driver DRV8825 a une limite de courant maximale de 2,5 A par bobine, mais sans dissipateur thermique, il ne peut fournir qu’environ 1,5 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 dissipateurs sur Amazon à bas prix.
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 avec l’IDE Arduino. Pour cet exemple précis, aucune bibliothèque n’est nécessaire.
Ce sketch contrôle la vitesse, le nombre de tours et le sens de rotation du moteur pas à pas.
Vous pouvez copier le code en cliquant sur le bouton en haut à droite du champ de code.
/* Example sketch to control a stepper motor with
A4988/DRV8825 stepper motor driver and
Arduino without a library.
More info: 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);
}
Comment fonctionne le 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 est utilisée pour 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 la 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
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);
}
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. Alors, 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 (direction) à HIGH ou 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 for loops 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++) correspondrait à 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 installer la bibliothèque 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 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. (Pas d’accélération ni de décélération).
/* Example sketch to control a stepper motor with
DRV8825 stepper motor driver, AccelStepper library
and Arduino: continuous rotation.
More info: https://www.makerguides.com */
#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();
}
Comment fonctionne le code :
La première étape est d’inclure la bibliothèque avec #include "AccelStepper.h".
#include "AccelStepper.h"
L’étape suivante est de définir les connexions DRV8825-Arduino et le type d’interface moteur. Le type d’interface doit être réglé à 1 pour un driver step et direction.
L’instruction #define est utilisée pour donner un nom à une 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 la 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() du code, on définit la vitesse maximale en pas/seconde. Des vitesses supérieures à 1000 pas par seconde peuvent être peu fiables, donc je fixe 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 section loop() on définit d’abord la vitesse à laquelle on veut faire tourner le moteur. Pour cela, on utilise la fonction setSpeed(). (vous pouvez aussi placer cette instruction 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. Pour changer le sens de rotation, 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 while loop 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 DRV8825 stepper motor driver, AccelStepper library
and Arduino: number of steps or revolutions.
More info: https://www.makerguides.com */
#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 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 à 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, mais 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 de l’accélération et de la 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 DRV8825 stepper motor driver, AccelStepper library
and Arduino: acceleration and deceleration.
More info: https://www.makerguides.com */
#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 prédéfini de pas. La fonction stepper.moveTo() sert à définir la position cible. La fonction stepper.runToPostion() déplace 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, il ne faut pas l’utiliser 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 DRV8825 et Arduino. Si vous souhaitez en savoir plus sur d’autres drivers pour moteurs pas à pas, les articles ci-dessous pourraient vous être utiles :
- How to control a stepper motor with A4988 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
Et si vous avez des commentaires, n’hésitez pas à les laisser dans la section commentaires.
