Comment contrôler un moteur pas à pas avec Arduino Motor Shield Rev3

Dans ce tutoriel, vous apprendrez comment contrôler un moteur pas à pas avec le Arduino Motor Shield Rev3. J’ai inclus un schéma de câblage et de nombreux exemples de code.

Tout d’abord, nous examinons un exemple utilisant la bibliothèque Arduino Stepper. Cette bibliothèque est idéale pour un contrôle basique du moteur pas à pas mais ne propose pas beaucoup de fonctionnalités supplémentaires.

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 facile à utiliser et peut grandement améliorer les performances de votre matériel.

Fournitures

Composants matériels

	Arduino Motor Shield Rev3	× 1	Amazon
	NEMA 17 stepper motor *	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Power supply (5-12 V)	× 1	Amazon
	USB cable type A/B	× 1	Amazon

Dans ce tutoriel, j’ai utilisé un moteur pas à pas bipolaire à 4 fils. Essayez de trouver un moteur pas à pas pouvant fonctionner entre 5 et 12 V et ne dépassant pas la limite de courant de 2 A. Ce  Stepper motor  modèle d’Adafruit fonctionne très bien à 12 V et ne consomme pas trop de courant (350 mA).

Logiciel

Arduino IDE

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 l’Arduino Motor Shield Rev3

Le  Arduino Motor Shield Rev3  est basé sur le driver double pont en H L298 fabriqué par STMicroelectronics. Avec ce shield, vous pouvez piloter des moteurs DC, un moteur pas à pas, des relais et des solénoïdes. Il dispose de deux canaux séparés, appelés A et B, que vous pouvez utiliser pour piloter 2 moteurs DC ou 1 moteur pas à pas lorsqu’ils sont combinés.

Un point très important à retenir est que le L298 est un driver à tension constante. Cela signifie que la consommation de courant dépend du rapport entre l’inductance et la résistance (L/R) du moteur que vous y connectez.

Cela signifie que vous devez être prudent lors du choix du moteur pas à pas et de l’alimentation à utiliser avec ce shield.  Tous les moteurs pas à pas ne fonctionneront pas !  La tension de fonctionnement du shield est comprise entre 5 et 12 volts. Comme le shield peut fournir un maximum de 2 ampères par canal, vous devez trouver un moteur pas à pas adapté à cette plage de tension et ne dépassant pas la limite de courant maximale. Le moteur que j’ai utilisé pour ce tutoriel consomme environ 1A à 5V.

Si le moteur que vous souhaitez piloter ne fonctionne pas avec ce shield, je vous recommande d’utiliser un driver à découpage. J’ai écrit un tutoriel pour le  A4988  et le  DRV8825  driver qui fonctionnent très bien avec de nombreux moteurs pas à pas.

Spécifications de l’Arduino Motor Shield Rev3

Tension de fonctionnement	5 V à 12 V
Contrôleur moteur	L298P, pilote 2 moteurs DC ou 1 moteur pas à pas
Courant max	2A par canal ou 4A max (avec alimentation externe)
Détection de courant	1,65V/A
Fonctions	Libre, arrêt et frein
Coût	Check price

Pour plus d’informations, vous pouvez consulter les fiches techniques ici.

Entrées et sorties

Fonction	Broches Canal A	Broches Canal B
Direction	D12	D13
PWM	D3	D11
Frein	D9	D8
Détection de courant	A0	A1

Câblage – Connexion d’un moteur pas à pas à l’Arduino Motor Shield Rev3

Le schéma de câblage ci-dessous montre comment connecter un moteur pas à pas et une alimentation au shield moteur Arduino.

Les connexions sont également indiquées dans le tableau ci-dessous.

Connexions Arduino Motor Shield Rev3

Arduino Motor Shield Rev3	Connexion
Vin	5 – 12 V
GND	Masse de l’alimentation
A-	Bobine 1 du moteur pas à pas
A+	Bobine 1 du moteur pas à pas
B-	Bobine 2 du moteur pas à pas
B+	Bobine 2 du moteur pas à pas

Avertissement

