Motores paso a paso

01 · Punto de partida

Posición contando pulsos

Con un motor DC necesitábamos un encoder y un lazo de control para saber dónde estaba el eje (tema 31); con un servo, un lazo cerrado interno (tema 32). Un motor paso a paso (stepper) resuelve el problema de otra forma: está construido para avanzar un ángulo fijo y repetible por cada pulso. Si el motor da 200 pasos por vuelta (1,8° cada uno), moverlo 90° es enviarle 50 pulsos; y no hace falta ningún sensor. La posición es la cuenta de pulsos que lleva el programa.

Esa idea de lazo abierto es la ventaja y la debilidad del paso a paso. Ventaja: precisión sin sensor, sin ajuste de ganancias, par de retención a velocidad cero y comportamiento muy predecible. Debilidad: si se le pide más de lo que puede dar (demasiada carga, aceleración o velocidad), pierde pasos sin avisar, y la posición que cree tener el programa deja de coincidir con la real. Todo el tema gira alrededor de cómo sacarle el máximo y evitar que eso pase.

02 · Principio

Cómo funciona

Un paso a paso híbrido (como el NEMA 17, el más común) tiene un rotor con muchos dientes magnetizados y un estator con dos bobinas (fases A y B) repartidas en varios polos. Al energizar una bobina, el rotor se alinea con sus polos; al energizar la siguiente en la secuencia, el rotor avanza hasta alinearse con ella. Cada cambio de bobina es un paso. Los motores comunes dan 200 pasos por vuelta (1,8° por paso); algunos, 400 (0,9°).

Un motor energizado y parado ejerce un par de retención (holding torque), que lo mantiene en su posición: a diferencia de un motor DC, no necesita realimentación para quedarse quieto. Un NEMA 17 típico da unos 4 a 5 kg·cm (0,4 a 0,5 N·m). El costo es que, mientras mantiene, consume corriente completa y se calienta, aunque no se mueva; por eso los drivers permiten reducirla o deshabilitar el motor cuando no hace falta.

Los motores pequeños de relojería y los de instrumentos usan el mismo principio. El 28BYJ-48 (5 V), muy popular, incluye un reductor interno de aproximadamente 64:1: da unos 2048 pasos completos (4096 medios pasos) por vuelta del eje de salida, a costa de un par modesto y una velocidad baja (algunas decenas de RPM como máximo).

03 · Conexiones

Unipolares y bipolares

Un unipolar de 6 cables se puede usar como bipolar ignorando las tomas centrales. Para identificar los cables de un bipolar sin etiquetas, se mide con el tester la resistencia entre pares: dos cables que dan unos pocos ohmios pertenecen a la misma bobina; entre bobinas distintas no hay continuidad. Otra comprobación es girar el eje con la mano mientras se cortocircuitan dos cables: si se siente un freno, son de la misma bobina.

04 · Los estados

Secuencias de paso

Un motor de dos bobinas (A y B) se puede energizar en cuatro «polaridades»: A, B, Ā y B̄ (Ā es la bobina A con la corriente en sentido inverso; en un unipolar, la otra mitad de la bobina). La secuencia de estados determina cómo avanza el rotor. Hay tres modos básicos:

El paso completo con dos bobinas es el modo estándar, porque da el mayor par. El medio paso duplica la resolución a cambio de un par que fluctúa entre pasos. Recorrer la secuencia hacia adelante hace girar en un sentido, y hacia atrás, en el otro; saltar un estado, o invertir el orden de dos conexiones, produce vibración o giro en falso. En un motor unipolar con un ULN2003, el programa escribe esos cuatro bits directamente; con un bipolar y un driver A4988, el driver genera la secuencia y el programa solo envía pulsos.

// Unipolar 28BYJ-48 con ULN2003: IN1..IN4 en los pines 8 a 11.
const uint8_t PINES[4] = {8, 9, 10, 11};
const uint8_t MEDIO_PASO[8] = {0b0001, 0b0011, 0b0010, 0b0110, 0b0100, 0b1100, 0b1000, 0b1001};
int8_t indice = 0;

