¿Qué es un motor paso a paso? Giro preciso con el 28BYJ-48 y el ULN2003 en Arduino

Un motor paso a paso divide su giro en pasos pequeños e iguales. Con cada orden gira un ángulo fijo, así que sabes exactamente dónde se ha parado el motor sin necesidad de ningún sensor. Las impresoras 3D, las máquinas CNC, los deslizadores de cámara y las cortinas automáticas usan motores paso a paso por esa precisión. La forma más barata de empezar con Arduino es el motor 28BYJ-48 y la placa controladora ULN2003 que se vende con él.

¿Cómo funciona un motor paso a paso?

Dentro del motor hay varias bobinas colocadas alrededor de un rotor magnético dentado. Al alimentar las bobinas en un orden concreto, el rotor es atraído cada vez hacia la bobina más cercana y avanza un paso. Si la secuencia va rápido, el motor gira rápido; si va despacio, gira despacio; si la inviertes, gira al revés. Como el motor cuenta cada paso, su posición se conoce, pero si se sobrecarga puede saltarse pasos sin darse cuenta.

¿Motor paso a paso, servo o motor DC?

Si basta con ir a un ángulo y quedarse ahí, un servo es más sencillo; tienes los detalles en ¿Qué es un servomotor? Si necesitas giro rápido y continuo, encaja mejor un motor DC con un controlador de motores L298N. Para tareas que exigen dar varias vueltas y conocer la posición, el motor paso a paso no tiene rival.

Características técnicas del 28BYJ-48

Conexión del controlador ULN2003

El conector de 5 cables del motor solo entra en la placa ULN2003 en una posición, así que no puedes equivocarte. Conecta los pines IN1–IN4 de la placa a los pines 8–11 del Arduino, y los terminales + y – a una alimentación de 5 V. El ULN2003 es una matriz de transistores Darlington que amplifica la pequeña señal del pin del Arduino hasta la corriente que necesita la bobina, y los cuatro LED de la placa muestran cómo se activan las bobinas por turnos.

Primer giro con la librería Stepper

La librería Stepper viene con el Arduino IDE y no hay que instalar nada. Lo único que hay que vigilar es el orden de los pines: para el 28BYJ-48 el objeto se declara en el orden 8, 10, 9, 11 (IN1, IN3, IN2, IN4). Si escribes 8, 9, 10, 11, el motor vibra en el sitio en lugar de girar; es el error más común.

1#include <Stepper.h>
2
3const int STEPS_PER_REV = 2048;                  // 28BYJ-48 tam tur / full revolution
4Stepper motor(STEPS_PER_REV, 8, 10, 9, 11);      // sıra: IN1, IN3, IN2, IN4 / order: IN1, IN3, IN2, IN4
5
6void setup() {
7  motor.setSpeed(10);                            // devir/dakika, en fazla ~15 / RPM, max ~15
8}
9
10void loop() {
11  motor.step(STEPS_PER_REV);        // bir yönde tam tur / one full turn
12  delay(1000);
13  motor.step(-STEPS_PER_REV / 2);   // ters yönde yarım tur / half a turn back
14  delay(1000);
15}

Control de posición con un potenciómetro

Si guardas la posición actual del motor en una variable, puedes llevarlo al punto que quieras. El código siguiente convierte la posición del potenciómetro en 0–2048 pasos y el motor va al mismo punto, como si siguiera la rueda. Una tolerancia de 10 pasos ignora las pequeñas oscilaciones. La conexión del potenciómetro está en ¿Qué es un potenciómetro?

1#include <Stepper.h>
2
3Stepper motor(2048, 8, 10, 9, 11);
4int position = 0;                                    // şu anki adım / current step
5
6void setup() {
7  motor.setSpeed(12);
8}
9
10void loop() {
11  int target = map(analogRead(A0), 0, 1023, 0, 2048);  // potansiyometre → hedef / pot → target
12  if (abs(target - position) > 10) {                 // küçük titreşimleri yok say / ignore jitter
13    motor.step(target - position);
14    position = target;
15  }
16}

AccelStepper: aceleración suave sin bloquear el programa

La orden step() de la librería Stepper detiene el programa hasta que termina el giro; mientras tanto no puedes leer botones ni actualizar una pantalla. AccelStepper, que puedes instalar desde el Gestor de librerías, mueve el motor paso a paso en segundo plano y añade aceleración y frenado para evitar arranques bruscos. Para el 28BYJ-48 se usa el modo de medio paso (HALF4WIRE), en el que una vuelta son 4096 pasos:

1#include <AccelStepper.h>
2
3// 28BYJ-48 + ULN2003, yarım adım: tur başına 4096 / half-step: 4096 per turn
4AccelStepper motor(AccelStepper::HALF4WIRE, 8, 10, 9, 11);
5
6void setup() {
7  motor.setMaxSpeed(1000);      // adım/saniye / steps per second
8  motor.setAcceleration(400);   // adım/saniye² / steps per second²
9  motor.moveTo(4096);           // bir tur ileri / one turn forward
10}
11
12void loop() {
13  if (motor.distanceToGo() == 0) {
14    motor.moveTo(-motor.currentPosition());   // geri dön / go back
15  }
16  motor.run();                  // her döngüde çağır, bekletmez / call every loop, non-blocking
17}

