Dans ce tutoriel, vous apprendrez à contrôler un moteur pas à pas avec le driver micro-pas TB6560 et Arduino. Ce driver est facile à utiliser et peut piloter de gros moteurs pas à pas comme un 3 A NEMA 23.
J’ai inclus un schéma de câblage et 2 exemples de code. Dans le premier exemple, je vous montrerai comment utiliser ce driver de moteur pas à pas sans bibliothèque Arduino. Dans le second exemple, nous verrons la bibliothèque AccelStepper. Cette bibliothèque est assez simple à utiliser et permet d’ajouter accélération et décélération au mouvement du moteur pas à pas.
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.
Fournitures
Composants matériels
| TB6560 stepper motor driver | × 1 | Amazon | |
 | NEMA 23 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (24 V) | × 1 | Amazon | |
| Jumper wires | × 4 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Outils
| Wire stripper | Amazon | ||
| Small screwdriver | Amazon | ||
| Self-adjusting crimping pliers (recommandé)* | Amazon | ||
| Wire ferrules assortment (recommandé)* | Amazon |
*Hackaday a écrit un excellent article sur les avantages d’utiliser des embouts de câble (également appelés manchons de terminaison).
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
Le TB6560 driver micro-pas est basé sur la puce Toshiba TB6560AHQ et peut être utilisé pour piloter des moteurs pas à pas bipolaires à deux phases.
Avec un courant maximal continu de 3 A, le driver TB6560 peut contrôler des moteurs pas à pas assez puissants comme un NEMA 23. Assurez-vous de ne pas connecter de moteurs pas à pas dont le courant nominal dépasse 3 A au driver.
La puce intègre plusieurs fonctions de sécurité telles que la protection contre les surintensités, la coupure en cas de sous-tension et la protection contre la surchauffe. Cependant, elle ne dispose pas de protection contre l’inversion de polarité, veillez donc à bien connecter l’alimentation. Vous trouverez plus de spécifications dans le tableau ci-dessous.
Spécifications du TB6560
| Tension de fonctionnement | 10 – 35 VDC, 24 VDC recommandé |
| Courant de sortie max | 3 A par phase, 3,5 A en pointe |
| Résolution micro-pas | complet, 1/2, 1/8 et 1/16 |
| Protection | Coupure basse tension, protection contre la surchauffe et les surintensités |
| Dimensions | 75 x 50 x 35 mm |
| Espacement des trous | 69 x 43 mm, ⌀ 3,5 mm |
| Coût | Check price |
Pour plus d’informations, vous pouvez consulter la fiche technique / manuel ci-dessous :
Notez que le TB6560 est un driver analogique. Ces dernières années, des drivers numériques comme le DM556 ou DM542 sont devenus beaucoup plus abordables. Les drivers numériques offrent généralement de meilleures performances et un fonctionnement plus silencieux. Ils peuvent être câblés et contrôlés de la même manière que le TB6560, ce qui vous permet de mettre à niveau facilement votre système plus tard.
J’ai utilisé les drivers DM556 pour ma fraiseuse CNC DIY et ils fonctionnent parfaitement depuis plusieurs années.
TB6560 vs TB6600
En cherchant un driver TB6560, vous tomberez probablement aussi sur le driver TB6600 un peu plus cher. Ce driver peut être contrôlé avec le même code et câblage, mais il présente quelques différences clés.
| TB6560 | TB6600 | |
|---|---|---|
| Tension de fonctionnement | 10 – 35 VDC, 24 VDC recommandé | 9 – 42 VDC, 36 VDC recommandé |
| Courant de sortie max | 3 A par phase, 3,5 A en pointe | 3,5 A par phase, 4 A en pointe |
| # Réglages de courant | 14 | 8 |
| Résolution micro-pas | complet, 1/2, 1/8 et 1/16 | complet, 1/2, 1/4, 1/8, 1/16 et 1/32 |
| Fréquence d’horloge | 15 kHz | 200 kHz |
| Coût | Check price | Check price |
Les principales différences sont donc la tension maximale plus élevée, le courant maximal plus important et une résolution micro-pas allant jusqu’à 1/32. Si vous souhaitez piloter des moteurs plus gros ou avez besoin d’une résolution plus fine, je recommande le TB6600.
Câblage – Connexion du TB6560 au moteur pas à pas et à l’Arduino
Le schéma de câblage ci-dessous montre comment connecter le driver TB6560 à l’Arduino et à un moteur pas à pas.
Dans ce tutoriel, nous connecterons le driver en configuration cathode commune. Cela signifie que nous relions toutes les parties négatives des signaux de commande ensemble à la masse.
Les connexions sont également indiquées dans le tableau ci-dessous :
Connexions TB6560
| TB6560 | Connexion |
|---|---|
| VCC | 10 – 35 VDC |
| GND | Masse alimentation |
| EN- | Non connecté |
| EN+ | Non connecté |
| CW- | Masse Arduino |
| CW+ | Broche 2 Arduino |
| CLK- | Masse Arduino |
| CLK+ | Broche 3 Arduino |
| A-, A+ | Bobine 1 moteur pas à pas |
| B-, B+ | Bobine 2 moteur pas à pas |
Notez que les broches d’activation (EN- et EN+) sont laissées déconnectées. Cela signifie que la broche d’activation est toujours à LOW et que le driver est toujours activé.
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 quel fil correspond à quoi. J’utilise l’astuce suivante pour identifier les moteurs bipolaires à 4 fils :
Il suffit d’identifier les deux paires de fils reliées aux deux bobines du moteur. Les fils d’une bobine se connectent à A- et A+, l’autre paire à B- et B+, la polarité n’a pas d’importance.
Pour trouver les deux fils d’une même bobine, procédez ainsi moteur déconnecté :
- Essayez de faire tourner l’axe du moteur à la main et notez la résistance au mouvement.
- Prenez une paire de fils au hasard et touchez leurs extrémités dénudées ensemble.
- Ensuite, en maintenant les fils en contact, essayez de faire tourner l’axe du moteur à nouveau.
Si vous ressentez une forte résistance, vous avez trouvé une paire de fils reliée à la même bobine. L’autre paire correspond à la seconde bobine.
Si l’axe 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.
Si ce n’est toujours pas clair, laissez un commentaire ci-dessous, plus d’informations sont aussi disponibles sur le RepRap.org wiki.
Réglages micro-pas TB6560
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 le TB6560 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 demi-pas, un moteur de 200 pas par révolution aura 400 micro-pas par révolution.
Vous pouvez modifier le réglage micro-pas du TB6560 en activant ou désactivant les interrupteurs DIP sur le driver. Voir le tableau ci-dessous pour les détails. Assurez-vous que le driver n’est pas alimenté lors du réglage des DIP !
Tableau micro-pas
| S3 | S4 | Résolution micro-pas |
|---|---|---|
| OFF | OFF | Pas complet |
| ON | OFF | Demi-pas |
| ON | ON | 1/8 de pas |
| OFF | ON | 1/16 de pas |
En général, un réglage micro-pas plus petit donne un fonctionnement plus fluide et silencieux. Cependant, cela limite la vitesse maximale que vous pouvez atteindre en contrôlant le driver avec un Arduino.
Réglages de courant TB6560
Vous pouvez ajuster le courant envoyé au moteur en fonctionnement en configurant les interrupteurs DIP SW1, SW2, SW3 et S1. Je recommande de commencer avec un courant de 1 A. Si votre moteur saute des pas ou cale, vous pouvez augmenter le courant plus tard.
Tableau des courants
| (A) | SW1 | SW2 | SW3 | S1 |
|---|---|---|---|---|
| 0,3 | OFF | OFF | ON | ON |
| 0,5 | OFF | OFF | ON | OFF |
| 0,8 | OFF | ON | OFF | ON |
| 1 | OFF | ON | OFF | OFF |
| 1,1 | OFF | ON | ON | ON |
| 1,2 | ON | OFF | OFF | ON |
| 1,4 | OFF | ON | ON | OFF |
| 1,5 | ON | OFF | ON | ON |
| 1,6 | ON | OFF | OFF | OFF |
| 1,9 | ON | ON | OFF | ON |
| 2 | ON | OFF | ON | OFF |
| 2,2 | ON | ON | ON | ON |
| 2,6 | ON | ON | OFF | OFF |
| 39 | ON | ON | ON | OFF |
Le courant d’arrêt est le courant utilisé pour maintenir l’axe du moteur en position arrêtée. Il est conseillé de le régler aussi bas que possible pour minimiser le chauffage inutile du moteur. Augmentez cette valeur si votre moteur ne peut pas maintenir sa position.
Tableau du courant d’arrêt
| Courant d’arrêt | S2 |
|---|---|
| 20 % | ON |
| 50 % | OFF |
Le réglage de la décroissance concerne la manière dont la puce driver gère la force contre-électromotrice (back EMF) du moteur. La fiche technique Toshiba du TB6560 fournit des explications et des schémas à ce sujet. En général, je laisse ce réglage à 0 %. Vous pouvez expérimenter pour trouver ce qui fonctionne le mieux avec votre montage.
À titre de référence, le driver TB6600 a un réglage de décroissance fixe à 40 %.
Tableau des réglages de décroissance
| S5 | S6 | |
|---|---|---|
| 0 % Normal | OFF | OFF |
| 25 % | ON | OFF |
| 50 % | OFF | ON |
| 100 % Mode rapide | ON | ON |
Dans le reste de ce tutoriel, j’utiliserai le driver en mode micro-pas 1/8 avec un courant de fonctionnement de 1 A, un courant d’arrêt de 20 % et un réglage de décroissance à 0 %.
Exemple de code Arduino pour TB6560
Maintenant que vous avez câblé le driver et réglé les interrupteurs DIP, il est temps de connecter l’Arduino à l’ordinateur et de téléverser du code. Vous pouvez téléverser le code exemple suivant sur votre Arduino en utilisant le Arduino IDE. 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 TB6560 stepper motor driver and Arduino without a library.Homepage*/ // Define stepper motor connections and steps per revolution: #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 1600 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 (CLK-) et direction (CW-). Je les ai connectées aux broches 3 et 2 de l’Arduino.
L’instruction #define sert à nommer une constante. Le compilateur remplacera toutes les références à cette constante par la valeur définie lors de la compilation. Ainsi, partout où vous mentionnez 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 micro-pas 1/8, je l’ai mise à 1600 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 1600
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 CW, puis rapidement d’un tour dans le sens CCW. Ensuite, le moteur tourne 5 tours dans chaque sens à 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 (direction) à HIGH ou LOW. Pour cela, on utilise la fonction digitalWrite(). Selon le câblage du moteur, mettre la broche DIR à HIGH fera tourner le moteur dans le sens CW ou CCW.
Contrôle du nombre de pas ou tours :
Dans ce sketch, les for loops contrôlent le nombre de pas que le moteur effectuera. Le code dans la boucle for correspond à 1 (micro)pas du moteur. Comme la boucle s’exécute 1600 fois (stepsPerRevolution), cela fait 1 tour. Dans les deux dernières boucles, la boucle for s’exécute 8000 fois, soit 8000 (micro)pas ou 5 tours.
Notez que vous pouvez changer le second terme de la boucle for pour le nombre de pas souhaité. for(int i = 0; i < 800; i++) donnerait 800 pas ou un demi-tour.
Contrôle de la vitesse :
La vitesse du moteur 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 cette fréquence en modifiant delayMicroseconds() dans le code. Plus le délai est court, plus la fréquence est élevée, plus le moteur tourne vite.
Installation de la bibliothèque AccelStepper
La bibliothèque AccelStepper écrite par Mike McCauley est une excellente bibliothèque pour vos projets. Elle supporte l’accélération et la décélération, mais offre aussi beaucoup d’autres fonctions utiles.
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 d’aller dans Tools > Manage Libraries… ou d’appuyer sur Ctrl + Shift + I sous Windows. Le gestionnaire de bibliothèques s’ouvre et met à jour la liste des bibliothèques installées.
Vous pouvez chercher ‘accelstepper’ et sélectionner la bibliothèque de Mike McCauley. Choisissez la dernière version puis cliquez sur Installer.
Exemple de code AccelStepper
Avec le sketch suivant, vous pouvez ajouter accélération et décélération aux mouvements du moteur pas à pas, sans codage compliqué. Dans cet exemple, le moteur tourne d’avant en arrière à 1000 pas par seconde avec une accélération de 500 pas par seconde².
Notez que j’utilise toujours le driver en mode micro-pas 1/8. Si vous utilisez un autre réglage, ajustez la vitesse et l’accélération en conséquence.
/* Example sketch to control a stepper motor with TB6560 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(1000); stepper.setAcceleration(500); } void loop() { // Set the target position: stepper.moveTo(8000); // 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 :
La première étape est d’inclure la bibliothèque avec #include <AccelStepper.h>.
// Include the AccelStepper library: #include "AccelStepper.h"
Ensuite, il faut définir les connexions TB6560-Arduino et le type d’interface moteur. Le moteur interface type doit être réglé à 1 pour un driver step and direction.
// 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
Puis, créez une instance de la classe AccelStepper avec le type d’interface moteur et les connexions appropriées.
Ici, 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, stepPin, dirPin);. Le nom donné au moteur sera utilisé plus tard pour définir 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 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 setup(), en plus de la vitesse maximale, il faut définir l’accélération/décélération avec la fonction setMaxSpeed() et setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(1000);
stepper.setAcceleration(500);
}
Dans la boucle loop, on fait tourner le moteur d’un nombre prédéfini de pas. La fonction stepper.moveTo() sert à définir la position cible (en pas). 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 bloque, ne l’utilisez pas si vous devez contrôler d’autres choses en même temps.
// Set the target position: stepper.moveTo(8000); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Si vous souhaitez voir plus d’exemples pour la bibliothèque AccelStepper, consultez mon tutoriel sur le driver A4988 :
Conclusion
Dans cet article, je vous ai montré comment contrôler un moteur pas à pas avec le driver TB6560 et Arduino. J’espère que vous l’avez trouvé utile et instructif.
Si vous souhaitez en savoir plus sur d’autres drivers de moteurs pas à pas, les articles ci-dessous pourraient vous intéresser :
- TB6600 Stepper Motor Driver with Arduino Tutorial
- 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
Notez que les commentaires sont modérés pour éviter le spam.