void darPaso(int8_t sentido) {                        // +1 o -1
    indice = (indice + sentido + 8) % 8;
    for (uint8_t i = 0; i < 4; i++) digitalWrite(PINES[i], (MEDIO_PASO[indice] >> i) & 1);
}

void soltar() { for (uint8_t i = 0; i < 4; i++) digitalWrite(PINES[i], LOW); }   // sin corriente: no sostiene, no se calienta

05 · Pasos intermedios

Microstepping y drivers

Los drivers modernos no se limitan a encender y apagar bobinas: reparten la corriente entre las dos con valores intermedios (aproximadamente senoidales), y el rotor se detiene en posiciones intermedias entre dos pasos completos. Es el microstepping: con 1/16 de paso, un motor de 200 pasos tiene 3200 micropasos por vuelta, de 0,1125° cada uno. Las ventajas son una marcha más suave (menos vibración y ruido, porque los pasos de 1,8° se perciben como golpes) y más resolución nominal.

Una advertencia: la resolución nominal no es precisión. El par que mueve al rotor entre dos micropasos consecutivos es muy pequeño; con cualquier carga o fricción el rotor no se detiene en cada micropaso, y la exactitud de posición sigue siendo del orden de una fracción de paso completo (típicamente un ±5 % de 1,8°, unos 0,09°). El microstepping mejora la suavidad más de lo que mejora la exactitud.

Los drivers A4988 y DRV8825

Son pequeñas placas con un puente H doble y un controlador de microstepping. Con solo dos señales de control, el programa mueve el motor:

• STEP: cada flanco de subida es un paso (o un micropaso). Requiere un pulso de al menos 1 µs (A4988) o 1,9 µs (DRV8825).
• DIR: el nivel fija el sentido de giro.
• EN (activo en bajo): habilita o deshabilita las salidas. MS1, MS2, MS3: seleccionan el microstepping. SLEEP y RESET: deben estar en alto (a menudo se unen entre sí).
• VMOT / GND: alimentación del motor (8 a 35 V en el A4988; 8,2 a 45 V en el DRV8825), con un capacitor electrolítico de 100 µF o más cerca del driver. VDD / GND: lógica (3 a 5,5 V).
• 1A, 1B, 2A, 2B: las dos bobinas del motor.

Precaución: no conectar ni desconectar el motor con la alimentación encendida, porque el pico inductivo puede destruir el driver; y respetar la polaridad de VMOT.

06 · La cuenta eléctrica

Corriente, tensión y velocidad

Un paso a paso se especifica por la corriente por fase (por ejemplo 1,7 A, con 1,5 Ω y 2,8 mH por bobina; la tensión nominal, 2,55 V en ese caso, es solo R × I). Si se lo alimentara con esa tensión, la corriente subiría muy despacio con la constante τ = L / R = 1,87 ms y no alcanzaría su valor a velocidades altas. Por eso los drivers usan una tensión mucho mayor (12 a 24 V) y un limitador de corriente por troceado (chopper): la corriente sube rápido con la tensión alta y, al llegar al valor configurado, el driver corta y reinyecta, manteniéndola constante.

El tiempo para llegar a 1,7 A en esa bobina: t = −τ ln(1 − I·R/V) es 1,74 ms con 4,2 V, 0,45 ms con 12 V y 0,21 ms con 24 V. Como cada paso necesita que la corriente cambie de bobina en un tiempo comparable, la velocidad máxima crece con la tensión: del orden de 86 RPM con 4,2 V, 336 RPM con 12 V y 715 RPM con 24 V en paso completo (un orden de magnitud, no una especificación).

El límite de corriente se ajusta con un potenciómetro en el driver, midiendo la tensión de referencia V_ref con un tester entre el cursor y masa:

donde R_s es la resistencia sensora de la placa (0,068 Ω en muchos A4988, 0,100 Ω en muchos DRV8825; verificá la tuya, porque cambia entre fabricantes). Para 1,2 A: V_ref ≈ 0,65 V en el A4988 de 0,068 Ω y 0,60 V en el DRV8825 de 0,100 Ω. Se suele regular al 70 a 100 % de la corriente nominal del motor, y se agrega disipador al driver (en 1 A y más, un A4988 sin disipador se sobrecalienta). Corriente mayor, más par y más calor, tanto en el driver como en el motor.