Motores más potentes: NEMA 17 y A4988

Para tareas que exigen fuerza, como las impresoras 3D y las máquinas CNC, se usan motores paso a paso bipolares como el NEMA 17. Dan 200 pasos por vuelta (1,8°) y son mucho más fuertes que el 28BYJ-48. Se manejan con controladores como el A4988 o el DRV8825: por cada pulso en STEP el motor avanza un paso, y el pin DIR fija el sentido. El controlador se alimenta con 8–35 V y, con el micropaso, divide cada paso hasta en 16 para un movimiento más suave.

1const int STEP_PIN = 3;
2const int DIR_PIN = 4;
3
4void setup() {
5  pinMode(STEP_PIN, OUTPUT);
6  pinMode(DIR_PIN, OUTPUT);
7}
8
9void loop() {
10  digitalWrite(DIR_PIN, HIGH);          // yön / direction
11  for (int i = 0; i < 200; i++) {       // NEMA 17'de 200 adım = 1 tur / 200 steps = 1 turn
12    digitalWrite(STEP_PIN, HIGH);
13    delayMicroseconds(800);             // küçüldükçe hız artar / smaller = faster
14    digitalWrite(STEP_PIN, LOW);
15    delayMicroseconds(800);
16  }
17  delay(1000);
18}

Motor paso a paso con el ESP32 y la Raspberry Pi Pico

Las entradas del ULN2003 funcionan sin problemas con señales de 3,3 V; aun así, alimenta el motor aparte con 5 V. En el ESP32 la librería AccelStepper funciona tal cual; usa pines fuera de 6–11 y 34–39, por ejemplo GPIO 19, 18, 5 y 17. En la Pico con MicroPython, haces girar el motor escribiendo por turnos la secuencia de medio paso en los cuatro pines:

1from machine import Pin
2import time
3
4pins = [Pin(n, Pin.OUT) for n in (2, 3, 4, 5)]      # IN1–IN4 → GP2–GP5
5SEQ = [[1,0,0,0],[1,1,0,0],[0,1,0,0],[0,1,1,0],
6       [0,0,1,0],[0,0,1,1],[0,0,0,1],[1,0,0,1]]    # yarım adım dizisi / half-step sequence
7
8def rotate(steps, delay_ms=2):
9    direction = 1 if steps > 0 else -1
10    for i in range(abs(steps)):
11        for pin, value in zip(pins, SEQ[(i * direction) % 8]):
12            pin.value(value)
13        time.sleep_ms(delay_ms)
14    for pin in pins:
15        pin.value(0)                                   # bobinleri bırak / release coils
16
17rotate(4096)        # bir tur / one turn (half-step)
18rotate(-1024)       # çeyrek tur geri / quarter turn back

Ideas de proyectos con motores paso a paso

• Reloj analógico: un reloj de mesa cuyas agujas de horas y minutos giran con motores paso a paso.
• Deslizador de cámara: un raíl que mueve la cámara muy despacio para hacer timelapse.
• Comedero automático para peces: un mecanismo que gira su depósito dos veces al día para soltar comida.
• Panel que sigue al sol: orienta un panel hacia la zona más luminosa con dos sensores de luz; para la parte de luz, mira Sensor de luz LDR.
• Plato giratorio: un plato que gira un objeto en ángulos iguales para fotos de producto o escaneo 3D.
• Cortina automática: un motor que abre y cierra la cortina enrollando su cuerda y recuerda su posición.

Errores comunes y cómo solucionarlos

• El motor vibra pero no gira: el orden de pines en la librería Stepper es incorrecto; escribe 8, 10, 9, 11 en lugar de 8, 9, 10, 11.
• El motor se salta pasos: la velocidad es demasiado alta o la carga demasiado pesada; mantén el 28BYJ-48 por debajo de 15 rpm y añade aceleración con AccelStepper.
• El Arduino se reinicia: la alimentación no es suficiente; alimenta el motor con una fuente externa de 5 V y une las tierras.
• El motor se calienta parado: las bobinas siguen alimentadas; pon los cuatro pines en LOW al acabar el movimiento.
• No cuadra el número de vueltas: en paso completo hay 2048 pasos y en medio paso 4096, mientras que un NEMA 17 tiene 200. No confundas el modo ni el motor.
• Con el A4988 el motor no gira: el límite de corriente está demasiado bajo, falta la alimentación del motor o los pines RESET y SLEEP no están unidos.

Un motor paso a paso es la forma más sencilla de decir «gira exactamente esto», y es la base de máquinas como las fresadoras CNC y las impresoras 3D. En la app BlueGrays encontrarás proyectos de uso del 28BYJ-48 y de cómo hacer un servo de 360 grados con un motor paso a paso, paso a paso con esquemas y código.