Driver A4988 con NEMA 17 y Arduino: Vref, micropasos y código

Controlar un NEMA 17 con el A4988 es la forma más barata de llevar a tu propio proyecto el movimiento preciso que usan las impresoras 3D, las fresadoras CNC y los grabadores láser. El A4988 es un driver para motores paso a paso bipolares fabricado por Allegro y que se vende en un módulo del tamaño de la yema de un dedo: cada pulso en STEP que envía Arduino avanza el motor un paso, el pin DIR elige el sentido de giro y el driver mantiene la corriente de las bobinas en el valor que tú fijas. Es decir, para hacer girar el motor solo necesitas dos pines y una fuente de alimentación de entre 8 y 35 V.

En esta guía aprenderás cómo funciona el A4988, cómo encontrar las bobinas de un NEMA 17 con el multímetro, cómo conectarlo y por qué necesitas un condensador de 100 µF en la alimentación. Después pasaremos al paso más crítico, ajustar la corriente con Vref, con la fórmula y la medición con multímetro paso a paso. También verás los micropasos con los pines MS1–MS3, un primer código sin librería, aceleración suave con AccelStepper, la CNC Shield, código para ESP32 y Raspberry Pi Pico, calor y disipadores, una comparación con el DRV8825 y el TMC2208, y soluciones al clásico problema de "el motor vibra pero no gira".

¿Qué es el A4988 y cómo funciona?

Dentro del A4988 hay dos puentes H completos (uno por bobina), un traductor (translator) y un circuito de control de corriente. El traductor convierte cada flanco LOW→HIGH del pin STEP en la secuencia de corriente correcta para las bobinas, así que no tienes que calcular el orden de las bobinas en el código. El control de corriente funciona por troceado (chopper): el driver mide continuamente la corriente de cada bobina a través de una pequeña resistencia de medida (Rs) y corta la salida durante un instante cuando la corriente alcanza el límite ajustado. Por eso la corriente de la bobina se mantiene en un valor seguro aunque alimentes el motor muy por encima de su tensión nominal, por ejemplo con 12 o 24 V. Además, el chip tiene protección contra sobretemperatura, baja tensión, cortocircuito en la carga y cortocircuito a masa.

Motor paso a paso NEMA 17: características y cómo encontrar las bobinas

NEMA 17 no es un modelo de motor, sino un estándar de tamaño para motores con una cara frontal de 42 × 42 mm; lo que hay dentro depende de la longitud del cuerpo y del fabricante. El 17HS4401, el modelo más habitual en proyectos de aficionados, da 200 pasos por vuelta (1,8°), tiene una corriente nominal de 1,7 A por fase, una resistencia de bobina de unos 1,5 Ω y alrededor de 40 N·cm de par de retención. La tensión de su etiqueta es solo 1,7 A × 1,5 Ω ≈ 2,6 V, pero que no te engañe: como el A4988 limita la corriente por sí mismo, el motor se alimenta con 12–24 V. Una tensión más alta hace que la corriente de la bobina suba más rápido en cada paso, así que el motor pierde menos par a alta velocidad. Si te interesa la diferencia con motores unipolares pequeños como el 28BYJ-48, consulta 28BYJ-48 y ULN2003.

Los 4 cables del motor pertenecen a dos bobinas independientes, y antes de conectarlo al A4988 tienes que saber qué dos cables forman la misma bobina. En muchos modelos el negro y el verde son una bobina y el rojo y el azul la otra, pero los colores cambian según el fabricante, así que lo más fiable es medir:

1. Pon el multímetro en medición de resistencia (Ω); si no sabes cómo, echa un vistazo a la guía del multímetro.
2. Sujeta un cable y mídelo uno por uno con los otros tres. El que marque 1–4 Ω es el otro extremo de la misma bobina; con los otros dos la pantalla muestra circuito abierto (OL).
3. Los dos cables restantes son la segunda bobina y deben dar la misma resistencia. Con la resistencia medida y la corriente nominal puedes comprobar la tensión de la etiqueta con la calculadora de la ley de Ohm.
4. ¿No tienes multímetro? Junta los extremos de dos cables y gira el eje con la mano: si cuesta claramente más girarlo, esos dos cables son de la misma bobina.
5. Conecta una bobina a los pines 1A–1B del A4988 y la otra a 2A–2B. Si el motor gira al revés de lo que quieres, basta con intercambiar los dos cables de una sola bobina.