07 · Los límites del lazo abierto

Torque, rampas y pérdida de pasos

El par de un paso a paso cae con la velocidad, porque la corriente no alcanza a establecerse en cada paso y porque el giro induce una fuerza contraelectromotriz (como en el tema 30). La curva de par contra velocidad tiene la forma de una meseta y una caída; un modelo ilustrativo es T(f) = Tret / (1 + (f / fc)²), donde f_c crece con la tensión. Si el par que pide la carga supera a T(f), el rotor no sigue al campo y pierde pasos: el eje queda detrás de la cuenta del programa.

Tres consecuencias para el programa:

• No arrancar a velocidad alta. Desde parado, el motor solo puede arrancar sin pérdida a una frecuencia baja (la de arranque, pull-in). Hay que acelerar con una rampa: aumentar la frecuencia de pulsos gradualmente hasta la velocidad de crucero, y frenar con otra rampa antes de llegar al destino.
• Dejar margen de par. Se trabaja con un par disponible al menos 20 a 50 % mayor que el de la carga.
• Evitar las resonancias. A ciertas velocidades bajas, el rotor oscila y puede perder pasos; el microstepping y las rampas lo mitigan.

Una rampa trapezoidal con aceleración a (en pasos/s²) hasta la velocidad v: tarda v / a y recorre v² / (2a) pasos. Por ejemplo, para 8000 micropasos/s (150 RPM con 3200 micropasos por vuelta) con a = 20 000 micropasos/s²: 0,4 s y 1600 micropasos. Para dar 10 vueltas (32 000 micropasos): 0,4 s acelerando, 0,4 s frenando y 3,6 s a velocidad de crucero, en total 4,4 s. Sin rampa, la única forma segura es una velocidad constante baja (por ejemplo 2000 micropasos/s): 16 s.

Como no hay sensor, la posición se pierde al apagar y puede degradarse por pasos perdidos. Por eso se hace homing: se mueve el eje lentamente hasta un final de carrera (tema 7) y se define ahí la posición cero. El taller del tema 34 lo desarrolla.

08 · El lado del programa

Generar los pulsos

La frecuencia de pulsos fija la velocidad: RPM = fSTEP × 60 / (pasos por vuelta × micropasos). Con 200 pasos y 1/16, un giro por segundo exige 3200 Hz; 600 RPM, 32 kHz. Esa frecuencia se puede generar de distintas formas:

• digitalWrite y delayMicroseconds: sencillo pero bloquea el programa durante cada movimiento. Sirve en pruebas.
• Temporización con micros() sin bloqueo (tema 41): el lazo principal emite un pulso cuando vence el intervalo. Llega a unos pocos kHz en un AVR de 16 MHz, y el jitter del lazo afecta la suavidad.
• La librería AccelStepper: maneja rampas, posición objetivo y velocidad máxima (setMaxSpeed, setAcceleration, moveTo, y run() llamado muy seguido). Es la herramienta habitual, con un límite de unos 4 a 8 kHz en un AVR.
• Un timer con interrupción o el hardware dedicado (RMT del ESP32, PIO de un RP2040): para frecuencias de decenas de kHz y pulsos precisos, sin jitter.

const uint8_t PIN_STEP = 3, PIN_DIR = 4, PIN_EN = 5;
const uint32_t PASOS_POR_VUELTA = 200UL * 16;         // 1/16 de paso

int32_t posicion = 0, destino = 0;                    // en micropasos
uint32_t intervaloUs = 312;                           // 3200 Hz = 1 vuelta por segundo
uint32_t tUltimoUs = 0;

void setup() {
    pinMode(PIN_STEP, OUTPUT); pinMode(PIN_DIR, OUTPUT); pinMode(PIN_EN, OUTPUT);
    digitalWrite(PIN_EN, LOW);                        // habilita el driver (activo en bajo)
}

