Dominando Motores Paso a Paso con Arduino: Guía Completa

En este tutorial aprenderemos todo lo necesario para controlar motores paso a paso con Arduino. Cubriremos cómo controlar un motor NEMA17 combinado con drivers A4988, DRV8825 y TMC2208.

Esta combinación se usa en innumerables aplicaciones donde se necesita control de posición: impresoras 3D, máquinas CNC, robótica, automatización, etc.

Yo la he usado en muchos proyectos Arduino:

• Slider de cámara DIY
• Máquina de doblado de alambre 3D
• Máquina de corte de espuma DIY
• Grabadora láser DIY
• Plotter con cambiador automático de bolígrafo
• Brazo robótico SCARA

Explicaré en detalle: funcionamiento, conexión de motores paso a paso con Arduino, ajuste del límite de corriente de los drivers y programación con y sin librería Arduino. También mostraré cómo controlar fácilmente múltiples motores usando un shield CNC para Arduino en cualquier proyecto.

Tenemos mucho que cubrir. Puede ver el vídeo siguiente o leer el tutorial escrito que incluye todos los códigos de ejemplo y diagramas de conexión.

¿Qué es un Motor Paso a Paso y Cómo Funciona?

Empezaré explicando brevemente qué es un motor paso a paso y cómo funciona, para entender mejor el resto.

Un motor paso a paso es un tipo único de motor DC sin escobillas cuya posición puede controlarse con precisión incluso sin retroalimentación (feedback).

Su principio se basa en campos magnéticos. Tiene dos componentes principales: un estator y un rotor. El rotor suele ser un imán permanente rodeado por bobinas en el estator.

Al energizar o hacer circular corriente por las bobinas, se generan campos magnéticos en el estator que atraen o repelen el rotor. Activando las bobinas paso a paso, en un orden particular, logramos movimiento continuo del rotor, pero también podemos detenerlo en cualquier posición.

Por eso se llaman motores paso a paso: se mueven en pasos discretos.

Aumentando el número de polos magnéticos en el rotor, aumentamos las posiciones de parada posibles, incrementando resolución o precisión. Nota: esto es explicación básica; hay más detalles en mi tutorial Cómo Funcionan los Motores Paso a Paso.

Un motor típico NEMA17 tiene 50 puntos de parada o pasos en el rotor. El estator tiene varias bobinas organizadas en dos fases que proporcionan 4 orientaciones de campo magnético.

Así, 50 pasos x 4 orientaciones = 200 pasos por vuelta completa. 360° / 200 = 1,8° por paso.

Las bobinas del estator están en dos fases, visible en los 4 hilos del motor (2 por fase). Las 4 orientaciones son posibles al hacer circular corriente en ambas direcciones por cada fase.

Hay motores de 5, 6 u 8 hilos, pero siguen funcionando en dos fases o se controlan con 4 terminales. Ofrecen distintas prestaciones (más par o velocidad) según cómo se conecten los hilos a los 4 terminales de control.

Con esto entendemos que para accionar un motor paso a paso no basta conectar alimentación; hay que energizar las dos fases en ambas direcciones y enviar pulsos en secuencia temporal. Por eso necesitamos drivers.

Hay muchos tipos y tamaños de drivers, pero el principio básico de todos es que tienen dos puentes H que permiten energizar las fases en ambas direcciones. También incluyen microstepping, limitación de corriente, etc., para facilitar el control.

Controlar Motor NEMA17 con Arduino y Driver A4988

Veamos el primer ejemplo: controlar un motor NEMA17 con driver A4988.

El NEMA17 es el más popular entre makers: buen rendimiento y asequible. Está en casi todas las impresoras 3D y grabadoras láser de escritorio.

Generalmente tiene 200 pasos (1,8°/paso), pero hay modelos de 400 pasos (0,9°/paso). La designación NEMA17 describe solo el tamaño de la brida frontal: 17/10 = 1,7 pulgadas (NEMA23 = 2,3 pulgadas). El tamaño de brida es fijo, pero la longitud varía de 20mm a 60mm, variando el consumo. El consumo se define por corriente máxima permitida: 0,3A a 2,5A para NEMA17.

Según la corriente nominal del motor, elegimos un driver que la soporte. El driver más popular para NEMA17 es el A4988.

El A4988 soporta máx. 2A por bobina (pico), pero se recomienda mantener ~1A, salvo con buena refrigeración (hasta 2A). Gran característica: limitación de corriente. Permite fijar cuánta corriente consumirá el motor independientemente de su nominal. Ejemplo: motor de 2,5A con driver limitado a 1,5A —no rendirá al máximo, pero funcionará. Si el motor es de menor nominal que el límite del driver, se sobrecalentará. Siempre intente igualar nominales.

