Maîtriser les moteurs pas à pas avec Arduino :le guide complet

Dans ce tutoriel, nous apprendrons tout ce que nous devons savoir sur le contrôle des moteurs pas à pas avec Arduino. Nous expliquerons comment contrôler un moteur pas à pas NEMA17 en combinaison avec un A4988, un DRV8825 et un pilote pas à pas TMC2208.

Cette combinaison de moteurs pas à pas et de pilotes est utilisée dans d'innombrables applications où le contrôle de position est nécessaire, telles que les imprimantes 3D, les machines CNC, la robotique, les machines d'automatisation, etc.

Je l'ai déjà utilisé moi-même dans plusieurs de mes projets Arduino, comme les suivants :

• Curseur de caméra DIY
• Machine à cintrer les fils 3D
• Machine de découpe de mousse DIY
• Graveur laser DIY
• Traceur de stylet avec changeur de stylet automatique
• Bras de robot SCARA

J'expliquerai en détail comment ils fonctionnent, comment connecter des moteurs pas à pas avec Arduino, comment définir la limite de courant des pilotes et comment les programmer avec ou sans bibliothèque Arduino. De plus, je vais vous montrer comment contrôler facilement plusieurs moteurs pas à pas à l'aide d'un blindage CNC Arduino pour tout type de projet Arduino. 

Nous avons donc beaucoup de choses à aborder dans ce didacticiel. Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous qui comprend également tous les exemples de codes et schémas de câblage.

Qu'est-ce qu'un moteur pas à pas et comment fonctionne-t-il ?

Je vais commencer par expliquer brièvement ce qu'est un moteur pas à pas et comment il fonctionne, car cela nous aidera à mieux comprendre tout le reste de ce tutoriel. 

Un moteur pas à pas est un type unique de moteur à courant continu sans balais dont la position peut être contrôlée avec précision même sans aucun retour.

Le principe de fonctionnement d'un moteur pas à pas est basé sur les champs magnétiques. Il comporte deux composants principaux, un stator et un rotor. Le rotor est généralement un aimant permanent et il est entouré de quelques bobines sur le stator.

Lorsque nous alimentons ou laissons le courant circuler dans les bobines, des champs magnétiques particuliers sont générés dans le stator qui attirent ou repoussent le rotor. En activant les bobines, étape par étape, l'une après l'autre dans un ordre particulier, nous pouvons obtenir un mouvement continu du rotor, mais aussi le faire arrêter dans n'importe quelle position.

C’est pourquoi ces moteurs sont appelés moteurs pas à pas, ils se déplacent par étapes discrètes. 

En augmentant le nombre de pôles magnétiques sur le rotor, on peut augmenter le nombre de positions d'arrêt possibles, augmentant ainsi la résolution ou la précision du moteur. Veuillez noter qu'il ne s'agit que d'une explication de base et que vous pouvez trouver plus de détails dans mon didacticiel Comment fonctionnent les moteurs pas à pas. 

Un moteur pas à pas typique, un NEMA17 par exemple, comporte 50 points d'arrêt ou étapes sur le rotor. D'autre part, le stator peut avoir plusieurs bobines organisées en deux phases qui fournissent quatre orientations ou positions différentes du champ magnétique.

Ainsi, les 50 pas du rotor multipliés par les 4 orientations différentes du champ magnétique, font un total de 200 pas pour effectuer une rotation complète. Ou si nous divisons 360 degrés par 200 pas, cela équivaut à une résolution de 1,8 degrés par pas.

J'ai mentionné que les bobines du stator sont organisées en deux phases, et on peut également le remarquer si l'on regarde le nombre de fils d'un moteur pas à pas. Il dispose de 4 quatre fils, deux pour chaque phase. Les quatre orientations différentes du champ magnétique sont possibles car nous pouvons laisser le courant circuler à travers les phases dans les deux sens.

Il existe également des moteurs pas à pas à 5, 6 ou même 8 fils, mais ils fonctionnent toujours sur deux phases ou nous les contrôlons avec seulement quatre bornes.

Le problème avec eux, c'est qu'ils peuvent fournir différentes caractéristiques de performance, comme plus de couple ou plus de vitesse, selon la façon dont nous connectons ces fils sur les quatre bornes de commande.

Néanmoins, avec cette brève explication, nous comprenons maintenant que pour piloter un moteur pas à pas, nous ne pouvons pas simplement y connecter l'alimentation car rien ne se passera. Au lieu de cela, nous devons alimenter les deux phases du moteur dans les deux sens, et les activer ou leur envoyer des impulsions dans un ordre particulier, dans une séquence opportune. C’est pourquoi nous avons besoin de pilotes pour contrôler les moteurs pas à pas. 

Il existe de nombreux types et tailles de pilotes, correspondant aux nombreux types et tailles de moteurs pas à pas. Cependant, le principe de fonctionnement de base de chacun d'entre eux est qu'ils disposent de deux ponts en H qui permettent d'alimenter les phases du moteur dans les deux sens.