Il est possible d’alimenter directement le shield depuis l’Arduino, mais ce n’est pas recommandé. Lorsque le moteur pas à pas consomme trop de courant, vous pouvez endommager à la fois le shield et l’Arduino. Je recommande donc d’utiliser une alimentation externe pour les moteurs.

Pour cela, vous devez couper le cavalier Vin Connect à l’arrière du shield. Après cela, vous pouvez alimenter l’Arduino séparément via un câble USB ou via la prise d’alimentation DC 5,5 mm.

Comment déterminer le câblage du moteur pas à pas ?

Si vous ne trouvez pas la fiche technique de votre moteur pas à pas, il peut être difficile de savoir quel fil correspond à quoi. J’utilise l’astuce suivante pour déterminer comment connecter les moteurs pas à pas bipolaires à 4 fils :

La seule chose à identifier est les deux paires de fils connectées aux deux bobines du moteur. Les fils d’une bobine se connectent à A- et A+ et l’autre paire à B- et B+, la polarité n’a pas d’importance.

Pour trouver les deux fils d’une bobine, procédez comme suit avec le moteur déconnecté :

1. Essayez de faire tourner l’arbre du moteur pas à pas à la main et notez la résistance au mouvement.
2. Ensuite, prenez une paire de fils au hasard et touchez les extrémités dénudées ensemble.
3. Puis, tout en maintenant les extrémités en contact, essayez de faire tourner l’arbre du moteur à nouveau.

Si vous ressentez une forte résistance, vous avez trouvé une paire de fils de la même bobine.  Si l’arbre tourne encore librement, essayez une autre paire de fils. Connectez ensuite les deux bobines aux broches indiquées dans le schéma de câblage ci-dessus.

Exemple de code Arduino basique pour moteur pas à pas et Arduino Motor Shield avec la bibliothèque Stepper.h

Vous pouvez téléverser l’exemple de code suivant sur votre Arduino en utilisant le  Arduino IDE.

Cet exemple utilise la bibliothèque Stepper.h, qui devrait être 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 stepper motor with 
   Arduino Motor Shield Rev3, Arduino UNO and Stepper.h library. 
   https://www.makerguides.com */

#include "Stepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Initialize the stepper library on the motor shield:
Stepper myStepper = Stepper(stepsPerRevolution, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the motor speed (RPMs):
  myStepper.setSpeed(60);
}


void loop() {
  // Step one revolution in one direction:
  myStepper.step(200);

  delay(2000);

  //Step on revolution in the other direction:
  myStepper.step(-200);

  delay(2000);
}

Explication du code :

Le sketch commence par inclure la bibliothèque Arduino Stepper.h. Plus d’informations sur cette bibliothèque sont disponibles sur le  Arduino website.

#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 200 pas pour faire 360 degrés. Vous pouvez modifier cette valeur si vous utilisez un autre type de moteur pas à pas ou une autre configuration.

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

Après cela, nous définissons les connexions du moteur (voir spécifications et schéma de câblage ci-dessus).

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 du programme. Ainsi, partout où vous mentionnez  pwmA, le compilateur le remplacera par la valeur 3 lors de la compilation.

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

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)  où steps est le nombre de pas par révolution et pin1 et pin2 sont les broches utilisées pour piloter le moteur pas à pas. Dans notre cas, ce sont dirA et dirB.

// Initialize the stepper library on the motor shield:
Stepper myStepper = Stepper(stepsPerRevolution, dirA, dirB);

Dans cet exemple, 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, dirA, dirB);.

Dans le setup, nous commençons par configurer les broches de frein et PWM en sortie avec la fonction  pinMode(). Les broches PWM doivent être mises à HIGH et les broches de frein à LOW avec la fonction  digitalWrite().

  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

Vous pouvez régler la vitesse du moteur en tours par minute avec la fonction  setSpeed(rpm). Je l’ai réglée à 60, donc nous devrions voir 1 révolution par seconde.

  // Set the motor speed (RPMs):
  myStepper.setSpeed(60);

Boucle