Pines del A4988 y esquema de conexión

¿Por qué es imprescindible el condensador de 100 µF?

Las placas A4988 solo llevan pequeños condensadores cerámicos. Junto con la inductancia de los cables de alimentación, estos condensadores de baja ESR provocan picos de tensión al encender la fuente o cuando el motor pide corriente de golpe. Esos picos pueden superar el límite de 35 V del chip incluso con una alimentación de solo 12 V y dañar el driver para siempre. La solución es sencilla: coloca entre VMOT y GND, lo más cerca posible de la placa, un condensador electrolítico de al menos 47 µF, mejor de 100 µF. Su tensión nominal debe estar holgadamente por encima de la de alimentación: elige uno de 25 V para 12 V, y de 35 V o 50 V para 24 V. Los electrolíticos tienen polaridad; la pata larga (+) va a VMOT y la corta (–), marcada con la franja del cuerpo, va a GND. Para conocer los tipos de condensador consulta ¿Qué es un condensador?, y para elegir el adaptador adecuado, alimentación de Arduino.

Ajuste de corriente con Vref: la fórmula

El pequeño potenciómetro del A4988 ajusta Vref (la tensión de referencia), que determina la corriente máxima del motor. El driver compara esta tensión con la de las dos resistencias de medida (Rs) de la placa, y la corriente máxima de bobina se obtiene con: I = Vref / (8 × Rs). Para hallar la Vref que necesitas, despeja la fórmula: Vref = I × 8 × Rs. Para saber Rs, lee el código impreso en las dos pequeñas resistencias SMD junto al chip: R100 significa 0,1 Ω, R068 0,068 Ω y R050 0,05 Ω. Si te cuesta descifrar los códigos, usa la calculadora de códigos de resistencias SMD o el artículo sobre códigos de resistencias SMD.

¿Qué corriente elegir? La corriente de la etiqueta del motor (1,7 A en el 17HS4401) es un techo que nunca debes superar. Sin disipador, el A4988 aguanta cómodamente alrededor de 1 A, así que 0,8–1 A es un buen punto de partida. En las placas habituales con resistencias R100 eso equivale a una Vref de 0,64–0,80 V. Si el motor pierde pasos con carga, sube la corriente de 0,1 A en 0,1 A; si pasas de 1,2 A, pon un disipador y un ventilador al chip. Una corriente mayor de la necesaria calienta el driver y el motor mucho más de lo que hace al motor realmente más fuerte.

Medir Vref con el multímetro paso a paso

1. Con todo apagado, desconecta el motor del driver. Para medir Vref no hace falta el motor.
2. Alimenta los pines VDD y GND del A4988 con la tensión lógica (basta con los 5V de Arduino). Vref se obtiene de esta tensión, así que sin VDD no se puede medir; dejar VMOT conectado no causa problemas.
3. Pon el multímetro en tensión continua (escala de 2 V o 20 V). Apoya la punta negra en GND y la roja en la parte metálica superior del potenciómetro; algunas placas tienen en su lugar un pequeño punto de medida marcado como VREF.
4. Gira el potenciómetro muy poco con un destornillador pequeño de plástico o cerámica y observa el valor. En la mayoría de placas, girar en sentido horario aumenta Vref, pero puede variar; algunos potenciómetros vuelven al inicio tras una vuelta completa, así que avanza poco a poco.
5. Cuando llegues al valor calculado, corta la alimentación, conecta el motor y solo entonces vuelve a encenderla.
6. Haz funcionar el motor unos minutos y comprueba la temperatura del chip. Si no puedes mantener el dedo encima ni unos segundos, baja un poco Vref o añade un disipador.

Micropasos con MS1, MS2 y MS3