Bien sûr, ils ont de nombreuses autres fonctions comme le micro-pas, la limitation de courant, etc. qui nous permettent de contrôler facilement les moteurs pas à pas, ce qui est tout leur objectif.

Comment contrôler le moteur pas à pas NEMA17 avec Arduino et le pilote pas à pas A4988

Très bien, nous pouvons maintenant jeter un œil au premier exemple de ce didacticiel, comment contrôler un moteur pas à pas NEMA 17 avec un pilote pas à pas A4988. 

Très bien, nous pouvons maintenant jeter un œil au premier exemple de ce didacticiel, comment contrôler un moteur pas à pas NEMA 17 avec un entraînement pas à pas A4988.

Le NEMA17 est le moteur pas à pas le plus populaire parmi les fabricants, car il offre d’excellentes performances tout en étant abordable. On le trouve également dans presque toutes les imprimantes 3D de bureau et graveurs laser. 

Généralement, le moteur pas à pas NEMA17 a 200 pas, soit une résolution de 1,8 degrés par pas, mais il existe également des modèles avec 400 pas et une résolution de 0,9 degrés par pas. Nous devons noter ici que la désignation NEMA17 décrit en fait uniquement la taille du moteur en termes de taille de la façade avant.

Le nombre représente la taille de la façade en pouces lorsqu'il est divisé par 10, ou dans ce cas, cela serait 17 divisé par 10, ce qui équivaut à une façade de 1,7 pouces, ou à une façade de 2,3 pouces dans le cas de NEMA23.

Ainsi, la taille de la plaque frontale est fixe, mais la longueur des moteurs pas à pas NEMA17 peut varier de 20 mm à 60 mm, et avec cela la puissance requise du moteur varie également. La puissance requise est généralement définie par la quantité de courant que le moteur est autorisé à consommer, et la plage de ces moteurs pas à pas NEMA17 va de 0,3 A à 2,5 A.

Maintenant, en fonction de la valeur nominale actuelle du moteur pas à pas, nous devons choisir un pilote approprié capable de gérer cette quantité de courant. Le pilote de moteur pas à pas NEMA17 le plus populaire est le pilote de moteur pas à pas A4988.

L’A4988 a un courant nominal maximum de 2 A par bobine, mais il s’agit en fait d’un courant nominal maximal. Il est recommandé de maintenir le courant à environ 1A, mais bien sûr, il est également possible d'aller jusqu'à 2A sous réserve d'un bon refroidissement du circuit intégré. 

Une fonctionnalité intéressante du pilote pas à pas A4988, comme en fait tous les autres lecteurs, est la limitation de courant. Avec cela, nous pouvons facilement définir la quantité de courant que le moteur consommera, quelle que soit sa puissance nominale. Par exemple, nous pouvons même connecter un moteur pas à pas de 2,5 A, mais nous limiterons le courant du pilote à 1,5 A. Ainsi, même si le moteur ne fonctionnera pas à sa capacité maximale, nous pourrons quand même l'utiliser.

D'un autre côté, si la puissance nominale du moteur est inférieure à la limite de courant définie sur le pilote, le moteur surchauffera. Bien sûr, il est toujours recommandé d'essayer de faire correspondre la valeur nominale actuelle du moteur avec la valeur nominale actuelle du conducteur.

Connexion A4988 et Arduino

Très bien, voyons maintenant comment connecter le pilote A4988 au moteur pas à pas et au contrôleur Arduino.

Vous pouvez obtenir les composants nécessaires à ce didacticiel Arduino à partir des liens ci-dessous :

• Moteur pas à pas NEMA 17……………… Amazon / Banggood / AliExpress
• Pilote pas à pas A4988…………………..… Amazon / Banggood / AliExpress
• Pilote pas à pas DRV8825……….……..… Amazon / Banggood / AliExpress
• Pilote pas à pas TMC2208 ……………… Amazon / Banggood / AliExpress
• Bouclier CNC Arduino ………………………. Amazon  / Banggood  / AliExpress
• Arduino Uno………………………………..… Amazon / Banggood / AliExpress

Divulgation :ce sont des liens d'affiliation. En tant qu'associé Amazon, je gagne des revenus grâce aux achats éligibles.

Dans le coin supérieur droit du pilote, nous avons les broches VMOT et GND et ici nous connectons l'alimentation du moteur qui peut aller de 8 à 36 V. Ici, il est également recommandé d'utiliser un condensateur de découplage entre ces deux broches afin de protéger la carte des pics de tension. Nous devrions utiliser un grand condensateur électrolytique d'une capacité d'au moins 47 uF. 

Ensuite, se trouvent les quatre broches auxquelles nous connectons le moteur pas à pas. Une phase du moteur va sur les broches 1A et 1B, et l'autre phase sur les broches 2A et 2B. 

Parfois, il peut être un peu difficile de reconnaître quels deux fils du moteur constituent une phase, mais il existe plusieurs façons de les identifier. Le moyen le plus simple consiste à faire tourner l'arbre du moteur pas à pas à la main, puis à connecter deux fils l'un à l'autre. Si vous connectez deux fils qui forment une phase, la rotation de l'arbre serait un peu plus difficile.