Conexión A4988 y Arduino

Veamos cómo conectar driver, motor y Arduino.

Componentes necesarios (enlaces afiliados):

• Motor Paso a Paso NEMA 17 – Amazon / Banggood / AliExpress
• Driver A4988 – Amazon / Banggood / AliExpress
• Driver DRV8825 – Amazon / Banggood / AliExpress
• Driver TMC2208 – Amazon / Banggood / AliExpress
• Shield CNC Arduino – Amazon / Banggood / AliExpress
• Arduino Uno – Amazon / Banggood / AliExpress

Divulgación: Son enlaces afiliados. Como asociado de Amazon gano por compras que califican.

En la esquina superior derecha del driver: pines VMOT y GND para alimentación del motor (8-36V). Recomendado: condensador electrolítico ≥47µF entre ambos para proteger de picos de tensión.

Siguientes 4 pines: conexión del motor. Una fase en 1A y 1B, la otra en 2A y 2B.

Identificar fases: gire el eje a mano y una dos hilos; si es una fase, el giro se vuelve más difícil. O use multímetro en continuidad: pitido = fase. El orden en el driver no importa.

Pines VDD y GND (lado opuesto): alimentación lógica 3-5V. Pines Step y Direction: a cualquier pin Arduino. Direction selecciona sentido; Step controla pasos. Cada pulso en Step avanza un paso en la dirección seleccionada.

Pines Sleep y Reset (arriba): modo sleep y reset. Ambos activos en bajo. Sleep por defecto HIGH; RST flotante. Para habilitar el driver fácilmente, conecte ambos entre sí (si no usa esas funciones). Pin Enable también activo en bajo; si no lo pone HIGH, el driver está habilitado.

Pines MS1, MS2, MS3: seleccionan resolución de microstepping. Motor NEMA17 típico = 200 pasos/vuelta. El microstepping permite mayor resolución energizando bobinas en niveles intermedios. Ejemplo: quarter-step = 200 x 4 = 800 microsteps/vuelta. A4988 máx. 16 microsteps = 3200 pasos/vuelta (0,1125°/paso). Hay drivers de 256 microsteps = 51.200 pasos/vuelta (0,007°/paso). Estos pines tienen pull-down; si se dejan desconectados, modo paso completo. Para otra resolución, conecte 5V a pines según tabla.

Limitación de Corriente A4988

Antes de programar o alimentar el motor, ajuste el límite de corriente del driver. Debe ser inferior a la nominal del motor para evitar sobrecalentamiento.

El A4988 tiene un pequeño potenciómetro. Girar en sentido horario sube el límite. Dos métodos para determinar el valor real:

1. Medir voltaje de referencia (Vref) en el potenciómetro respecto a GND y usar fórmula: Límite = Vref / (8 x Rcs). Rcs = resistencia de sense (sensores de corriente junto al chip). Valores típicos: 0,05, 0,1 u 0,2 Ω. En mi caso, resistencias marcadas R100 = 0,1Ω. Ejemplo: Vref=0,7V → límite=0,875A. Para límite 1A → Vref=0,8V.
2. Medir corriente directa por las bobinas: conecte motor y driver, omita controlador, ponga 5V en Direction y Step para mantener posición activa. MS desconectados (paso completo). Desconecte una bobina y ponga amperímetro en serie. Alimente driver (lógica 5V, motor 12V). Lea corriente. Nota: en paso completo la corriente alcanza solo 70% del límite real; multiplique por 1,3 para obtener límite real en otros modos. Ambos métodos dan resultados similares.

Motores Paso a Paso y Arduino – Códigos de Ejemplo

Ahora programemos el Arduino con varios ejemplos.

Ejemplo 1: Control básico sin librería

/* Control básico de motor paso a paso sin librería
 * by Dejan, https://howtomechatronics.com */
#define stepPin 2
#define dirPin 5
void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}
void loop() {
  digitalWrite(dirPin, HIGH); // Dirección
  for(int x = 0; x < 800; x++) { // 800 pulsos = 1 vuelta en quarter-step
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(700); // Cambiar este delay cambia velocidad
    digitalWrite(stepPin, LOW);
    delayMicroseconds(700);
  }
  delay(1000);
  digitalWrite(dirPin, LOW); // Cambia dirección
  for(int x = 0; x < 1600; x++) { // 2 vueltas
    digitalWrite(stepPin, HIGH);
    delayMicroseconds(500);
    digitalWrite(stepPin, LOW);
    delayMicroseconds(500);
  }
  delay(1000);
}