void irA(int32_t micropasos) { destino = micropasos; }

void actualizarPasos() {                              // se llama en cada vuelta del loop
    if (posicion != destino && micros() - tUltimoUs >= intervaloUs) {
        tUltimoUs += intervaloUs;
        bool adelante = destino > posicion;
        digitalWrite(PIN_DIR, adelante ? HIGH : LOW);
        digitalWrite(PIN_STEP, HIGH);
        delayMicroseconds(2);                         // ancho mínimo del pulso
        digitalWrite(PIN_STEP, LOW);
        posicion += adelante ? 1 : -1;
    }
}

Esta versión usa una velocidad constante; para cambiar intervaloUs gradualmente (la rampa) se emplea AccelStepper o la misma lógica del tema 30, aplicada a la frecuencia en lugar de al PWM. Y se debe llevar la cuenta de posicion con un entero de 32 bits: con 3200 micropasos por vuelta, un int16_t se desborda a las 10 vueltas.

09 · Elegir

Comparación y elección

El paso a paso es la mejor opción para posicionar con precisión y repetibilidad a velocidades moderadas y con cargas conocidas. Si la carga es variable o impredecible, o si el sistema no puede permitirse perder la posición, conviene un motor con encoder, o un paso a paso con un encoder que verifique la posición.

10 · Analogía con programación

Secuencias, micropasos, corriente y rampas

Calculemos lo esencial: las propiedades de las tres secuencias, la resolución con micropasos y la frecuencia de pulsos para cada velocidad, el V_ref de cada driver, cuánto tarda la corriente en subir con distintas tensiones, el tiempo de una rampa trapezoidal y, con un modelo ilustrativo de par contra velocidad, hasta qué velocidad llega el motor con distintas tensiones.

import math

# ---- 1. Secuencias de un motor de dos fases (A, B, A', B': A' y B' son las polaridades inversas) ----
SECUENCIAS = {"onda": ["1000", "0100", "0010", "0001"],
              "paso completo": ["1100", "0110", "0011", "1001"],
              "medio paso": ["1000", "1100", "0100", "0110", "0010", "0011", "0001", "1001"]}
print("modo           estados  bobinas activas  bits que cambian  pasos/vuelta (motor de 200)")
for nombre, seq in SECUENCIAS.items():
    activas = sorted({s.count("1") for s in seq})
    cambian = sorted({sum(a != b for a, b in zip(seq[i], seq[(i + 1) % len(seq)])) for i in range(len(seq))})
    pasos = 200 * (2 if nombre == "medio paso" else 1)
    print(f"{nombre:13s}  {len(seq):7d}  {str(activas):15s}  {str(cambian):16s}  {pasos}")

# ---- 2. Micropasos y frecuencia de pulsos ----
print()
print("micropaso  micropasos/vuelta  grados por micropaso")
for ms in (1, 2, 4, 8, 16, 32):
    print(f"1/{ms:<2d}  {200 * ms:16d}  {1.8 / ms:18.4f}")
print("frecuencia de STEP con 1/16 (3200 micropasos por vuelta):")
for rpm in (30, 150, 600):
    f = rpm / 60 * 3200
    print(f"  {rpm:4d} RPM -> {f:7.0f} Hz (período {1e6 / f:6.1f} µs)")

# ---- 3. Límite de corriente para 1,2 A ----
print()
print(f"A4988 (Rs 0,068 Ω): Vref = {1.2 * 8 * 0.068:.3f} V; DRV8825 (Rs 0,100 Ω): Vref = {1.2 * 5 * 0.100:.3f} V")

# ---- 4. Subida de corriente en una bobina de 1,5 Ω y 2,8 mH hasta 1,7 A ----
L, R, I = 0.0028, 1.5, 1.7
tau = L / R
print(f"τ = L/R = {tau * 1000:.2f} ms")
for v in (4.2, 12, 24):
    t = -tau * math.log(1 - I * R / v)
    f = 1 / (2 * t)                                          # orden de magnitud de la frecuencia de paso máxima
    print(f"  {v:4.1f} V: {t * 1000:.3f} ms para llegar a {I} A -> ~{f:5.0f} pasos/s (~{f / 200 * 60:3.0f} RPM)")