Une autre façon consiste à utiliser un multimètre et à vérifier la continuité entre les deux fils. Si vous connectez deux fils qui forment une phase, vous aurez un court-circuit et le multimètre commencera à émettre un bip.

Une fois que nous avons trouvé une phase, nous pouvons la connecter à n'importe quelle position des deux positions sur le driver, l'ordre n'a pas d'importance. 

Ensuite, nous avons le CI ou les broches d'alimentation logique, VDD et GND, qui peuvent être de 3V à 5V. De l'autre côté, nous avons les broches Step et Direction, qui peuvent être connectées à n'importe quelle broche de la carte Arduino. Avec la broche Direction, nous sélectionnons le sens de rotation du moteur, et avec la broche Step, nous contrôlons les pas du moteur. À chaque impulsion que nous envoyons à la broche Step, le moteur avance d'un pas dans la direction sélectionnée. 

Juste au-dessus de ces broches, nous avons les broches Sleep et Reset qui servent, comme leurs noms l'indiquent, à mettre le pilote en mode veille ou à le réinitialiser. Nous devons noter que ces deux broches sont actives à un niveau bas. La broche de veille par défaut est à l'état ÉLEVÉ, mais la broche RST est flottante. Cela signifie que pour activer le pilote, le moyen le plus simple est simplement de connecter ces deux broches entre elles, en supposant que nous n'utiliserons pas ces fonctions de broches. 

La broche d'activation est également active à un niveau bas, donc à moins que nous ne la tirions sur HAUT, le pilote sera activé. 

Les trois broches suivantes, MS1, MS2 et MS3, servent à sélectionner la résolution pas à pas du moteur. Nous avons déjà dit que la résolution des pas dépend de la construction du moteur qui est généralement de 200 pas par tour pour un moteur pas à pas NEMA 17. Cependant, tous les pilotes pas à pas disposent de cette fonctionnalité appelée micropas qui permet de piloter le moteur à des résolutions plus élevées. Ceci est réalisé en alimentant les bobines à un niveau de courant intermédiaire, qui produisent des emplacements d'étapes intermédiaires.

Par exemple, si nous sélectionnons une résolution d'un quart de pas, les 200 pas du moteur deviendront 200 multiplié par 4 équivaut à 800 micropas par tour. Le pilote utilisera quatre niveaux de courant différents sur les bobines pour y parvenir. 

Le pilote A4988 a une résolution maximale de 16 micropas, ce qui ferait qu'un moteur NEMA17 de 200 pas aurait 3 200 pas par tour, soit 0,1125 degrés par pas. C'est une précision vraiment impressionnante et c'est pourquoi ces types de moteurs pas à pas et de pilotes sont utilisés dans tant d'applications. En fait, il existe des pilotes pas à pas qui ont jusqu'à 256 micropas, soit 51 200 pas par tour, ou 0,007 degrés par pas.

Néanmoins, ces trois broches ont des résistances pull-down, donc si nous les laissons déconnectées, le pilote fonctionnera en mode pas à pas. Pour sélectionner une résolution de micropas différente, nous devons connecter 5 V aux broches appropriées selon ce tableau. 

A4988 Limitation de courant

Très bien, maintenant que nous savons comment connecter le moteur pas à pas et le pilote à la carte Arduino, nous pouvons continuer en expliquant comment programmer ou coder l'Arduino pour contrôler le moteur pas à pas. Cependant, avant de faire cela, ou avant d'alimenter le moteur, il y a encore une chose très importante que nous devons faire :ajuster la limite de courant du pilote.

Comme nous l'avons déjà expliqué, nous devons ajuster la limite de courant du pilote pour qu'elle soit inférieure au courant nominal du moteur, sinon le moteur surchaufferait.

Il y a un petit potentiomètre trimmer sur le pilote A4988 grâce auquel nous pouvons ajuster la limite de courant. En tournant le potentiomètre dans le sens des aiguilles d'une montre, la limite de courant augmente et vice versa. Deux méthodes peuvent être utilisées pour déterminer la valeur réelle de la limite de courant. 

La première méthode consiste à mesurer la tension de référence aux bornes du potentiomètre lui-même et de GND. Nous pouvons mesurer la tension de référence à l'aide d'un multimètre et utiliser cette valeur dans la formule suivante pour calculer la limite de courant du pilote :

Limite actuelle =Vref / (8 x Rcs)

Le Rcs est la résistance de détection de courant ou les valeurs des résistances de détection de courant situées juste à côté de la puce. Selon le fabricant, ces valeurs sont généralement de 0,05, 0,1 ou 0,2 ohm. Nous devons donc examiner de plus près la valeur de ces résistances afin de calculer avec précision la limite de courant avec cette méthode. Dans mon cas, ces résistances étaient étiquetées R100, ce qui signifiait 0,1 ohms.