Los micropasos (microstepping) consisten en que el driver varía gradualmente la corriente de las dos bobinas para dividir cada paso completo en partes más pequeñas. El A4988 elige uno de cinco modos según los niveles lógicos de los pines MS1–MS3. Estos pines tienen resistencias pull-down internas, así que si dejas los tres sin conectar el motor funciona en paso completo.

La verdadera ventaja de los micropasos es un giro suave y silencioso: en paso completo el motor da un tirón en cada paso y entra en resonancia y vibra a ciertas velocidades, mientras que a 1/16 el movimiento es casi continuo. Pero no esperes que la precisión se multiplique de verdad por 16. El par que hace avanzar un solo micropaso es solo sin(90° / 16) ≈ 10 % del par de retención; si el rozamiento o la carga superan esa pequeña fuerza, el motor se queda unos micropasos atrás. Para calcular la velocidad usa: pasos/s = rpm × 200 × micropasos / 60. Por ejemplo, 60 rpm a 1/16 necesitan 3200 pulsos STEP por segundo. Si quieres cambiar el modo por software, también puedes conectar los pines MS a Arduino; aunque en la mayoría de proyectos basta con fijar un modo con cables.

Primer código: giro con STEP y DIR sin librería

El siguiente código hace girar el motor una vuelta hacia delante y otra hacia atrás sin ninguna librería, solo enviando pulsos al pin STEP. Suponemos que has conectado MS1–MS3 a 5V, es decir, que el motor funciona a 1/16 y una vuelta son 3200 pasos.

1// A4988 + NEMA 17, kütüphanesiz / without a library
2const int STEP_PIN = 2;            // CNC Shield X ekseniyle aynı / same as CNC Shield X axis
3const int DIR_PIN  = 5;
4const int EN_PIN   = 8;            // aktif LOW / active LOW
5
6const long STEPS_PER_REV = 200L * 16;   // 1,8° motor, 1/16 mikro adım = 3200 / 1.8° motor, 1/16 microstep
7
8void setup() {
9  pinMode(STEP_PIN, OUTPUT);
10  pinMode(DIR_PIN, OUTPUT);
11  pinMode(EN_PIN, OUTPUT);
12  digitalWrite(EN_PIN, LOW);       // sürücüyü aç / enable the driver
13}
14
15void rotate(long steps, unsigned int pauseUs) {
16  digitalWrite(DIR_PIN, steps > 0 ? HIGH : LOW);   // yön / direction
17  delayMicroseconds(5);                           // DIR, STEP'ten önce otursun / let DIR settle before STEP
18  for (long i = 0; i < labs(steps); i++) {
19    digitalWrite(STEP_PIN, HIGH);
20    delayMicroseconds(5);                         // darbe en az 1 µs / pulse at least 1 µs
21    digitalWrite(STEP_PIN, LOW);
22    delayMicroseconds(pauseUs);                   // küçüldükçe hız artar / smaller = faster
23  }
24}
25
26void loop() {
27  rotate(STEPS_PER_REV, 500);      // 1 tur ileri, ~1,6 sn / one turn forward, ~1.6 s
28  delay(1000);
29  rotate(-STEPS_PER_REV, 500);     // 1 tur geri / one turn back
30  delay(1000);
31}

Hay tres tiempos a tener en cuenta en este código. El A4988 exige que la parte HIGH y la LOW del pulso STEP duren al menos 1 µs; 5 µs es un valor seguro. Tras cambiar DIR hay que esperar al menos 200 ns antes del primer pulso STEP; el código espera 5 µs para ello. La velocidad la marca la pausa entre pulsos: con 500 µs de pausa, un paso dura unos 0,51 ms y una vuelta (3200 pasos) unos 1,6 segundos, es decir, unas 36 rpm. Este código tiene dos puntos débiles: el motor arranca de golpe a toda velocidad y Arduino no puede hacer nada más mientras dura el bucle. Si bajas la pausa directamente a 100 µs, lo más probable es que el motor no llegue a arrancar y solo zumbe.

Aceleración y deceleración con AccelStepper

