En este tutorial, aprenderás cómo controlar un motor paso a paso con el driver de microstepping TB6560 y Arduino. Este driver es fácil de usar y puede controlar motores paso a paso grandes como un 3 A NEMA 23.
He incluido un diagrama de conexiones y 2 códigos de ejemplo. En el primer ejemplo, te mostraré cómo usar este driver de motor paso a paso sin una librería de Arduino. En el segundo ejemplo, veremos la librería AccelStepper. Esta librería es bastante fácil de usar y permite añadir aceleración y desaceleración al movimiento del motor paso a paso.
Después de cada ejemplo, desgloso y explico cómo funciona el código, para que no tengas problemas en modificarlo según tus necesidades.
Materiales
Componentes de 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 |
Herramientas
| Wire stripper | Amazon | ||
| Small screwdriver | Amazon | ||
| Self-adjusting crimping pliers (recomendado)* | Amazon | ||
| Wire ferrules assortment (recomendado)* | Amazon |
*Hackaday escribió un excelente artículo sobre los beneficios de usar terminales de cable (también conocidos como manguitos de extremo).
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.
Acerca del driver
El TB6560 driver de microstepping está basado en el chip Toshiba TB6560AHQ y puede usarse para controlar motores paso a paso bipolares de dos fases.
Con una corriente máxima continua de 3 A, el driver TB6560 puede controlar motores paso a paso bastante grandes como un NEMA 23. Asegúrate de no conectar motores con una corriente nominal superior a 3 A al driver.
El chip incluye varias funciones de seguridad como protección contra sobrecorriente, apagado por bajo voltaje y protección contra sobrecalentamiento. Sin embargo, no tiene protección contra voltaje inverso, así que asegúrate de conectar correctamente la fuente de alimentación. Puedes encontrar más especificaciones en la tabla a continuación.
Especificaciones del TB6560
| Voltaje de operación | 10 – 35 VDC, 24 VDC recomendado |
| Corriente máxima de salida | 3 A por fase, 3.5 A pico |
| Resolución de microstepping | completo, 1/2, 1/8 y 1/16 |
| Protección | Apagado por bajo voltaje, protección contra sobrecalentamiento y sobrecorriente |
| Dimensiones | 75 x 50 x 35 mm |
| Separación de orificios | 69 x 43 mm, ⌀ 3.5 mm |
| Costo | Check price |
Para más información, puedes consultar la hoja de datos/manual a continuación:
Ten en cuenta que el TB6560 es un driver analógico. En los últimos años, drivers digitales como el DM556 o DM542 se han vuelto mucho más asequibles. Los drivers digitales suelen ofrecer mejor rendimiento y funcionamiento más silencioso. Se pueden cablear y controlar de la misma forma que el TB6560, por lo que puedes actualizar tu sistema fácilmente más adelante.
He usado los drivers DM556 para mi router CNC DIY y han funcionado muy bien durante varios años.
TB6560 vs TB6600
Al buscar un driver TB6560 para motor paso a paso, probablemente también encuentres el driver TB6600 un poco más caro. Este driver puede controlarse con el mismo código/cableado, pero hay algunas diferencias clave.
| TB6560 | TB6600 | |
|---|---|---|
| Voltaje de operación | 10 – 35 VDC, 24 VDC recomendado | 9 – 42 VDC, 36 VDC recomendado |
| Corriente máxima de salida | 3 A por fase, 3.5 A pico | 3.5 A por fase, 4 A pico |
| # Ajustes de corriente | 14 | 8 |
| Resolución de microstepping | completo, 1/2, 1/8 y 1/16 | completo, 1/2, 1/4, 1/8, 1/16 y 1/32 |
| Frecuencia de reloj | 15 kHz | 200 kHz |
| Costo | Check price | Check price |
Así que las principales diferencias son el mayor voltaje máximo, mayor corriente máxima y hasta 1/32 de microstepping. Si quieres controlar motores paso a paso más grandes o necesitas mayor resolución, te recomiendo optar por el TB6600.
Cableado – Conectar TB6560 al motor paso a paso y Arduino
El diagrama de cableado a continuación muestra cómo conectar el driver TB6560 al Arduino y a un motor paso a paso.
En este tutorial, conectaremos el driver en configuración de cátodo común. Esto significa que conectamos todos los lados negativos de las señales de control juntos a tierra.
Las conexiones también se muestran en la tabla a continuación:
Conexiones TB6560
| TB6560 | Conexión |
|---|---|
| VCC | 10 – 35 VDC |
| GND | Tierra de la fuente de alimentación |
| EN- | No conectado |
| EN+ | No conectado |
| CW- | GND Arduino |
| CW+ | Pin 2 Arduino |
| CLK- | GND Arduino |
| CLK+ | Pin 3 Arduino |
| A-, A+ | Bobina 1 del motor paso a paso |
| B-, B+ | Bobina 2 del motor paso a paso |
Ten en cuenta que hemos dejado los pines de habilitación (EN- y EN+) desconectados. Esto significa que el pin de habilitación está siempre en LOW y el driver siempre está habilitado.
¿Cómo determinar el cableado correcto del motor paso a paso?
Si no encuentras la hoja de datos de tu motor paso a paso, puede ser difícil saber qué color de cable va a cada lado. Yo uso el siguiente truco para identificar cómo conectar motores bipolares de 4 cables:
Lo único que necesitas identificar son los dos pares de cables que están conectados a las dos bobinas del motor. Los cables de una bobina se conectan a A- y A+ y los de la otra a B- y B+, la polaridad no importa.
Para encontrar los dos cables de una bobina, haz lo siguiente con el motor desconectado:
- Intenta girar el eje del motor paso a paso con la mano y nota qué tan difícil es girarlo.
- Ahora toma un par de cables cualquiera del motor y toca sus extremos pelados juntos.
- Luego, mientras mantienes los extremos juntos, intenta girar el eje del motor paso a paso de nuevo.
Si sientes mucha resistencia, has encontrado un par de cables conectados a la misma bobina. El otro par está conectado a la segunda bobina.
Si aún puedes girar el eje libremente, prueba con otro par de cables. Ahora conecta las dos bobinas a los pines indicados en el diagrama de cableado arriba.
Si sigue sin estar claro, deja un comentario abajo, también puedes encontrar más información en el RepRap.org wiki.
Ajustes de microstepping del TB6560
Los motores paso a paso típicamente tienen un tamaño de paso de 1.8° o 200 pasos por revolución, esto se refiere a pasos completos. Un driver de microstepping como el TB6560 permite resoluciones más altas al permitir posiciones intermedias de paso. Esto se logra energizando las bobinas con niveles intermedios de corriente.
Por ejemplo, conducir un motor en modo de medio paso (1/2) dará al motor de 200 pasos por revolución 400 microsteps por revolución.
Puedes cambiar el ajuste de microstepping o modo de excitación del TB6560 activando o desactivando los interruptores DIP en el driver. Consulta la tabla a continuación para más detalles. ¡Asegúrate de que el driver no esté conectado a la alimentación cuando ajustes los interruptores DIP!
Tabla de microstepping
| S3 | S4 | Resolución de microstepping |
|---|---|---|
| OFF | OFF | Paso completo |
| ON | OFF | Medio paso (1/2) |
| ON | ON | 1/8 paso |
| OFF | ON | 1/16 paso |
En general, un ajuste de microstep más pequeño resultará en un funcionamiento más suave y silencioso. Sin embargo, limitará la velocidad máxima que puedes alcanzar al controlar el driver con Arduino.
Ajustes de corriente del TB6560
Puedes ajustar la corriente que va al motor cuando está funcionando configurando los interruptores DIP SW1, SW2, SW3 y S1 en ON o OFF. Recomiendo comenzar con un nivel de corriente de 1 A. Si tu motor pierde pasos o se detiene, siempre puedes aumentar la corriente más adelante.
Tabla de corriente
| (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 corriente de parada es la corriente usada para mantener el eje del motor en una posición detenida. Querrás ajustarla lo más baja posible para minimizar el calentamiento innecesario del motor. Aumenta este valor si tu motor no puede mantener su posición.
Tabla de corriente de parada
| Corriente de parada | S2 |
|---|---|
| 20 % | ON |
| 50 % | OFF |
El ajuste de decaimiento tiene que ver con cómo el chip driver maneja la fuerza contraelectromotriz (back EMF) del motor. La hoja de datos del TB6560 Toshiba ofrece explicación y diagramas sobre este ajuste. Normalmente dejo el modo de decaimiento en 0 %. Puedes experimentar con este ajuste para ver qué funciona mejor en tu configuración.
Como referencia, el driver TB6600 tiene un ajuste fijo de decaimiento del 40 %.
Tabla de ajuste de decaimiento
| S5 | S6 | |
|---|---|---|
| 0 % Normal | OFF | OFF |
| 25 % | ON | OFF |
| 50 % | OFF | ON |
| 100 % Modo rápido | ON | ON |
En el resto de este tutorial, usaré el driver en modo de microstepping 1/8 con corriente de funcionamiento de 1 A, corriente de parada del 20 % y ajuste de decaimiento del 0 %.
Código de ejemplo TB6560 para Arduino
Ahora que has conectado el driver y configurado los interruptores DIP, es hora de conectar el Arduino al ordenador y subir algo de código. Puedes subir el siguiente código de ejemplo a tu Arduino usando el Arduino IDE. Para este ejemplo específico, no necesitas instalar ninguna librería.
Este sketch controla la velocidad, el número de revoluciones y la dirección de giro del motor paso a paso.
Puedes copiar el código haciendo clic en el botón en la esquina superior derecha del campo de código.
/* 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); }
Cómo funciona el código:
El sketch comienza definiendo los pines de paso (CLK-) y dirección (CW-). Los conecté a los pines 3 y 2 del Arduino.
La instrucción #define se usa para dar un nombre a un valor constante. El compilador reemplazará cualquier referencia a esta constante con el valor definido cuando se compile el programa. Así que donde menciones dirPin, el compilador lo reemplazará con el valor 2 al compilar el programa.
También definí una constante stepsPerRevolution . Como configuré el driver en modo de microstepping 1/8, la puse en 1600 pasos por revolución. Cambia este valor si tu configuración es diferente.
// Define stepper motor connections and steps per revolution: #define dirPin 2 #define stepPin 3 #define stepsPerRevolution 1600
En la sección setup() del código, todos los pines de control del motor se declaran como OUTPUT digital con la función pinMode().
void setup() {
// Declare pins as output:
pinMode(stepPin, OUTPUT);
pinMode(dirPin, OUTPUT);
}
En la sección loop() del código, dejamos que el motor gire una revolución lentamente en dirección CW y una revolución rápidamente en dirección CCW. Luego dejamos que el motor gire 5 revoluciones en cada dirección a alta velocidad. ¿Cómo controlas la velocidad, dirección de giro y número de revoluciones?
// 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);
}
Controlar dirección de giro:
Para controlar la dirección de giro del motor paso a paso, configuramos el pin DIR (dirección) en HIGH o LOW. Para esto usamos la función digitalWrite(). Dependiendo de cómo conectaste el motor, poner el pin DIR en HIGH hará que el motor gire en sentido CW o CCW.
Controlar número de pasos o revoluciones:
En este sketch de ejemplo, el for loops controla el número de pasos que el motor dará. El código dentro del bucle for resulta en 1 (micro)paso del motor. Como el código en el bucle se ejecuta 1600 veces (stepsPerRevolution), esto resulta en 1 revolución. En los dos últimos bucles, el código dentro del for se ejecuta 8000 veces, lo que resulta en 8000 (micro)pasos o 5 revoluciones.
Ten en cuenta que puedes cambiar el segundo término en el bucle for al número de pasos que desees. for(int i = 0; i < 800; i++) resultaría en 800 pasos o media revolución.
Controlar velocidad:
La velocidad del motor paso a paso está determinada por la frecuencia de los pulsos que enviamos al pin STEP. A mayor frecuencia, más rápido gira el motor. Puedes controlar la frecuencia de los pulsos cambiando delayMicroseconds() en el código. Cuanto menor sea el retardo, mayor la frecuencia y más rápido gira el motor.
Instalando la librería AccelStepper
La librería AccelStepper escrita por Mike McCauley es una librería excelente para usar en tu proyecto. Una de sus ventajas es que soporta aceleración y desaceleración, pero también tiene muchas otras funciones útiles.
Puedes descargar la última versión de esta librería aquí:
Puedes instalar la librería yendo a Sketch > Include Library > Add .ZIP Library… en el IDE de Arduino.
Otra opción es navegar a Tools > Manage Libraries… o presionar Ctrl + Shift + I en Windows. Se abrirá el Library Manager y actualizará la lista de librerías instaladas.
Puedes buscar ‘accelstepper’ y buscar la librería de Mike McCauley. Selecciona la última versión y luego haz clic en Instalar.
Código de ejemplo AccelStepper
Con el siguiente sketch puedes añadir aceleración y desaceleración a los movimientos del motor paso a paso, sin necesidad de código complicado. En el siguiente ejemplo, el motor girará de un lado a otro con una velocidad de 1000 pasos por segundo y una aceleración de 500 pasos por segundo al cuadrado.
Ten en cuenta que sigo usando el driver en modo de microstepping 1/8. Si usas una configuración diferente, ajusta la velocidad y aceleración según convenga.
/* 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); }
Explicación del código:
El primer paso es incluir la librería con #include <AccelStepper.h>.
// Include the AccelStepper library: #include "AccelStepper.h"
El siguiente paso es definir las conexiones del TB6560 al Arduino y el tipo de interfaz del motor. El motor interface type debe configurarse en 1 cuando se usa un driver de paso y dirección.
// 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
Luego, necesitas crear una nueva instancia de la clase AccelStepper con el tipo de interfaz y conexiones apropiadas.
En este caso llamé al motor paso a paso ‘stepper’, pero puedes usar otros nombres como ‘z_motor’ o ‘liftmotor’, etc. AccelStepper liftmotor = AccelStepper(motorInterfaceType, stepPin, dirPin);. El nombre que le des al motor paso a paso se usará luego para configurar la velocidad, posición y aceleración de ese motor en particular. Puedes crear múltiples instancias de la clase AccelStepper con diferentes nombres y pines. Esto te permite controlar fácilmente 2 o más motores paso a paso al mismo tiempo.
// Create a new instance of the AccelStepper class: AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);
En el setup(), además de la velocidad máxima, necesitamos definir la aceleración/desaceleración. Para esto usamos la función setMaxSpeed() y setAcceleration().
void setup() {
// Set the maximum speed and acceleration:
stepper.setMaxSpeed(1000);
stepper.setAcceleration(500);
}
En la sección loop del código, dejamos que el motor gire un número predefinido de pasos. La función stepper.moveTo() se usa para establecer la posición objetivo (en pasos). La función stepper.runToPostion() mueve el motor (con aceleración/desaceleración) a la posición objetivo y bloquea hasta que llega a ella. Como esta función es bloqueante, no deberías usarla si necesitas controlar otras cosas al mismo tiempo.
// Set the target position: stepper.moveTo(8000); // Run to target position with set speed and acceleration/deceleration: stepper.runToPosition();
Si quieres ver más ejemplos para la librería AccelStepper, consulta mi tutorial para el driver A4988:
Conclusión
En este artículo te he mostrado cómo controlar un motor paso a paso con el driver TB6560 y Arduino. Espero que te haya resultado útil e informativo.
Si quieres aprender más sobre otros drivers para motores paso a paso, los artículos a continuación pueden ser útiles:
- 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
Ten en cuenta que los comentarios están sujetos a moderación para evitar spam.