Dans la boucle, nous appelons simplement la fonction  step(steps)  qui fait tourner le moteur d’un nombre spécifique 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:
  myStepper.step(200);

  delay(2000);

  //Step on revolution in the other direction:
  myStepper.step(-200);

  delay(2000);
}

Notez que la fonction step(steps) est bloquante, ce qui signifie qu’elle attend que le moteur ait fini de bouger avant de passer à la ligne suivante de votre sketch.

Exemples de code pour Arduino Motor Shield 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 pas à pas doit effectuer. Dans ces exemples, j’utiliserai 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 télécharger la dernière version de cette bibliothèque ici :

Vous pouvez installer la bibliothèque en allant dans Sketch > Include Library > Add .ZIP Library… dans l’IDE Arduino.

Une autre option est de naviguer vers Tools > Manage Libraries… ou de taper Ctrl + Shift + I sous Windows. Le gestionnaire de bibliothèques s’ouvrira et mettra à 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 à 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 en haut à droite du champ de code.

/* Example sketch to control a stepper motor with
   Arduino Motor Shield Rev3, Arduino UNO and AccelStepper.h library: 
   continuous rotation. More info: https://www.makerguides.com */

// Include the AccelStepper library:
#include "AccelStepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);
}

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 :

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

#include "AccelStepper.h"

Après avoir spécifié les connexions comme précédemment, nous devons définir le type d’interface moteur pour la bibliothèque AccelStepper. Dans ce cas, nous piloterons le moteur pas à pas en mode pas complet, avec deux fils, donc nous réglons le mode à 2. Vous pouvez trouver les autres types d’interface ici (link).

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

Ensuite, vous devez créer une nouvelle instance de la classe AccelStepper avec le type d’interface moteur approprié et les connexions.

Dans cet exemple, 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, dirA, dirB);.

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

La section setup du code est presque identique à l’exemple précédent, mais j’ai aussi défini la vitesse maximale en pas/seconde. Des vitesses supérieures à 1000 pas par seconde peuvent être peu fiables, donc je l’ai réglée à 600 (vous devrez expérimenter pour trouver la vitesse maximale adaptée à votre configuration). Notez que je spécifie le nom du moteur pas à pas (‘stepper’) pour lequel je veux définir la vitesse maximale.

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);

Boucle

Dans la boucle, nous réglons d’abord la vitesse à laquelle nous voulons que le moteur tourne avec la fonction  setSpeed(). (vous pouvez aussi placer cela dans la section setup du code).

La fonction  stepper.runSpeed()  interroge le moteur et lorsqu’un pas est dû, elle 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 de rotation du moteur, 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();
}

2. Sketch pour contrôler le nombre de pas ou de tours

Avec le sketch suivant, vous pouvez contrôler la vitesse, la direction et le nombre de pas/tours. Aucune accélération ou décélération n’est utilisée.

Dans ce cas, le moteur pas à pas effectue 1 tour dans le sens horaire à 400 pas/sec, puis 1 tour dans le sens antihoraire à 200 pas/sec, et enfin 3 tours dans le sens horaire à 600 pas/sec.

/* Example sketch to control a stepper motor with 
  Arduino Motor Shield Rev3, Arduino UNO and 
  AccelStepper.h library: number of steps or revolutions. 
  More info: https://www.makerguides.com */

#include "AccelStepper.h"

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(600);
}