No puedes llevar un motor paso a paso de parado a alta velocidad en un instante; el rotor y la carga no pueden seguir un cambio tan brusco, el motor pierde el sincronismo y se salta pasos. La solución es aumentar la velocidad en rampa y reducirla al acercarse al destino. AccelStepper, que puedes instalar desde el Gestor de Librerías, lo hace sin bloquear: llamas a run() continuamente dentro de loop() y la librería da un paso cada vez que toca. Así puedes leer botones, actualizar una pantalla o medir sensores mientras el motor gira; encontrarás esta idea en detalle en millis() y delay(). En un Uno, AccelStepper alcanza de forma fiable unos pocos miles de pasos por segundo (su documentación indica unos 4000 pasos/s a 16 MHz), por eso el ejemplo usa 2000 pasos/s, unas 37 rpm a 1/16.

1#include <AccelStepper.h>
2
3const int STEP_PIN = 2;
4const int DIR_PIN  = 5;
5const int EN_PIN   = 8;
6const long STEPS_PER_REV = 200L * 16;            // 1/16 mikro adımda 1 tur / one turn at 1/16 microstep
7
8AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
9
10void setup() {
11  stepper.setEnablePin(EN_PIN);
12  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
13  stepper.enableOutputs();
14  stepper.setMaxSpeed(2000);                     // adım/sn, Uno için güvenli / steps per second, safe on Uno
15  stepper.setAcceleration(1500);                 // adım/sn² / steps per second²
16  stepper.moveTo(STEPS_PER_REV * 3);             // 3 tur ileri / three turns forward
17}
18
19void loop() {
20  if (stepper.distanceToGo() == 0) {             // hedefe varıldı / target reached
21    delay(500);
22    stepper.moveTo(stepper.currentPosition() == 0 ? STEPS_PER_REV * 3 : 0);   // git-gel / back and forth
23  }
24  stepper.run();                                 // her döngüde çağır, bekletmez / call every loop, non-blocking
25}

Varios motores con la CNC Shield V3

Si vas a controlar más de un NEMA 17, la forma más sencilla de evitar la maraña de cables es la CNC Shield V3 para Arduino. Esta placa se monta sobre el Uno y tiene cuatro zócalos para A4988 (X, Y, Z y A), jumpers de micropasos bajo cada driver, conectores de motor, entradas para finales de carrera y una bornera de alimentación; con los tres jumpers puestos, el A4988 funciona a 1/16. En la tabla de conexiones elegimos a propósito D2, D5 y D8 para STEP, DIR y EN: son los pines del eje X de la shield, así que los códigos anteriores funcionan en ella sin cambios. Si cargas GRBL en el Uno, la shield se convierte en una controladora CNC o láser que recibe G-code desde el ordenador. En GRBL escribes los pasos por milímetro de cada eje en los ajustes $100, $101 y $102: con una polea GT2 de 20 dientes y micropasos a 1/16 son 200 × 16 / (20 × 2) = 80 pasos/mm, y con un husillo trapezoidal T8 de 8 mm de avance, 200 × 16 / 8 = 400 pasos/mm.

Uso del A4988 con ESP32

Los pines del ESP32 dan 3,3 V. El A4988 solo reconoce con seguridad una entrada como HIGH si supera el 70 % de VDD; con VDD a 5 V ese umbral es 3,5 V, así que una señal de 3,3 V se queda corta. Por eso, con ESP32 y Pico conecta el pin VDD del A4988 a 3V3: el driver funciona sin problemas entre 3 y 5,5 V y no necesitarás un conversor de niveles lógicos. Como VDD ha cambiado, no olvides volver a medir Vref. El siguiente código lleva el motor, con aceleración, al ángulo que escribas en el Monitor Serie (por ejemplo, 90 o -45). Como el ESP32 es mucho más rápido, aquí AccelStepper alcanza sin esfuerzo 6000 pasos por segundo; para velocidades mayores, echa un vistazo a la librería FastAccelStepper, que usa temporizadores por hardware. Si el ESP32 es nuevo para ti, empieza por ¿Qué es el ESP32?.