Descripción: Definimos pines STEP y DIR como salidas. En loop, ponemos Direction HIGH, enviamos 200 pulsos (1 vuelta en paso completo) con delay entre flancos que define velocidad. Luego invertimos dirección y enviamos 400 pulsos (2 vueltas). Si cambiamos a quarter-step (800 pasos/vuelta), el primer bucle = 90°, segundo = 180°.

Ejemplo 2: Control de velocidad con potenciómetro

/* Control velocidad con potenciómetro sin librería
 * by Dejan, https://howtomechatronics.com */
#define stepPin 2
#define dirPin 5
int customDelay, customDelayMapped;
void setup() {
  pinMode(stepPin, OUTPUT);
  pinMode(dirPin, OUTPUT);
}
void loop() {
  speedControl();
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(customDelayMapped);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(customDelayMapped);
}
void speedControl() {
  customDelay = analogRead(A0); // Lee potenciómetro 0-1023
  customDelayMapped = map(customDelay, 0, 1023, 300, 3000); // Mapea a 300-3000 µs
}

Descripción: Leemos potenciómetro y mapeamos a delay en µs para pulsos Step. Mínimo ~300µs; por debajo el motor pierde pasos. Este método funciona para control simple; para control complejo, use librería.

Control con Librería AccelStepper – Ejemplos

La librería más popular es AccelStepper de Mike McCauley. Muy versátil: control de velocidad, aceleración/desaceleración, posiciones objetivo, control simultáneo de múltiples motores, etc. Tiene buena documentación. Yo la he usado en mis proyectos (Slider cámara, máquina doblado 3D, brazo SCARA, etc.).

Ejemplo: Control velocidad con potenciómetro (AccelStepper)

/* Control motor con AccelStepper
 * by Dejan, https://howtomechatronics.com */
#include 
AccelStepper stepper1(1, 2, 5); // Tipo driver 1 (2 pines STEP, DIR)
void setup() {
  stepper1.setMaxSpeed(1000); // Velocidad máx en pasos/seg
}
void loop() {
  stepper1.setSpeed(analogRead(A0)); // Velocidad actual desde potenciómetro
  stepper1.runSpeed(); // Ejecuta a velocidad constante
}

Descripción: Incluir librería (instalar desde Library Manager). Crear instancia AccelStepper: parámetro 1 = tipo driver (1 para 2 pines), pines STEP/DIR. En setup, setMaxSpeed (máx 4000, pero >1000 puede ser poco fiable). En loop, setSpeed con valor analógico (0-1023) y runSpeed() cada ciclo. Valor negativo = dirección opuesta.

Ejemplo: Control de dos motores con aceleración/desaceleración

/* Control dos motores con AccelStepper
 * by Dejan, https://howtomechatronics.com */
#include 
AccelStepper stepper1(1, 2, 5);
AccelStepper stepper2(1, 3, 6);
void setup() {
  stepper1.setMaxSpeed(1000);
  stepper1.setAcceleration(500);
  stepper1.setCurrentPosition(0);
  stepper2.setMaxSpeed(1000);
  stepper2.setAcceleration(500);
  stepper2.setCurrentPosition(0);
}
void loop() {
  stepper1.moveTo(800); // 800 pasos = 1 vuelta en quarter-step
  stepper1.runToPosition(); // Bloquea hasta llegar
  stepper2.moveTo(1600); // 2 vueltas
  stepper2.runToPosition();
  // Vuelta a 0 sin bloquear: ambos a la vez
  stepper1.moveTo(0);
  stepper2.moveTo(0);
  while (stepper1.currentPosition() != 0 || stepper2.currentPosition() != 0) {
    stepper1.run(); // No bloqueante, un paso por llamada
    stepper2.run();
  }
}

Descripción: Definimos dos motores. En setup: setAcceleration y setCurrentPosition(0). En loop: moveTo() define posición objetivo; runToPosition() mueve con aceleración/desaceleración pero bloquea. Para no bloquear, usamos run() (un paso por llamada) en bucle while hasta que ambos llegan a 0. Podemos añadir más código en el while. Hay muchos métodos; recomiendo leer la documentación.

Ejemplo: Control coordinado de múltiples motores (MultiStepper)

/* Control múltiple con AccelStepper y MultiStepper
 * by Dejan, https://howtomechatronics.com */
#include 
#include 
AccelStepper stepper1(1, 2, 5);
AccelStepper stepper2(1, 3, 6);
AccelStepper stepper3(1, 4, 7);
MultiStepper steppersControl;
long gotoposition[3];
void setup() {
  stepper1.setMaxSpeed(1000);
  stepper2.setMaxSpeed(1000);
  stepper3.setMaxSpeed(1000);
  steppersControl.addStepper(stepper1);
  steppersControl.addStepper(stepper2);
  steppersControl.addStepper(stepper3);
}
void loop() {
  gotoposition[0] = 800;  // 1 vuelta
  gotoposition[1] = 1600; // 2 vueltas
  gotoposition[2] = 3200; // 3 vueltas
  steppersControl.moveTo(gotoposition); // Calcula velocidades requeridas
  steppersControl.runSpeedToPosition(); // Bloquea hasta que todos lleguen
  delay(1000);
  gotoposition[0] = 0;
  gotoposition[1] = 0;
  gotoposition[2] = 0;
  steppersControl.moveTo(gotoposition);
  steppersControl.runSpeedToPosition();
  delay(1000);
}