À titre d'exemple, si nous mesurons une tension de référence de 0,7 V et que nous avons des résistances de 0,1 ohms, la limite de courant serait de 0,875 A. Ou si nous voulons limiter le courant à, disons, 1 A, nous devons ajuster la tension de référence à 0,8 V. 

La deuxième méthode pour définir la limite de courant consiste à mesurer directement le courant traversant les bobines. Pour cela, nous devons connecter le moteur pas à pas et le driver comme expliqué précédemment. Nous pouvons ignorer la connexion du contrôleur, mais plutôt connecter 5 V aux broches Direction et Step afin que le moteur reste actif et occupe une position. Les broches MS doivent être laissées déconnectées pour que le pilote fonctionne en mode pas à pas. Ensuite, nous pouvons déconnecter une ligne ou une bobine du moteur et la connecter en série avec un ampèremètre. De cette façon, une fois que nous alimentons le pilote avec à la fois la tension logique, le 5 V, et l'alimentation du moteur 12 V dans mon cas, nous pouvons lire la quantité de courant qui traverse la bobine.

Cependant, il convient de noter ici que lorsque le pilote fonctionne en mode pas à pas, le courant dans les bobines ne peut atteindre que 70 % de la limite de courant réelle. Ainsi, lors de l'utilisation du pilote dans les autres modes micropas, la lecture de l'ampèremètre doit être multipliée par 1,3 afin d'obtenir la valeur réelle de la limite de courant du pilote. 

J'ai essayé les deux méthodes pour définir la limite actuelle du pilote et elles m'ont donné à peu près les mêmes résultats.

Moteurs pas à pas et Arduino – Exemples de codes

Néanmoins, nous pouvons maintenant passer à la programmation de l'Arduino, ou jeter un œil à plusieurs exemples de codes pour contrôler un moteur pas à pas avec une carte Arduino.

Commençons par un exemple de code très basique expliquant comment contrôler un moteur pas à pas sans utiliser de bibliothèque.

Exemple de code 1

/* 
 * Basic example code for controlling a stepper without library
 * 
 * by Dejan, https://howtomechatronics.com
 */
// defines pins
#define stepPin 2
#define dirPin 5 
 
void setup() {
 // Sets the two pins as Outputs
 pinMode(stepPin,OUTPUT); 
 pinMode(dirPin,OUTPUT);
}
void loop() {
 digitalWrite(dirPin,HIGH); // Enables the motor to move in a particular direction
 // Makes 200 pulses for making one full cycle rotation
 for(int x = 0; x < 800; x++) {
 digitalWrite(stepPin,HIGH); 
 delayMicroseconds(700); // by changing this time delay between the steps we can change the rotation speed
 digitalWrite(stepPin,LOW); 
 delayMicroseconds(700); 
 }
 delay(1000); // One second delay
 
 digitalWrite(dirPin,LOW); //Changes the rotations direction
 // Makes 400 pulses for making two full cycle rotation
 for(int x = 0; x < 1600; x++) {
 digitalWrite(stepPin,HIGH);
 delayMicroseconds(500);
 digitalWrite(stepPin,LOW);
 delayMicroseconds(500);
 }
 delay(1000);
}Code language: PHP (php)

Description du code :

Ici, tout ce que nous avons à faire est de définir à quel numéro de broche les broches STEP et DIR sont connectées et de les définir comme sorties. Dans la boucle, nous définissons d’abord le sens de rotation du moteur en faisant en sorte que l’état de la broche de direction soit ÉLEVÉ. Ensuite, à l'aide d'une boucle « for », nous envoyons 200 impulsions à la broche STEP qui feront tourner le moteur pendant un cycle complet, étant donné qu'il fonctionne en mode pas complet. Les impulsions sont générées simplement en basculant l'état de la broche STEP HIGH à LOW avec un certain délai entre elles. Cette temporisation définit en réalité la vitesse de rotation. Si on l'abaisse, la vitesse de rotation augmentera à mesure que les pas se produiront plus rapidement, et vice versa. 

Ensuite, nous changeons le sens de rotation et, en utilisant une autre boucle « for », nous envoyons 400 impulsions qui feraient tourner le moteur pendant deux cycles complets. Cependant, si nous changeons le mode micropas du pilote, disons d'un quart de pas, ce qui ferait maintenant au moteur 800 pas, la première boucle fera tourner le moteur de seulement 90 degrés, et la deuxième boucle ne fera qu'une demi-rotation.

Exemple de code 2

Voici un autre exemple simple, contrôlant la vitesse du moteur pas à pas à l'aide d'un potentiomètre.

Pour cela, il suffit de connecter le potentiomètre à l'Arduino et de lire sa valeur à l'aide de la fonction analogRead().