void loop() {
  // Set the current position to 0:
  stepper.setCurrentPosition(0);

  // Run the motor forward at 400 steps/second until the motor reaches 200 steps (1 revolution):
  while (stepper.currentPosition() != 200) {
    stepper.setSpeed(400);
    stepper.runSpeed();
  }

  delay(1000);

  // Reset the position to 0:
  stepper.setCurrentPosition(0);

  // Run the motor backwards at 200 steps/second until the motor reaches -200 steps (1 revolution):
  while (stepper.currentPosition() != -200) {
    stepper.setSpeed(-200);
    stepper.runSpeed();
  }

  delay(1000);

  // Reset the position to 0:
  stepper.setCurrentPosition(0);

  // Run the motor forward at 600 steps/second until the motor reaches 600 steps (3 revolutions):
  while (stepper.currentPosition() != 600) {
    stepper.setSpeed(600);
    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  while loop  en combinaison avec la fonction  currentPosition()  . D’abord, je définis la position actuelle du moteur pas à pas à zéro avec  stepper.setCurrentPosition(0).

  // Set the current position to 0:
  stepper.setCurrentPosition(0);

Ensuite, nous utilisons une boucle while. Une boucle while s’exécute continuellement et indéfiniment tant que l’expression entre parenthèses () est vraie. Ici, je vérifie si la position actuelle du moteur pas à pas n’est pas égale à 200 pas (!= signifie : n’est pas égal à). Tant que c’est vrai, nous faisons tourner le moteur à une vitesse constante définie par  setSpeed().

  // Run the motor forward at 400 steps/second until the motor reaches 200 steps (1 revolution):
  while (stepper.currentPosition() != 200) {
    stepper.setSpeed(400);
    stepper.runSpeed();
  }

Dans le reste de la boucle, nous faisons 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

Dans cet exemple, nous allons voir une des principales fonctionnalités de la bibliothèque AccelStepper : l’ajout d’accélération et de 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é. La première partie de ce sketch est la même que dans l’exemple 1, mais le setup et la boucle sont différents.

Le moteur effectuera cinq tours aller-retour à une vitesse de 200 pas par seconde et une accélération de 50 pas/seconde ² .

/* Example sketch to control a stepper motor with 
  Arduino Motor Shield Rev3, Arduino UNO and 
  AccelStepper.h library: acceleration and deceleration 
  More info: https://www.makerguides.com */

#include <AccelStepper.h>

// Define number of steps per revolution:
const int stepsPerRevolution = 200;

// Give the motor control pins names:
#define pwmA 3
#define pwmB 11
#define brakeA 9
#define brakeB 8
#define dirA 12
#define dirB 13

// Define the AccelStepper interface type:
#define MotorInterfaceType 2

// Create a new instance of the AccelStepper class:
AccelStepper stepper = AccelStepper(MotorInterfaceType, dirA, dirB);

void setup() {
  // Set the PWM and brake pins so that the direction pins can be used to control the motor:
  pinMode(pwmA, OUTPUT);
  pinMode(pwmB, OUTPUT);
  pinMode(brakeA, OUTPUT);
  pinMode(brakeB, OUTPUT);

  digitalWrite(pwmA, HIGH);
  digitalWrite(pwmB, HIGH);
  digitalWrite(brakeA, LOW);
  digitalWrite(brakeB, LOW);

  // Set the maximum steps per second:
  stepper.setMaxSpeed(200);
  // Set the maximum acceleration in steps per second^2:
  stepper.setAcceleration(50);
}

void loop() {
  // Set target position:
  stepper.moveTo(1000);
  // 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, nous devons définir l’accélération/décélération. Pour cela, nous utilisons la fonction  setAcceleration().

  // Set the maximum steps per second:
  stepper.setMaxSpeed(200);
  // Set the maximum acceleration in steps per second^2:
  stepper.setAcceleration(50);

Dans la boucle, j’ai utilisé 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, nous utilisons 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érera avant d’atteindre la position cible.

  // Set target position:
  stepper.moveTo(1000);
  // Run to position with set speed and acceleration:
  stepper.runToPosition();

Enfin, nous remettons la nouvelle position cible à 0, pour revenir à l’origine.

Conclusion

Dans cet article, je vous ai montré comment contrôler un moteur pas à pas avec l’Arduino Motor Shield Rev3. Nous avons vu 4 exemples, utilisant à la fois les bibliothèques Stepper et AccelStepper.

J’espère que vous l’avez trouvé utile et instructif. Si vous souhaitez en savoir plus sur d’autres drivers (microstepping) comme le  A4988, consultez les articles ci-dessous.

Autres tutoriels sur les moteurs pas à pas :

• Control a stepper motor with L298N motor driver and Arduino
• 28BYJ-48 Stepper Motor with ULN2003 Driver and Arduino Tutorial
• 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 d’autres questions, laissez simplement un commentaire ci-dessous.