# ---- 5. Rampa trapezoidal: 10 vueltas con 1/16 ----
v, a, n = 8000, 20000, 200 * 16 * 10                        # micropasos/s, micropasos/s², micropasos
t_acel, d_acel = v / a, v * v / (2 * a)
crucero = n - 2 * d_acel
total = 2 * t_acel + crucero / v
print()
print(f"Rampa a {v} micropasos/s con {a} micropasos/s²: {t_acel:.3f} s y {d_acel:.0f} micropasos")
print(f"{n} micropasos: crucero {crucero:.0f} micropasos en {crucero / v:.2f} s; total {total:.2f} s")
print(f"A velocidad constante segura de 2000 micropasos/s: {n / 2000:.1f} s")

# ---- 6. Modelo ilustrativo de par contra velocidad: T(f) = Tret / (1 + (f/fc)²), fc = 100·V ----
T_RET, CARGA = 0.4, 0.15
print()
print("tensión   fc      T a 2000 Hz   f máxima con margen 1,2   RPM (paso completo)   f de arranque sin rampa")
for volt in (12, 24, 36):
    fc = 100 * volt
    par = T_RET / (1 + (2000 / fc) ** 2)
    f_max = fc * math.sqrt(T_RET / (1.2 * CARGA) - 1)
    f_arr = 0.2 * fc * (1 - CARGA / T_RET)
    print(f"{volt:4d} V  {fc:5d} Hz  {par:8.3f} N·m  {f_max:14.0f} Hz  {f_max / 200 * 60:14.0f}  {f_arr:14.0f} Hz")

Resultado: la secuencia de onda tiene 4 estados con 1 bobina activa (2 bits cambian por paso); el paso completo, 4 estados con 2 bobinas; el medio paso, 8 estados que alternan 1 y 2 bobinas y cambian 1 bit por paso (400 pasos por vuelta). Con 1/16 hay 3200 micropasos por vuelta (0,1125° cada uno) y 150 RPM exigen 8000 Hz (período de 125 µs); 600 RPM, 32 000 Hz. Para 1,2 A: V_ref de 0,653 V en el A4988 y 0,600 V en el DRV8825. La bobina de 1,5 Ω y 2,8 mH (τ = 1,87 ms) llega a 1,7 A en 1,744 ms con 4,2 V, 0,446 ms con 12 V y 0,210 ms con 24 V (unos 86, 336 y 715 RPM). La rampa a 8000 micropasos/s con 20 000 micropasos/s² tarda 0,400 s y recorre 1600; diez vueltas llevan 4,40 s con rampa frente a 16 s a la velocidad segura sin rampa. Con el modelo de par, la velocidad máxima con 1,2 de margen sobre 0,15 N·m es de 1327 Hz (398 RPM) con 12 V, 2653 Hz (796 RPM) con 24 V y 3980 Hz (1194 RPM) con 36 V; sin rampa solo se puede arrancar a 150, 300 y 450 Hz.

11 · Exploración interactiva

Secuencias, drivers y curva de par

El primer instrumento recorre la secuencia de un motor de dos fases, paso a paso. El segundo calcula micropasos, frecuencia de STEP y V_ref de un driver. El tercero dibuja una curva de par contra velocidad (modelo ilustrativo, no de un motor real) y dice si el motor pierde pasos para una carga, una tensión y una frecuencia, con rampa o sin ella.

Recorrido guiado