/*
 Basic example code for controlling a stepper without library
 by Dejan, https://howtomechatronics.com
*/
// defines pins
#define stepPin 2
#define dirPin 5
int customDelay, customDelayMapped;
void setup() {
 // Sets the two pins as Outputs
 pinMode(stepPin, OUTPUT);
 pinMode(dirPin, OUTPUT);
}
void loop() {
 speedControl();
 // Makes pules with custom delay, depending on the Potentiometer, from which the speed of the motor depends
 digitalWrite(stepPin, HIGH);
 delayMicroseconds(customDelayMapped);
 digitalWrite(stepPin, LOW);
 delayMicroseconds(customDelayMapped);
}
// Custom function for reading the potentiometer and mapping its value from 300 to 3000, suitable for the custom delay value in microseconds
void speedControl() {
 customDelay = analogRead(A0); // Read the potentiometer value
 customDelayMapped = map(customDelay, 0, 1023, 300, 3000); // Convert the analog input from 0 to 1024, to 300 to 3000
}Code language: PHP (php)

Description du code :

Nous pouvons ensuite mapper ou convertir les valeurs du potentiomètre qui vont de 0 à 1023, en valeurs appropriées pour être un temps de retard en microsecondes pour les impulsions Step. J'ai trouvé que la valeur minimale du délai entre les étapes était d'environ 300 microsecondes. En descendant plus bas, le moteur pas à pas a commencé à sauter des étapes. 

Dans l’ensemble, contrôler les moteurs pas à pas avec cette méthode est facile et fonctionne, mais seulement si le contrôle requis est simple, comme le montrent les exemples. Si nous avons besoin d'un contrôle plus complexe, le meilleur moyen est d'utiliser une bibliothèque Arduino.

Contrôle des moteurs pas à pas avec Arduino et la bibliothèque AccelStepper – Exemples

La bibliothèque la plus populaire pour contrôler les moteurs pas à pas avec Arduino est la bibliothèque AccelStepper de Mike McCauley. Il s'agit d'une bibliothèque extrêmement polyvalente comprenant le contrôle de la vitesse, de l'accélération et de la décélération, la définition des positions cibles, le contrôle simultané de plusieurs moteurs pas à pas, etc.

La bibliothèque dispose d'une excellente documentation expliquant le fonctionnement de chaque fonction. J'ai déjà utilisé cette bibliothèque pour plusieurs de mes projets Arduino, pour contrôler le mouvement de mon curseur de caméra DIY, de la machine à cintrer les fils 3D, du bras robot SCARA et quelques autres. Si vous êtes intéressé, vous trouverez des détails et des explications de code pour chaque projet sur le site Web. 

Jetons maintenant un œil à quelques exemples de code utilisant cette bibliothèque.

Exemple de code – Contrôle de la vitesse d'un moteur pas à pas à l'aide d'un potentiomètre

Le premier exemple consistera à contrôler la vitesse du moteur à l'aide du potentiomètre.

/* 
 * Basic example code for controlling a stepper with the AccelStepper library
 * 
 * by Dejan, https://howtomechatronics.com
 */
