In questo tutorial imparerai come controllare un motore passo-passo con il driver microstepping TB6560 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 2 codici di esempio. Nel primo esempio ti mostrerò come usare questo driver per motori passo-passo senza una libreria Arduino. Nel secondo esempio esamineremo la libreria AccelStepper. Questa libreria è abbastanza semplice da usare e permette di aggiungere accelerazione e decelerazione al movimento del motore passo-passo.
Dopo ogni esempio, spiego come funziona il codice, così non avrai problemi a modificarlo secondo le tue esigenze.
Materiale necessario
Componenti hardware
| 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 |
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 TB6560 driver microstepping è basato sul chip Toshiba TB6560AHQ e può essere usato per pilotare motori passo-passo bipolari a due fasi.
Con una corrente massima continua di 3 A, il driver TB6560 può controllare motori passo-passo abbastanza grandi come un NEMA 23. Assicurati di non collegare motori con una corrente nominale superiore a 3 A al driver.
Il chip ha diverse funzioni di sicurezza integrate come protezione da sovracorrente, spegnimento per sottotensione e protezione da surriscaldamento. Tuttavia, non ha protezione da inversione di polarità, quindi assicurati di collegare correttamente l’alimentazione. Puoi trovare altre specifiche nella tabella sottostante.
Specifiche TB6560
| Tensione di funzionamento | 10 – 35 VDC, 24 VDC consigliati |
| Corrente massima in uscita | 3 A per fase, 3,5 A di picco |
| Risoluzione microstep | intero, 1/2, 1/8 e 1/16 |
| Protezione | Spegnimento per bassa tensione, protezione da surriscaldamento e sovracorrente |
| Dimensioni | 75 x 50 x 35 mm |
| Distanza tra i fori | 69 x 43 mm, ⌀ 3,5 mm |
| Costo | Check price |
Per maggiori informazioni, puoi consultare il datasheet/manuale qui sotto:
Nota che il TB6560 è un driver analogico. Negli ultimi anni, driver digitali come il DM556 o DM542 sono diventati molto più accessibili. I driver digitali solitamente offrono prestazioni migliori e funzionamento più silenzioso. Possono essere cablati e controllati allo stesso modo del TB6560, 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.
TB6560 vs TB6600
Quando cerchi un driver TB6560 per motori passo-passo, probabilmente incontrerai anche il driver leggermente più costoso TB6600. Questo driver può essere controllato con lo stesso codice/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 |
Quindi le principali differenze sono la tensione massima più alta, la corrente massima più elevata e fino a 1/32 di microstepping. Se vuoi controllare motori passo-passo più grandi o hai bisogno di una risoluzione più alta, ti consiglio di scegliere il TB6600.
Cablaggio – Collegare TB6560 a motore passo-passo e Arduino
Lo schema di collegamento qui sotto mostra come collegare il driver TB6560 all’Arduino e a un motore passo-passo.
In questo tutorial collegheremo il driver in configurazione catodo comune. Questo significa che colleghiamo tutti i lati negativi dei segnali di controllo insieme a massa.
I collegamenti sono anche indicati nella tabella sottostante:
Collegamenti TB6560
| TB6560 | Collegamento |
|---|---|
| VCC | 10 – 35 VDC |
| GND | Massa alimentazione |
| EN- | Non collegato |
| EN+ | Non collegato |
| CW- | Massa Arduino |
| CW+ | Pin 2 Arduino |
| CLK- | Massa Arduino |
| CLK+ | 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 (EN- e EN+). 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 passo-passo bipolari a 4 fili:
L’unica cosa da identificare sono le due coppie di fili collegate alle due bobine del motore. I fili di una bobina si collegano a A- e A+, l’altra coppia a B- e B+, la polarità non importa.
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 insieme le estremità scoperte.
- Poi, tenendo insieme le estremità, prova a girare di nuovo l’albero del motore passo-passo.
Se senti molta resistenza, hai trovato una coppia di fili collegata alla stessa bobina. L’altra coppia è collegata alla seconda bobina.
Se riesci ancora a girare liberamente l’albero, prova un’altra coppia di fili. 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 TB6560
I motori passo-passo tipicamente hanno un passo di 1,8° o 200 passi per rivoluzione, riferito ai passi interi. Un driver microstepping come il TB6560 permette risoluzioni più alte consentendo posizioni intermedie del passo. Questo si ottiene 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 rivoluzione 400 microstep per rivoluzione.
Puoi cambiare l’impostazione microstep o la modalità di eccitazione del TB6560 azionando gli interruttori dip sul driver. Vedi la tabella sotto per i dettagli. Assicurati che il driver non sia alimentato quando regoli gli interruttori dip!
Tabella microstep
| S3 | S4 | Risoluzione microstep |
|---|---|---|
| OFF | OFF | Passo intero |
| ON | OFF | 1/2 passo |
| ON | ON | 1/8 passo |
| OFF | ON | 1/16 passo |
In generale, un’impostazione microstep più piccola porta a un funzionamento più fluido e silenzioso. Tuttavia limita la velocità massima che puoi raggiungere controllando il driver con Arduino.
Impostazioni di corrente TB6560
Puoi regolare la corrente che va al motore durante il funzionamento impostando gli interruttori dip SW1, SW2, SW3 e S1 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
| (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 |
La corrente di stop è la corrente usata per mantenere l’albero del motore fermo in posizione. Vuoi impostarla il più bassa possibile per minimizzare il riscaldamento inutile del motore. Aumenta questo valore se il motore non riesce a mantenere la posizione.
Tabella corrente di stop
| Corrente di stop | S2 |
|---|---|
| 20 % | ON |
| 50 % | OFF |
L’impostazione decay riguarda come il chip driver gestisce la forza controelettromotrice (back EMF) del motore. Il datasheet Toshiba del TB6560 fornisce spiegazioni e diagrammi su questa impostazione. Di solito lascio la modalità decay al 0 %. Puoi sperimentare con questa impostazione per vedere cosa funziona meglio nel tuo setup.
Come riferimento, il driver TB6600 ha un’impostazione decay fissa al 40 %.
Tabella impostazione decay
| S5 | S6 | |
|---|---|---|
| 0 % Normale | OFF | OFF |
| 25 % | ON | OFF |
| 50 % | OFF | ON |
| 100 % Modalità veloce | ON | ON |
Nel resto di questo tutorial userò il driver in modalità 1/8 microstepping con corrente di funzionamento 1 A, corrente di stop 20 % e impostazione decay 0 %.
Esempio di codice Arduino per TB6560
Ora che hai cablato il driver e impostato gli interruttori dip, è il momento di collegare l’Arduino al computer e caricare un codice. Puoi caricare il seguente codice di esempio sul tuo Arduino usando il Arduino IDE. Per questo esempio specifico, non è necessario installare librerie.
Questo sketch controlla la velocità, il numero di rivoluzioni e la 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 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); }
Come funziona il codice:
Lo sketch inizia definendo i pin step (CLK-) e direzione (CW-). 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 quando il programma viene compilato. Quindi ovunque menzioni dirPin, il compilatore lo sostituirà con il valore 2 durante la compilazione.
Ho anche definito una costante stepsPerRevolution . Poiché ho impostato il driver in modalità 1/8 microstepping, l’ho settata a 1600 passi per rivoluzione. 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
Nella sezione setup() del codice, tutti i pin di controllo del motore sono dichiarati come OUTPUT digitali con la funzione pinMode().
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
Nella sezione loop() del codice, facciamo ruotare il motore di una rivoluzione lentamente in senso orario (CW) e una rivoluzione velocemente in senso antiorario (CCW). Poi facciamo ruotare il motore per 5 rivoluzioni in entrambe le direzioni ad alta velocità. Come si controllano velocità, direzione di rotazione e numero di rivoluzioni?
// 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à ruotare il motore in senso orario o antiorario.
Controllo del numero di passi o rivoluzioni:
In questo sketch di esempio, il for loops controlla il numero di passi che il motore farà. Il codice dentro il ciclo for corrisponde a 1 (micro)passo del motore. Poiché il ciclo viene eseguito 1600 volte (stepsPerRevolution), questo corrisponde a 1 rivoluzione. Negli ultimi due cicli, il codice dentro il for viene eseguito 8000 volte, corrispondenti a 8000 (micro)passi o 5 rivoluzioni.
Nota che puoi cambiare il secondo termine nel ciclo for con qualsiasi numero di passi desideri. for(int i = 0; i < 800; i++) corrisponderebbe a 800 passi o mezza rivoluzione.
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 è navigare 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.
Esempio di codice AccelStepper
Con il seguente sketch puoi aggiungere accelerazione e decelerazione ai movimenti del motore passo-passo, senza codici complicati. Nell’esempio il motore si muoverà avanti e indietro con una velocità di 1000 passi al secondo e 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 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); }
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 TB6560-Arduino e il tipo di interfaccia motore. Il motore interface type deve essere impostato a 1 quando si usa un driver step e 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
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 dovresti 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 per il driver A4988:
Conclusione
In questo articolo ti ho mostrato come controllare un motore passo-passo con il driver TB6560 e Arduino. Spero che ti sia stato utile e informativo.
Se vuoi imparare di più su altri driver per motori passo-passo, gli articoli qui sotto potrebbero esserti utili:
- 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
Nota che i commenti sono moderati per prevenire spam.