1. Con «Paso completo», avanzá cuatro pasos: el estado recorre 1100 → 0110 → 0011 → 1001 → 1100 y el ángulo suma 1,8° por paso; después de 200 pasos, una vuelta.
2. Pasá a «Medio paso»: 8 estados que alternan una y dos bobinas; cada paso mueve 0,9°. Con «Onda» hay una sola bobina activa: menos par.
3. En el instrumento 2, 150 RPM con 1/16: 3200 micropasos por vuelta y 8000 Hz (período de 125 µs). Subí a 600 RPM: 32 kHz, más de lo que genera un AVR con digitalWrite; hace falta un timer.
4. Pasá a 1/32 con el A4988: la opción no existe en ese driver. Con el DRV8825 sí, y la frecuencia se duplica.
5. Regulá 1,2 A: V_ref 0,65 V (A4988) y 0,60 V (DRV8825). Con 1,5 A el aviso indica que hace falta disipador; con 2,2 A el A4988 supera su máximo de 2 A.
6. En el instrumento 3, 24 V, carga 0,15 N·m y 1500 Hz: el motor entrega 0,29 N·m, un margen de ~1,9: sin problemas. Subí la frecuencia a 3000 Hz: el margen cae a 1,04, por debajo del 1,2 recomendado (la frecuencia máxima con rampa es 2653 Hz); a 4000 Hz el par disponible ya es menor que la carga y el motor pierde pasos.
7. Desmarcá «Acelerar con rampa»: a 1500 Hz el motor no puede arrancar directamente (el límite de arranque es de 300 Hz) y pierde pasos aun con par de sobra. Bajá la tensión a 12 V: la frecuencia máxima cae a 1327 Hz.

12 · Método de trabajo

Cómo integrar un paso a paso

1. Identificá el motor: corriente por fase, resistencia, inductancia, par de retención y tipo (unipolar o bipolar).
2. Calculá la carga de par con margen del 20 al 50 %, incluyendo la aceleración.
3. Elegí el driver (A4988, DRV8825 u otro) según corriente, tensión y microstepping.
4. Alimentá con la tensión más alta que soporte el driver (12 a 24 V típico), con un capacitor de 100 µF o más en VMOT.
5. Regulá el V_ref para la corriente deseada y agregá un disipador.
6. Calculá la frecuencia de STEP y elegí cómo generarla (AccelStepper, timer, hardware).
7. Usá rampas de aceleración y una velocidad máxima que deje margen de par.
8. Prevé el homing con un final de carrera y deshabilitá el motor cuando no haga falta mantener la posición.

Si el motor vibra pero no gira, revisá el cableado de las bobinas (pares cruzados) o la corriente; si pierde pasos, falta rampa, par o tensión; si se calienta mucho, bajá la corriente o deshabilitalo en reposo; si el driver se quema, probablemente se conectó el motor con la alimentación encendida o falta el capacitor en VMOT.

13 · Comprensión

Confusiones frecuentes

14 · Práctica guiada

Predecí antes de comprobar

1. Resolución

Un motor de 1,8° por paso se usa con 1/8 de paso. ¿Cuántos micropasos por vuelta y qué ángulo por micropaso?

2. Frecuencia de STEP

Con 1/16, ¿qué frecuencia de STEP y qué período se necesitan para 120 RPM?

3. Vref

Para 1 A, ¿qué V_ref corresponde a un A4988 con R_s = 0,068 Ω y a un DRV8825 con R_s = 0,100 Ω?

4. Subida de corriente

Una bobina de 2 Ω y 2 mH se alimenta con 12 V. ¿Cuánto tarda la corriente en llegar a 1,5 A?

5. Rampa

Se acelera de 0 a 4000 micropasos/s con 10 000 micropasos/s². ¿Cuánto tarda y cuántos micropasos recorre?

6. Elegir

Elegí motor y driver para: (a) el eje de una impresora 3D; (b) la aguja de un indicador de tablero; (c) un eje que debe conocer su posición aunque se corte la energía.

15 · Síntesis

Ideas para recordar

¿Listo para el tema 34?

Antes de avanzar, calculá la frecuencia de STEP para 300 RPM con 1/16, explicá por qué un paso a paso se alimenta con una tensión mucho mayor que la nominal y decí qué es y por qué se usa una rampa de aceleración. Si podés justificar las tres respuestas, ya sabés manejar un paso a paso.

En el próximo tema los usamos en un taller de posicionamiento con paso a paso y servo: rampas de aceleración, homing y movimiento coordinado.