#include <AccelStepper.h>
// Define the stepper motor and the pins that is connected to
AccelStepper stepper1(1, 2, 5); // (Type of driver: with 2 pins, STEP, DIR)
void setup() {
 // Set maximum speed value for the stepper
 stepper1.setMaxSpeed(1000);
}
void loop() {
 stepper1.setSpeed((analogRead(A0));
 // Step the motor with a constant speed previously set by setSpeed();
 stepper1.runSpeed();
}Code language: PHP (php)

Description du code :

Donc, ici, nous devons d’abord inclure la bibliothèque AccelStepper. Bien sûr, avant de faire cela, nous devons installer la bibliothèque et nous pouvons le faire à partir du gestionnaire de bibliothèque Arduino IDE. Il suffit de rechercher « AccelStepper » et la bibliothèque apparaîtra et nous pourrons l'installer. 

Ensuite, nous devons créer une instance de la classe AccelStepper pour notre moteur. Le premier paramètre ici est le type de pilote, dans ce cas pour un pilote avec deux broches de contrôle cette valeur est 1, et les deux autres paramètres sont les numéros de broches auxquelles notre pilote est connecté à l'Arduino. Si nous avons plusieurs moteurs pas à pas, nous devons définir chacun d'eux comme ceci, et nous pouvons les nommer comme nous le souhaitons, dans ce cas j'ai nommé mon moteur stepper1. 

Dans la section de configuration, il suffit de définir la vitesse maximale du moteur qui est définie en pas par seconde. Cette valeur peut aller jusqu'à 4000, mais dans la documentation de la bibliothèque, il est indiqué que des valeurs de vitesse supérieures à 1000 pas par seconde peuvent ne pas être fiables. 

Dans la section boucle, en utilisant la fonction setSpeed(), nous définissons la vitesse actuelle du moteur, et dans ce cas, il s'agit de l'entrée analogique du potentiomètre qui est de 0 à 1023.

Pour que le moteur puisse se déplacer et mettre en œuvre cette vitesse constante, nous devons appeler la fonction runSpeed() à chaque intervalle. Une valeur négative ici, ou simplement l'inclusion d'un signe moins avant la valeur, ferait tourner le moteur pas à pas dans la direction opposée.

Exemple de code – Contrôle de deux moteurs pas à pas avec accélération et décélération

Voici un autre exemple de contrôle de deux moteurs pas à pas avec implémentation de l'accélération et de la décélération à l'aide de la bibliothèque AccelStepper.

/*
 Controlling two stepper with the AccelStepper library
 by Dejan, https://howtomechatronics.com
*/
#include <AccelStepper.h>
// Define the stepper motor and the pins that is connected to
AccelStepper stepper1(1, 2, 5); // (Typeof driver: with 2 pins, STEP, DIR)
AccelStepper stepper2(1, 3, 6);
void setup() {
 stepper1.setMaxSpeed(1000); // Set maximum speed value for the stepper
 stepper1.setAcceleration(500); // Set acceleration value for the stepper
 stepper1.setCurrentPosition(0); // Set the current position to 0 steps
 stepper2.setMaxSpeed(1000);
 stepper2.setAcceleration(500);
 stepper2.setCurrentPosition(0);
}
void loop() {
 stepper1.moveTo(800); // Set desired move: 800 steps (in quater-step resolution that's one rotation)
 stepper1.runToPosition(); // Moves the motor to target position w/ acceleration/ deceleration and it blocks until is in position
 stepper2.moveTo(1600);
 stepper2.runToPosition();
 // Move back to position 0, using run() which is non-blocking - both motors will move at the same time
 stepper1.moveTo(0);
 stepper2.moveTo(0);
 while (stepper1.currentPosition() != 0 || stepper2.currentPosition() != 0) {
 stepper1.run(); // Move or step the motor implementing accelerations and decelerations to achieve the target position. Non-blocking function
 stepper2.run();
 //
 //
 }
}Code language: PHP (php)

Description du code :

Nous devons donc définir les deux moteurs pas à pas et, dans la configuration, à l'aide de la fonction setAcceleration(), définir la valeur d'accélération des moteurs. En utilisant la fonction setCurrentPosition(), nous définissons la position des moteurs à 0 pas. 

Dans la section boucle, nous commençons par la fonction moveTo() grâce à laquelle nous indiquons au moteur vers quelle position aller ou combien de pas il doit parcourir. En cas de résolution par quart de pas, 800 pas signifieraient une rotation complète. Ensuite, la fonction runToPosition() déplace le moteur vers cette position tout en implémentant l'accélération et la décélération. Cependant, il s'agit d'une fonction de blocage, donc l'exécution du code y restera jusqu'à ce que le moteur pas à pas atteigne cette position. 

Avec la même méthode, nous déplaçons le deuxième moteur de 1 600 pas ou deux tours complets avec une résolution d'un quart de pas. 

Si nous ne voulons pas que notre code soit bloqué jusqu'à ce que le moteur atteigne la position cible, au lieu d'utiliser la fonction runToPosition(), nous devrions utiliser la fonction run(). Le run() implémente également l'accélération et la décélération pour atteindre la position cible, mais il n'effectue qu'un pas par appel. Nous devons donc l’appeler le plus souvent possible. Pour cette raison, nous plaçons ici les fonctions run() pour les deux moteurs dans cette boucle while, qui est exécutée jusqu'à ce que les deux moteurs pas à pas atteignent la position 0. Nous avons précédemment réglé les deux moteurs pour qu'ils passent en position 0 avec les fonctions moveTo(). 

Nous pourrions également ajouter plus de code dans cette boucle « while » et faire d’autres choses également tout en faisant fonctionner le moteur. En fait, il existe de nombreuses méthodes pour faire fonctionner les moteurs et faire d’autres choses. Je vous recommande de parcourir la documentation bien décrite de la bibliothèque afin que vous puissiez comprendre le fonctionnement de chaque fonction et les implémenter en fonction de vos besoins.

Exemple de code – Contrôle de plusieurs moteurs pas à pas avec la bibliothèque AccelStepper

Je voudrais vous montrer un autre exemple utilisant la bibliothèque AccelStepper et qui contrôle plusieurs moteurs pas à pas de manière coordonnée. Cela signifie que nous pouvons définir des positions cibles pour chaque stepper et qu'ils peuvent tous atteindre leurs positions en même temps, quelle que soit la distance qu'ils doivent parcourir.

Cela peut être facilement fait en utilisant la classe MultiStepper fournie avec la bibliothèque AccelStepper.

/*
 Controlling multiple steppers with the AccelStepper and MultiStepper library
 by Dejan, https://howtomechatronics.com
*/
#include <AccelStepper.h>
#include <MultiStepper.h>
// Define the stepper motor and the pins that is connected to
AccelStepper stepper1(1, 2, 5); // (Typeof driver: with 2 pins, STEP, DIR)
AccelStepper stepper2(1, 3, 6);
AccelStepper stepper3(1, 4, 7);
MultiStepper steppersControl; // Create instance of MultiStepper
long gotoposition[3]; // An array to store the target positions for each stepper motor
void setup() {
 stepper1.setMaxSpeed(1000); // Set maximum speed value for the stepper
 stepper2.setMaxSpeed(1000);
 stepper3.setMaxSpeed(1000);
 // Adding the 3 steppers to the steppersControl instance for multi stepper control
 steppersControl.addStepper(stepper1);
 steppersControl.addStepper(stepper2);
 steppersControl.addStepper(stepper3);
}
void loop() {
 // Store the target positions in the "gotopostion" array
 gotoposition[0] = 800; // 800 steps - full rotation with quater-step resolution
 gotoposition[1] = 1600;
 gotoposition[2] = 3200;
 steppersControl.moveTo(gotoposition); // Calculates the required speed for all motors
 steppersControl.runSpeedToPosition(); // Blocks until all steppers are in position
 delay(1000);
 gotoposition[0] = 0;
 gotoposition[1] = 0;
 gotoposition[2] = 0;
 steppersControl.moveTo(gotoposition);
 steppersControl.runSpeedToPosition();
 delay(1000);
}Code language: PHP (php)

Description du code :

Ici, nous devons également inclure la classe MultiStepper et en créer une instance. Ensuite, nous devons définir un tableau, de type « long », qui sera utilisé pour stocker les positions cibles de nos moteurs. Dans la section de configuration, nous devons définir les valeurs de vitesse maximales des steppers et ajouter les steppers à l'instance MultiStepper précédemment créée, que dans mon cas je l'ai nommée « steppersControl ». 

Dans la section boucle, nous commençons par stocker les valeurs de position cible dans le tableau que nous avons créé précédemment. J'ai réglé le premier stepper pour qu'il effectue une rotation, le deuxième, deux rotations et le troisième, trois rotations. Ensuite, nous pouvons attribuer ce tableau à la fonction moveTo() qui calculera les vitesses requises pour que tous les moteurs arrivent à ces positions en même temps. Il suffit ensuite d'appeler la fonction runSpeedToPosition() qui déplacera les moteurs vers leur position. Il faut cependant noter que cette fonction bloque le code jusqu'à ce que les steppers atteignent leur position cible. Nous pourrions utiliser la fonction run() à la place, si nous ne voulons pas bloquer le code. Nous devons également noter que la classe MultiStepper ne prend pas en charge l'accélération et la décélération. 

Néanmoins, si vous souhaitez en savoir plus, à partir d'exemples plus avancés, vous pouvez consulter mes projets Arduino que j'ai déjà mentionnés, tous les détails et leurs codes sont sur le site.

Bouclier CNC pour contrôler plusieurs moteurs pas à pas pour tout projet Arduino

Toujours en ce qui concerne le contrôle de plusieurs moteurs pas à pas, il convient de mentionner et de jeter un œil au bouclier CNC Arduino.

L'objectif principal du bouclier CNC Arduino est de contrôler des machines CNC à 2 ou 3 axes, mais c'est en fait une excellente option pour contrôler tout type de projet où nous devons contrôler plusieurs moteurs pas à pas car il est compact et fournit des connexions faciles pour les pilotes et les moteurs. 

Ce bouclier se place au-dessus d'une carte Arduino UNO et peut contrôler jusqu'à 4 moteurs pas à pas individuels et disposer de toutes les broches Arduino restantes disponibles pour utilisation. J'ai utilisé cette combinaison d'une carte Arduino UNO et du blindage CNC pour contrôler mon bras robot SCARA à 4 axes.

Je mettrai bientôt à jour cette section de l'article, comment utiliser le bouclier CNC avec Arduino avec plus de détails.

DRV8825 contre A4988

Très bien, passons maintenant à autre chose et voyons comment contrôler les moteurs pas à pas en utilisant l'autre pilote que j'ai mentionné au début, le DRV8825.

En fait, tout ce que nous avons expliqué jusqu'à présent sur le contrôle des moteurs pas à pas avec le pilote pas à pas A4988 s'applique également au DRV8825. Le principe de fonctionnement, les connexions et le codage sont quasiment les mêmes pour ces deux pilotes. La différence entre eux réside dans leurs caractéristiques techniques et nous allons maintenant les examiner et les comparer.

Le DRV8825 est un pilote pas à pas de Texas Instruments qui peut être utilisé en remplacement direct du pilote Allegro A4988 car leurs connexions sont les mêmes. Les trois principales différences entre eux sont que le DR8825 peut fournir plus de courant que l'A4988 sans refroidissement supplémentaire (1,5 A contre 1 A), qu'il a une tension d'alimentation maximale plus élevée (45 V contre 35 V) et qu'il offre une résolution de micropas plus élevée (32 contre 16 micropas). 

Bien entendu, ils présentent également d’autres différences mineures. Par exemple, le potentiomètre de limite de courant a un emplacement différent et la relation entre le réglage de la limite de courant et la tension de la broche de référence est différente. Le DRV8825 n'a pas besoin d'alimentation logique et l'emplacement de cette broche est utilisé comme sortie FAULT.

Cependant, il est sûr de connecter la broche FAULT directement au 5 V, de sorte que le DRV8825 peut être utilisé en remplacement direct dans les systèmes conçus pour le pilote A4988. 

Il convient cependant de noter que lors du remplacement d'un pilote A4988 par un DRV8825, il est très important de s'assurer que l'orientation du pilote est correcte. Je l'ai déjà mentionné, leurs potentiomètres sont à des endroits différents, sur l'A4988 c'est en dessous de la puce, et sur le DRV8825 c'est au dessus de la puce, ce qui peut parfois prêter à confusion et le driver peut être facilement placé du mauvais côté. 

Pour régler la limite de courant, nous pouvons mesurer la tension de référence avec une sonde sur GND et l'autre sur le potentiomètre lui-même.

La formule de calcul pour le variateur pas à pas DRV8825 est la suivante :

Limite actuelle =Vref x 2

Quant à la sélection de la résolution des micropas, nous pouvons utiliser le tableau suivant.

Dans l'ensemble, le DRV8825 est un meilleur pilote pas à pas que l'A4988, car il offre des valeurs nominales de courant et de tension plus élevées, ainsi qu'une résolution de micropas plus élevée, ce qui se traduit par un fonctionnement plus fluide et plus silencieux du moteur pas à pas.

Pilote pas à pas TMC2208

En parlant de fonctionnement plus fluide et plus silencieux, jetons un coup d’œil au pilote pas à pas TMC2208. La puce TMC2208 est fabriquée par Trinamic, une société allemande spécialisée dans l'électronique de contrôle de mouvement. Le TMC2208 est un pilote de moteur pas à pas silencieux qui peut également être utilisé en remplacement direct dans les systèmes conçus pour les pilotes A4988 ou DRV8825. Il est largement utilisé dans les imprimantes 3D de bureau, les graveurs laser, les scanners, etc.

Ce qui distingue ce pilote des deux autres, c'est son unité d'interpolation intégrée qui fournit 256 subdivisions ou micropas. Cela permet un contrôle sinusoïdal parfait généré en interne dans la puce. Cela signifie que le pilote enverra 256 micropas au moteur pas à pas, quelle que soit la résolution de micropas que nous avons sélectionnée via les deux broches MS, 2, 4, 8 ou 16 micropas. Cela permet un fonctionnement plus fluide et réduit considérablement la charge du microcontrôleur.

Cette fonctionnalité du pilote, combinée à la technologie de contrôle de courant silencieux StealthChop2, permet un contrôle ultra-silencieux des moteurs pas à pas. Voici une comparaison des niveaux de bruit entre les trois conducteurs.

Niveaux sonores du pilote pas à pas : A4988 autour de 65 dB, DRV8825 autour de 67 dB et TMC2208 autour de 41 dB.

Le TMC2208 pilote les moteurs pas à pas de manière totalement silencieuse, ce qui est vraiment impressionnant.

L'intensité nominale du TMC2208 est légèrement supérieure à celle du pilote A4988, soit 1,2 A avec un courant de crête de 2 A. Pour définir la limite actuelle du pilote, nous pouvons encore une fois utiliser la même méthode que celle expliquée pour les autres pilotes. Nous devons mesurer la tension de référence avec une sonde sur GND et l'autre juste à côté de la broche Enable.

La formule de calcul de la limite actuelle est la suivante :

Limite actuelle =Vref x 0,71

Bien qu'il puisse être utilisé en remplacement direct, le pilote TMC2208 a un brochage légèrement différent de celui du pilote A4988. Ici, nous n'avons que deux broches pour sélectionner la résolution des micropas et pour activer le pilote, nous devons connecter la broche d'activation à GND.

En termes de codage, c’est la même chose que les deux autres pilotes. 

Le pilote TMC2208 possède également d'autres fonctionnalités plus avancées par rapport aux deux autres pilotes, comme par exemple une interface UART simple à utiliser qui permet de contrôler le pilote avec une seule ligne, au lieu des deux broches Step et Dir. En plus de cela, je propose plus d’options de réglage et de contrôle. 

Dans l’ensemble, le TMC2208 est un meilleur pilote que l’A4988 et le DRV8825, mais c’est normal car son prix est plus élevé. Cependant, si vous n'avez pas besoin de ces fonctionnalités supplémentaires et que les niveaux de bruit ne vous préoccupent pas, les deux autres pilotes sont tout simplement un excellent choix.

Conclusion

Nous avons donc couvert à peu près tout ce que nous devons savoir sur le contrôle des moteurs pas à pas avec Arduino. Le NEMA17 et les trois pilotes, l'A4988, le DRV8825 et le TMC2208, sont tout simplement incroyablement polyvalents et peuvent être utilisés dans de nombreuses applications où le contrôle de position est nécessaire. Vous pouvez toujours en apprendre davantage en explorant certains de mes projets Arduino.

Si vous souhaitez apprendre à contrôler des moteurs pas à pas plus gros comme NEMA23 ou NEMA34, j'aurai également un tutoriel dédié à cela. 

J'espère que vous avez apprécié ce tutoriel et appris quelque chose de nouveau. N'oubliez pas de vous abonner et n'hésitez pas à poser vos questions dans la section commentaires ci-dessous.