1#include <AccelStepper.h>
2
3// ESP32: STEP=25, DIR=26, EN=27, A4988 VDD → 3V3
4const int STEP_PIN = 25;
5const int DIR_PIN  = 26;
6const int EN_PIN   = 27;
7const float STEPS_PER_DEG = 200.0 * 16 / 360.0;  // 1/16'da derece başına 8,89 adım / 8.89 steps per degree at 1/16
8
9AccelStepper stepper(AccelStepper::DRIVER, STEP_PIN, DIR_PIN);
10
11void setup() {
12  Serial.begin(115200);
13  stepper.setEnablePin(EN_PIN);
14  stepper.setPinsInverted(false, false, true);   // EN aktif LOW / EN is active LOW
15  stepper.enableOutputs();
16  stepper.setMaxSpeed(6000);                     // adım/sn / steps per second
17  stepper.setAcceleration(4000);                 // adım/sn² / steps per second²
18  Serial.println("Aci yaz, ornek 90 / type an angle, e.g. 90");
19}
20
21void loop() {
22  if (Serial.available()) {
23    float angle = Serial.parseFloat();           // Seri Monitör'den açı / angle from the Serial Monitor
24    while (Serial.available()) Serial.read();    // satır sonunu at / drop the line ending
25    stepper.moveTo(lround(angle * STEPS_PER_DEG));
26    Serial.printf("Hedef / target: %.1f\n", angle);
27  }
28  stepper.run();                                 // bekletmeden adım at / step without blocking
29}

A4988 con Raspberry Pi Pico y MicroPython

En la Pico también conectas el VDD del A4988 al pin 3V3 (OUT). En lugar de una librería de aceleración, en MicroPython puedes escribir una rampa lineal sencilla como la de abajo: la función move() cambia gradualmente la pausa entre pulsos de 2000 µs a 400 µs durante los primeros y los últimos 600 pasos, y en medio va a máxima velocidad. El bucle de MicroPython añade unas decenas de microsegundos a cada paso, así que la velocidad real es algo menor que la calculada. Si necesitas decenas de miles de pasos por segundo o varios motores a la vez, los bloques PIO de la Pico pueden generar los pulsos sin ocupar la CPU en absoluto. Para instalar MicroPython en la Pico, consulta ¿Qué es la Raspberry Pi Pico?.