Descripción: Incluir MultiStepper, crear instancia y array long para posiciones objetivo. En setup: maxSpeed y addStepper. En loop: cargar array, moveTo() calcula velocidades para que todos lleguen a la vez, runSpeedToPosition() bloquea hasta fin. Nota: MultiStepper no soporta aceleración/desaceleración. Para no bloquear, use run() en bucle.

Shield CNC Arduino para Controlar Múltiples Motores Paso a Paso

El shield CNC para Arduino sirve principalmente para máquinas CNC de 2-3 ejes, pero es excelente para cualquier proyecto que requiera controlar múltiples motores paso a paso: compacto y conexiones fáciles para drivers y motores.

Se monta sobre Arduino UNO, controla hasta 4 motores individuales y deja el resto de pines libres. Lo usé en mi brazo robótico SCARA de 4 ejes.

Actualizaré esta sección con más detalles sobre uso del shield CNC con Arduino próximamente.

DRV8825 vs A4988

Veamos el driver DRV8825. Todo lo explicado para A4988 aplica a DRV8825: principio, conexiones, código son casi idénticos. Diferencias en características técnicas:

• Más corriente sin refrigeración extra: 1,5A vs 1A (pico 2,5A vs 2A).
• Voltaje máx. de alimentación superior: 45V vs 35V.
• Mayor resolución de microstepping: 32 vs 16 microsteps.

Otras diferencias menores: potenciómetro en distinta ubicación, relación Vref-límite distinta. DRV8825 no necesita alimentación lógica (ese pin es salida FAULT). Es seguro conectar FAULT a 5V, así DRV8825 sirve como reemplazo directo en sistemas diseñados para A4988.

Importante: Al reemplazar A4988 por DRV8825, verifique orientación correcta. Potenciómetros en lados opuestos (A4988 bajo chip, DRV8825 sobre chip) → confusión fácil → driver al revés.

Para límite de corriente: mida Vref con una punta en GND y otra en potenciómetro. Fórmula: Límite = Vref x 2. Tabla para microstepping distinta.

En resumen, DRV8825 es mejor que A4988: mayor corriente, voltaje y microstepping → funcionamiento más suave y silencioso.

Driver TMC2208

Hablando de suave y silencioso: TMC2208 de Trinamic (Alemania), especialistas en electrónica de control de movimiento. Driver silencioso, reemplazo directo de A4988/DRV8825. Usado en impresoras 3D, grabadoras láser, escáneres.

Lo que lo distingue: unidad de interpolación integrada con 256 subdivisiones (microsteps). Proporciona control sinusoidal perfecto generado internamente. El driver entrega 256 microsteps al motor, independientemente de la resolución seleccionada en pines MS (2, 4, 8, 16). Esto da funcionamiento más suave y reduce carga del microcontrolador.

Combinado con tecnología StealthChop2 (control de corriente sin ruido), logra control ultra-silencioso.

Niveles de ruido: A4988 ~65dB, DRV8825 ~67dB, TMC2208 ~41dB. ¡El TMC2208 mueve motores en silencio total!

Corriente nominal: 1,2A (pico 2A) —ligeramente superior a A4988. Límite de corriente: mida Vref en GND y patilla junto a pin Enable. Fórmula: Límite = Vref x 0,71.

Pinout ligeramente distinto: solo 2 pines MS, Enable se activa conectando a GND. Código igual que los otros.

Funciones avanzadas: interfaz UART simple para control con una sola línea (en vez de Step/Dir), más opciones de ajuste y control.

En general, TMC2208 es mejor que A4988 y DRV8825, pero cuesta más. Si no necesita extras y el ruido no le preocupa, los otros dos son excelente opción.

Conclusión

Hemos cubierto lo esencial para controlar motores paso a paso con Arduino. NEMA17 y los tres drivers (A4988, DRV8825, TMC2208) son increíblemente versátiles para aplicaciones que requieren control de posición. Puede aprender más explorando mis proyectos Arduino.

Si le interesa controlar motores mayores (NEMA23, NEMA34), tendré un tutorial dedicado.

¡Espero que disfrutara y aprendiera! Suscríbase y deje preguntas en comentarios.