In questo tutorial imparerai come controllare un motore passo-passo con il driver microstepping TB6600 e Arduino. Questo driver è facile da usare e può controllare motori passo-passo di grandi dimensioni come un 3 A NEMA 23.
Ho incluso uno schema di collegamento e 3 esempi di codice. Nel primo esempio, ti mostrerò come utilizzare questo driver per motori passo-passo senza una libreria Arduino.
Questo esempio può essere usato per far girare il motore in modo continuo. Nel secondo esempio, vedremo come controllare la velocità, il numero di giri e la direzione di rotazione del motore passo-passo.
Infine, daremo un’occhiata alla AccelStepper libreria. Questa libreria è abbastanza semplice da usare e permette di aggiungere accelerazione e decelerazione al movimento del motore passo-passo.
Dopo ogni esempio, spiego nel dettaglio come funziona il codice, così non avrai problemi a modificarlo secondo le tue esigenze.
Materiali
Componenti hardware
| TB6600 stepper motor driver | × 1 | Amazon | |
 | NEMA 23 stepper motor | × 1 | Amazon |
 | Arduino Uno Rev3 | × 1 | Amazon |
| Power supply (24/36 V) | × 1 | Amazon | |
| Jumper wires | × 4 | Amazon | |
| USB cable type A/B | × 1 | Amazon |
Strumenti
| Wire stripper | Amazon | ||
| Small screwdriver | Amazon | ||
| Self-adjusting crimping pliers (consigliato)* | Amazon | ||
| Wire ferrules assortment (consigliato)* | Amazon |
*Hackaday ha scritto un ottimo articolo sui vantaggi dell’uso delle guaine terminali (note anche come manicotti di fine filo).
Software
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.
Informazioni sul driver
Il TB6600 driver microstepping è basato sul circuito integrato Toshiba TB6600HG e può essere usato per pilotare motori passo-passo bipolari a due fasi.
Con una corrente massima continua di 3,5 A, il driver TB6600 può controllare motori passo-passo abbastanza grandi come un NEMA 23. Assicurati di non collegare motori con una corrente nominale superiore a 3,5 A al driver.
Il driver include diverse funzioni di sicurezza come protezione da sovracorrente, spegnimento per sottotensione e protezione da surriscaldamento.
Puoi trovare ulteriori specifiche nella tabella sottostante. Nota che le specifiche esatte e le dimensioni possono variare leggermente tra i produttori. Controlla sempre il datasheet del tuo driver prima di collegare l’alimentazione.
Specifiche TB6600
| Tensione di funzionamento | 9 – 42 V |
| Corrente massima in uscita | 4,5 A per fase, 5,0 A di picco1 |
| Risoluzione microstep | intero, 1/2, 1/4, 1/8 e 1/162 |
| Protezione | Spegnimento per bassa tensione, protezione da surriscaldamento e sovracorrente |
| Dimensioni | 96 x 72 x 28/36 mm |
| Distanza tra fori | 88, ⌀ 5 mm |
| Costo | Check price |
1 Queste sono le specifiche per il circuito integrato TB6600HG; il driver ha una corrente massima nominale di 3,5 A e 4,0 A di picco.
2 Vedi il commento sui driver TB6600 falsi/aggiornati più avanti.
Per maggiori informazioni, puoi consultare il datasheet e il manuale qui sotto:
Driver TB6600 falsi o ‘aggiornati’
Recentemente ho smontato uno dei driver TB6600 che avevo ordinato e ho scoperto che non usava effettivamente un chip TB6600HG. Invece, montava un chip molto più piccolo TB67S109AFTG, sempre prodotto da Toshiba. Le prestazioni e le specifiche di questi chip sono simili, ma il TB6600HG ha una corrente di picco più alta (fino a 5 A) ed è un chip molto più grande con un dissipatore migliore.
C’è un modo molto semplice per verificare se il tuo driver usa un chip TB6600HG o TB67S109AFTG, il TB6600HG supporta solo fino a 1/16 microstepping (vedi datasheet), mentre il TB67S109AFTG arriva fino a 1/32. La ragione principale per cui i produttori sono passati a questo altro chip è probabilmente il prezzo. Qui sotto trovi link ai chip su LCSC.com che mostrano che il TB67S109AFTG costa circa 1,50 $ in meno.
TB6600HG: https://lcsc.com/product-detail/Motor-Drivers_TOSHIBA_TB6600HG_TB6600HG_C66042.html
TB67S109AFTG: https://lcsc.com/product-detail/Motor-Drivers_TOSHIBA_TB67S109AFTG_TB67S109AFTG_C92125.html
Puoi acquistare driver TB6600 originali su Amazon, come questo 4-axis driver board ma la maggior parte usa il chip TB67S109AFTG. Puoi riconoscere il TB6600HG dalle uscite dei pin sulla PCB e dal fatto che supporta solo fino a 1/16 microstepping.
Jim da embeddedtronicsblog ha fatto dei test sui driver TB67S109AFTG e ha scoperto che i motori passo-passo giravano meglio rispetto ai driver TB6600. Quindi, conviene scegliere un TB6600 originale o l’‘upgrade’? Direi che dipende se ti serve davvero l’alta corrente o preferisci il microstepping fino a 1/32.
Puoi trovare il datasheet del TB67S109AFTG qui sotto.
Alternative
Nota che il TB6600 è un driver analogico. Negli ultimi anni, driver digitali come il DM556 o il DM542 sono diventati molto più accessibili. I driver digitali offrono generalmente prestazioni migliori e funzionamento più silenzioso. Possono essere cablati e controllati allo stesso modo del TB6600, quindi puoi facilmente aggiornare il tuo sistema in seguito.
Ho usato i driver DM556 per il mio router CNC fai-da-te e hanno funzionato benissimo per diversi anni.
TB6600 vs TB6560
Quando cerchi un driver per motori passo-passo TB6600, probabilmente incontrerai anche il driver leggermente più economico TB6560 TB6560. Questo driver può essere controllato con lo stesso codice e cablaggio, ma ci sono alcune differenze chiave.
| TB6560 | TB6600 | |
|---|---|---|
| Tensione di funzionamento | 10 – 35 VDC, 24 VDC consigliati | 9 – 42 VDC, 36 VDC consigliati |
| Corrente massima in uscita | 3 A per fase, 3,5 A di picco | 3,5 A per fase, 4 A di picco |
| # Impostazioni di corrente | 14 | 8 |
| Risoluzione microstep | intero, 1/2, 1/8 e 1/16 | intero, 1/2, 1/4, 1/8, 1/16 e 1/32* |
| Frequenza di clock | 15 kHz | 200 kHz |
| Costo | Check price | Check price |
*Driver che usano il chip TB67S109AFTG.
Quindi le principali differenze sono la tensione massima più alta, la corrente massima più elevata e il microstepping fino a 1/32. Il TB6600 ha anche un dissipatore migliore e un design complessivo più curato. Se vuoi controllare motori passo-passo più grandi o hai bisogno di una risoluzione più alta, ti consiglio il TB6600.
Cablaggio – Collegare TB6600 a motore passo-passo e Arduino
Collegare il driver TB6600 a un Arduino e a un motore passo-passo è abbastanza semplice. Lo schema di collegamento qui sotto mostra quali connessioni effettuare.
In questo tutorial collegheremo il driver in configurazione catodo comune. Questo significa che colleghiamo tutti i lati negativi dei segnali di controllo a massa.
Le connessioni sono anche riportate nella tabella sottostante:
Connessioni TB6600
| TB6600 | Connessione |
|---|---|
| VCC | 9 – 42 VDC |
| GND | Massa alimentazione |
| ENA- | Non collegato |
| ENA+ | Non collegato |
| DIR- | Massa Arduino |
| DIR+ | Pin 2 Arduino |
| PUL- | Massa Arduino |
| PUL+ | Pin 3 Arduino |
| A-, A+ | Bobina 1 motore passo-passo |
| B-, B+ | Bobina 2 motore passo-passo |
Nota che abbiamo lasciato scollegati i pin di abilitazione (ENA- e ENA+). Questo significa che il pin di abilitazione è sempre LOW e il driver è sempre abilitato.
Come determinare il cablaggio corretto del motore passo-passo?
Se non trovi il datasheet del tuo motore passo-passo, può essere difficile capire quale filo va dove. Io uso questo trucco per identificare come collegare motori bipolari a 4 fili:
L’unica cosa da identificare sono le due coppie di fili collegati alle due bobine del motore. I fili di una bobina si collegano a A- e A+, quelli dell’altra a B- e B+, la polarità non conta.
Per trovare i due fili di una bobina, fai così con il motore scollegato:
- Prova a girare l’albero del motore passo-passo a mano e nota quanto è difficile ruotarlo.
- Ora prendi una coppia casuale di fili del motore e tocca le estremità scoperte insieme.
- Poi, tenendo le estremità unite, prova a girare di nuovo l’albero del motore.
Se senti molta resistenza, hai trovato una coppia di fili della stessa bobina. Se l’albero gira ancora liberamente, prova un’altra coppia. Ora collega le due bobine ai pin indicati nello schema di collegamento sopra.
Se non è ancora chiaro, lascia un commento qui sotto, puoi trovare più informazioni anche su RepRap.org wiki
Impostazioni microstep TB6600
I motori passo-passo hanno tipicamente un passo di 1,8° o 200 passi per giro, riferito ai passi interi. Un driver microstepping come il TB6600 permette risoluzioni più alte con posizioni intermedie del passo, ottenute alimentando le bobine con livelli di corrente intermedi.
Ad esempio, pilotare un motore in modalità 1/2 passo darà a un motore da 200 passi per giro 400 microstep per giro.
Puoi cambiare le impostazioni microstep del TB6600 agendo sugli interruttori dip switch sul driver. Vedi la tabella sotto per i dettagli. Assicurati che il driver non sia alimentato quando regoli i dip switch!
Nota bene che queste impostazioni sono per i driver 1/32 microstepping con chip TB67S109AFTG. Quasi tutti i driver TB6600 in commercio oggi usano questo chip. Di solito trovi anche una tabella con le impostazioni di microstep e corrente sul corpo del driver.
Tabella microstep
| S1 | S2 | S3 | Risoluzione microstep |
|---|---|---|---|
| ON | ON | ON | NC |
| ON | ON | OFF | Passo intero |
| ON | OFF | ON | 1/2 passo |
| OFF | ON | ON | 1/2 passo |
| ON | OFF | OFF | 1/4 passo |
| OFF | ON | OFF | 1/8 passo |
| OFF | OFF | ON | 1/16 passo |
| OFF | OFF | OFF | 1/32 passo |
In generale, un’impostazione di microstep più piccola porta a un funzionamento più fluido e silenzioso. Tuttavia limita la velocità massima raggiungibile controllando il driver con Arduino.
Impostazioni di corrente TB6600
Puoi regolare la corrente fornita al motore durante il funzionamento impostando i dip switch S4, S5 e S6 su ON o OFF. Consiglio di iniziare con un livello di corrente di 1 A. Se il motore perde passi o si blocca, puoi sempre aumentare la corrente in seguito.
Tabella corrente
| Corrente (A) | Corrente di picco | S4 | S5 | S6 |
|---|---|---|---|---|
| 0,5 | 0,7 | ON | ON | ON |
| 1,0 | 1,2 | ON | OFF | ON |
| 1,5 | 1,7 | ON | ON | OFF |
| 2,0 | 2,2 | ON | OFF | OFF |
| 2,5 | 2,7 | OFF | ON | ON |
| 2,8 | 2,9 | OFF | OFF | ON |
| 3,0 | 3,2 | OFF | ON | OFF |
| 3,5 | 4,0 | OFF | OFF | OFF |
Esempio base di codice TB6600 con Arduino
Con lo sketch seguente puoi testare la funzionalità del driver per motori passo-passo. Fa semplicemente ruotare il motore a velocità fissa.
Puoi caricare il codice sul tuo Arduino usando l’IDE Arduino. Per questo esempio specifico non è necessario installare librerie.
Nel prossimo esempio vedremo come controllare velocità, numero di giri e direzione di rotazione del motore passo-passo.
Puoi copiare il codice cliccando sul pulsante in alto a destra nel campo del codice.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver
and Arduino without a library: continuous rotation.
More info: https://www.makerguides.com */
// Define stepper motor connections:
#define dirPin 2
#define stepPin 3
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
// Set the spinning direction CW/CCW:
digitalWrite(dirPin, HIGH);
}
void loop() {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
Come vedi, il codice è molto breve e semplice. Non serve molto per far girare un motore passo-passo!
Spiegazione del codice
Lo sketch inizia definendo i pin step (PUL+) e direzione (DIR+). Li ho collegati ai pin 3 e 2 di Arduino.
L’istruzione #define serve a dare un nome a un valore costante. Il compilatore sostituirà ogni riferimento a questa costante con il valore definito durante la compilazione. Quindi ovunque menzioni dirPin, il compilatore lo sostituirà con il valore 2 quando il programma viene compilato.
// Define stepper motor connections: #define dirPin 2 #define stepPin 3
Nella setup() sezione del codice, tutti i pin di controllo del motore sono dichiarati come OUTPUT digitali con la funzione pinMode(pin, mode). Ho anche impostato la direzione di rotazione del motore passo-passo mettendo il pin di direzione HIGH. Per questo usiamo la funzione digitalWrite(pin, value).
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
// Set the spinning direction CW/CCW:
digitalWrite(dirPin, HIGH);
}
Nella loop() sezione del codice, facciamo eseguire al driver un passo inviando un impulso al pin step. Poiché il codice nella sezione loop viene ripetuto continuamente, il motore passo-passo inizierà a ruotare a velocità fissa.
void loop() {
// These four lines result in 1 step:
digitalWrite(stepPin, HIGH);
delayMicroseconds(500);
digitalWrite(stepPin, LOW);
delayMicroseconds(500);
}
Nel prossimo esempio vedrai come cambiare la velocità del motore.
2. Esempio di codice per controllare rotazione, velocità e direzione
Lo sketch seguente controlla velocità, numero di giri e direzione di rotazione del motore passo-passo.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver
and Arduino without a library: number of revolutions, speed and direction.
More info: https://www.makerguides.com */
// 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);
}
Come funziona il codice
Oltre a impostare i collegamenti del motore passo-passo, ho definito anche una costante stepsPerRevolution . Poiché ho impostato il driver in modalità 1/8 microstepping, l’ho settata a 1600 passi per giro (per un motore standard da 200 passi per giro). Cambia questo valore se il tuo setup è diverso.
// Define stepper motor connections and steps per revolution: #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 1600
La setup() sezione è uguale a prima, solo che non definiamo ancora la direzione di rotazione.
Nella loop() sezione del codice, facciamo ruotare il motore di un giro lentamente in senso orario (CW) e un giro velocemente in senso antiorario (CCW). Poi facciamo ruotare il motore per 5 giri in ogni direzione ad alta velocità. Come si controllano velocità, direzione e numero di giri?
// 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);
}
Controllo della direzione di rotazione
Per controllare la direzione di rotazione del motore passo-passo impostiamo il pin DIR (direzione) su HIGH o LOW. Per questo usiamo la funzione digitalWrite(). A seconda di come hai collegato il motore, impostare il pin DIR su HIGH farà girare il motore in senso orario o antiorario.
Controllo del numero di passi o giri
In questo sketch, la for loops controlla il numero di passi che il motore farà. Il codice dentro il for loop corrisponde a 1 (micro)passo del motore. Poiché il loop viene eseguito 1600 volte (stepsPerRevolution), questo corrisponde a 1 giro. Negli ultimi due loop, il codice dentro il for viene eseguito 8000 volte, cioè 8000 (micro)passi o 5 giri.
Nota che puoi cambiare il secondo termine nel for loop con qualsiasi numero di passi desideri. for(int i=0; i<800; i++) equivarrebbe a 800 passi o mezzo giro.
Controllo della velocità
La velocità del motore passo-passo è determinata dalla frequenza degli impulsi inviati al pin STEP. Più alta è la frequenza, più veloce gira il motore. Puoi controllare la frequenza degli impulsi cambiando delayMicroseconds() nel codice. Più breve è il delay, più alta è la frequenza e più veloce gira il motore.
Installazione della libreria AccelStepper
La libreria AccelStepper scritta da Mike McCauley è una libreria fantastica per il tuo progetto. Uno dei vantaggi è che supporta accelerazione e decelerazione, ma ha anche molte altre funzioni utili.
Puoi scaricare l’ultima versione di questa libreria qui:
Puoi installare la libreria andando su Sketch > Include Library > Add .ZIP Library… nell’IDE Arduino.
Un’altra opzione è andare su Tools > Manage Libraries… o premere Ctrl + Shift + I su Windows. Si aprirà il Library Manager e aggiornerà la lista delle librerie installate.
Puoi cercare ‘accelstepper’ e trovare la libreria di Mike McCauley. Seleziona l’ultima versione e clicca su Install.
3. Esempio di codice AccelStepper
Con lo sketch seguente puoi aggiungere accelerazione e decelerazione ai movimenti del motore passo-passo, senza codici complicati. Nell’esempio il motore si muoverà avanti e indietro a 1000 passi al secondo con un’accelerazione di 500 passi al secondo quadrato.
Nota che sto ancora usando il driver in modalità 1/8 microstepping. Se usi un’impostazione diversa, prova a modificare velocità e accelerazione.
/* Example sketch to control a stepper motor with TB6600 stepper motor driver,
AccelStepper library and Arduino: acceleration and deceleration.
More info: https://www.makerguides.com */
// 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);
}
Spiegazione del codice
Il primo passo è includere la libreria con #include <AccelStepper.h>.
// Include the AccelStepper library: #include "AccelStepper.h"
Il passo successivo è definire i collegamenti TB6600-Arduino e il tipo di interfaccia motore. Il tipo di interfaccia deve essere impostato a 1 quando si usa un driver step e direction. Puoi trovare gli altri tipi di interfaccia here.
// 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
Poi devi creare una nuova istanza della classe AccelStepper con il tipo di interfaccia motore e i collegamenti appropriati.
In questo caso ho chiamato il motore passo-passo ‘stepper’, ma puoi usare altri nomi come ‘z_motor’ o ‘liftmotor’ ecc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. Il nome che dai al motore sarà usato per impostare velocità, posizione e accelerazione di quel motore. Puoi creare più istanze della classe AccelStepper con nomi e pin diversi. Questo ti permette di controllare facilmente 2 o più motori passo-passo contemporaneamente.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
Nel setup(), oltre alla velocità massima, dobbiamo definire accelerazione e decelerazione. Per questo usiamo la funzione setMaxSpeed() e setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(1000);
stepper.setAcceleration(500);
}
Nella sezione loop del codice, facciamo ruotare il motore di un numero predefinito di passi. La funzione stepper.moveTo() serve per impostare la posizione target (in passi). La funzione stepper.runToPostion() muove il motore (con accelerazione/decelerazione) verso la posizione target e blocca l’esecuzione finché non arriva. Poiché questa funzione è bloccante, non usarla se devi controllare altre cose contemporaneamente.
// Set the target position: stepper.moveTo(8000); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Se vuoi vedere altri esempi per la libreria AccelStepper, dai un’occhiata al mio tutorial su How to control a stepper motor with A4988 driver and Arduino.
Conclusione
In questo articolo ti ho mostrato come controllare un motore passo-passo con il driver TB6600 e Arduino. Spero ti sia stato utile e interessante.
Se vuoi imparare di più su altri driver per motori passo-passo, gli articoli qui sotto potrebbero esserti utili:
- TB6560 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
- Control a Stepper Motor with an IR Remote
Abbiamo anche un articolo su How To Use the TB6600 Stepper Motor Driver with ESP32 se vuoi lavorare con un microcontrollore ESP32 invece.
Se hai domande, lascia un commento qui sotto.