1from machine import Pin
2import time
3
4step = Pin(2, Pin.OUT)              # STEP → GP2
5direction = Pin(3, Pin.OUT)         # DIR → GP3
6enable = Pin(4, Pin.OUT, value=0)   # EN → GP4, 0 = sürücü açık / 0 = driver enabled
7
8STEPS_PER_REV = 200 * 16            # 1/16 mikro adım / 1/16 microstep
9
10def move(steps, max_sps=2500, ramp_steps=600):
11    direction.value(1 if steps > 0 else 0)    # yön / direction
12    time.sleep_us(5)
13    n = abs(steps)
14    ramp = min(ramp_steps, n // 2)            # hızlanma ve yavaşlama adımı / accel and decel steps
15    fast = 1000000 // max_sps                 # en kısa bekleme, µs / shortest pause, µs
16    slow = 2000                               # 500 adım/sn ile başla / start at 500 steps/s
17    for i in range(n):
18        k = min(i, n - 1 - i)                 # başa ya da sona uzaklık / distance to start or end
19        pause = slow - (slow - fast) * k // ramp if k < ramp else fast
20        step.value(1)
21        time.sleep_us(3)                      # STEP darbesi / STEP pulse
22        step.value(0)
23        time.sleep_us(pause)
24
25while True:
26    move(STEPS_PER_REV)             # 1 tur ileri / one turn forward
27    time.sleep(1)
28    move(-STEPS_PER_REV // 2)       # yarım tur geri / half a turn back
29    time.sleep(1)

Calor, disipador y protección térmica

Es normal que el A4988 se caliente, porque la corriente de las bobinas pasa por los MOSFET del interior del chip. El camino de corriente de cada bobina tiene normalmente una resistencia total de 0,64 Ω, y la potencia disipada crece con el cuadrado de la corriente: aproximadamente P ≈ I² × 0,64 Ω. Con 1 A son unos 0,65 W, y con 1,5 A unos 1,45 W; además, al calentarse el chip la resistencia aumenta y el valor real es aún mayor. Para una placa del tamaño de una yema de dedo es mucho calor. Cuando el chip llega a 165 °C, la protección térmica desactiva las salidas y las vuelve a activar al enfriarse unos 15 °C. Un motor que funciona unos segundos, se para y luego sigue solo es la señal típica de esta protección.

• Pon un disipador: Pega un pequeño disipador de aluminio sobre el chip con cinta térmica; asegúrate de que no toque los pines ni el potenciómetro.
• Asegura flujo de aire: Por encima de 1,2 A o dentro de una caja cerrada, un pequeño ventilador multiplica el efecto del disipador.
• Ajusta la corriente a lo que necesitas: Si el motor no pierde pasos con carga, baja un poco Vref; reducir la corriente un 20 % reduce el calor en torno a un 36 %.
• Desactiva las bobinas en reposo: Si no necesitas par de retención, pon el pin EN a HIGH o llama a disableOutputs() al terminar el movimiento; el driver y el motor se enfrían.
• Vigila también la temperatura del motor: Los motores paso a paso consumen corriente incluso parados, así que se ponen templados o incluso calientes. Si la carcasa supera los 60 °C, baja la corriente; a esa temperatura las piezas de PLA de una impresora 3D empiezan a ablandarse.
• Pasa a un driver más potente: Si tu motor necesita más de 1,5 A, un driver como el DRV8825 o el TMC2209 es más adecuado.

Diferencias entre A4988, DRV8825 y TMC2208

Los tres drivers usan el mismo formato "StepStick" de 16 pines y a menudo se pueden intercambiar en una CNC Shield, pero hay diferencias que vigilar. El potenciómetro del DRV8825 está en otro sitio y su fórmula es distinta; el pin que en el A4988 es VDD es la salida FAULT en el DRV8825. Con el mismo código, el TMC2208 hace girar el motor en sentido contrario al A4988, así que tendrás que invertir DIR en el código o girar 180° el conector del motor. Sus ajustes avanzados se hacen por UART, y si quieres homing sin sensores (StallGuard), fíjate en el TMC2209. En resumen, para aprender y para proyectos de bajo coste el A4988 sigue siendo el punto de partida más sensato; elige el TMC2208 si importa el ruido y el DRV8825 si necesitas más corriente. Para una comparación general de tipos de motor, lee diferencias entre motor DC, servo y paso a paso.

El motor vibra pero no gira: errores frecuentes y soluciones

Ideas de proyectos con A4988 y NEMA 17

• Slider para cámara: Desplaza una cámara por un raíl milímetro a milímetro con correa y polea GT2 para grabar vídeos time-lapse.
• Plotter de dibujo: Mueve un bolígrafo en dos ejes con una CNC Shield y GRBL para pasar al papel dibujos del ordenador; para subir y bajar el bolígrafo basta un servomotor.
• Plato giratorio: Gira un objeto en ángulos iguales para fotos de producto o escaneo 3D; como una vuelta son 3200 pasos a 1/16, para 36 fotos das unos 89 pasos entre cada una.
• Seguidor solar: Construye un sistema que oriente un panel hacia el sol durante todo el día; tienes la idea completa en el artículo del seguidor solar.
• Base de brazo robótico: Gira la base de un brazo pesado con un NEMA 17 y engranajes en lugar de un servo; para el resto de articulaciones, mira el artículo del brazo robótico.
• Posicionamiento manual: Mueve el motor rápido con un joystick y con precisión, paso a paso, con un encoder rotativo.
• Cortina automática o tapa deslizante: Al arrancar, busca el punto cero con un final de carrera, guárdalo con setCurrentPosition(0) y lleva la cortina a la posición que quieras.

En resumen, controlar un NEMA 17 con el A4988 consiste en emparejar bien las bobinas, poner 100 µF en la alimentación, calcular Vref con la fórmula y ajustarla con el multímetro, elegir los micropasos y mover el motor con aceleración. Cuando domines esta base, también entenderás cómo funcionan máquinas como las impresoras 3D y las CNC. En la app BlueGrays encontrarás proyectos de movimiento como el uso de un motor paso a paso o convertir un motor paso a paso en un servo de 360 grados, paso a paso, con esquemas de circuito y código.