Control de un Motor Paso a Paso 28BYJ-48 con Arduino y Driver ULN2003 sin Librerías

Este artículo detalla un proyecto de electrónica enfocado en el control de precisión de un motor paso a paso unipolar 28BYJ-48 utilizando una placa Arduino y el módulo controlador ULN2003, con el desafío fundamental de no emplear librerías preexistentes. Exploraremos desde la teoría de funcionamiento del motor hasta la implementación práctica de la secuencia de pasos mediante programación directa.

🔩Funcionamiento

Este proyecto tiene como objetivo diseñar un sistema de control para el motor paso a paso 28BYJ-48 utilizando una placa Arduino y el driver ULN2003, sin recurrir a librerías específicas. Se explorará el funcionamiento del motor, la comunicación con el driver y la programación directa de los pasos necesarios para su operación.

El corazón de este proyecto es el motor paso a paso unipolar 28BYJ-48. Su característica principal es la capacidad de mover su eje en pasos discretos y repetibles, lo que permite un control de posición extremadamente preciso sin la necesidad de sensores de retroalimentación (trabajo en lazo abierto).

El Motor 28BYJ-48: Un Gigante de la Precisión

El 28BYJ-48 es un motor de 5 hilos y 4 fases (o bobinas con un punto común). Es popular por su bajo costo y por incluir una caja reductora interna, usualmente con una relación de 1/64 (aproximadamente). Esto significa que, aunque el motor base tiene un ángulo de paso de 5.625°, la caja reductora multiplica este valor, resultando en un ángulo de paso final mucho más pequeño y, por ende, una mayor resolución y mayor torque a baja velocidad.

• Tensión Nominal: Típicamente 5V.
• Pasos por Rotación: Para el eje de salida, se requieren alrededor de 2048 pasos en modo de paso completo (o el doble, ≈ 4096, en modo de medio paso) para completar una revolución de 360° (debido a la relación de engranajes, la cifra exacta puede variar ligeramente, siendo comúnmente 4076 o 4096 pasos para una vuelta completa).

El driver ULN2003 facilita la conexión del motor con el Arduino, proporcionando la amplificación de corriente necesaria para su funcionamiento. Dispone de cuatro entradas digitales que controlan los cuatro electromagnetos del motor.

Para mover el motor, es necesario activar las bobinas en una secuencia específica. Se pueden usar los siguientes modos:

1. Modo Wave Drive (una bobina activa a la vez)
2. Modo Full Step (dos bobinas activas a la vez, mayor torque)
3. Modo Half Step (mayor resolución de pasos)

MODO WAVE DRIVE(Una bobina activa a la vez)

MODO FULL STEP(dos bobinas activas a la vez, mayor torque)

MODO HALF STEP (mayor resolución de pasos)

Nota: La secuencia de Medio Paso consta de 8 pasos para completar un ciclo eléctrico. El motor gira un paso completo y un medio paso alternativamente. Para girar en sentido contrario, simplemente se invierte el orden de la tabla (de 7 a 0).

El Módulo Driver ULN2003

El motor 28BYJ-48, aunque pequeño, requiere más corriente de la que los pines digitales del Arduino pueden suministrar de manera segura. Aquí es donde entra el módulo ULN2003.

El ULN2003 es un arreglo de siete pares de transistores Darlington de alta ganancia en una configuración de colector abierto. Para nuestro motor, usaremos cuatro de sus canales. El módulo actúa como una interfaz de potencia:

1. Aísla el Arduino del motor.
2. Amplifica la pequeña corriente de señal del Arduino (unos pocos mA) para suministrar la corriente de DC requerida por las bobinas del motor (hasta 500mA por canal).
3. Incluye diodos de protección flyback (o de rueda libre) para absorber el voltaje inverso generado por las bobinas del motor cuando se desenergizan, protegiendo los transistores.

El motor unipolar se conecta al módulo, el cual requiere una fuente de alimentación externa de 5V (se recomienda no usar el 5V del Arduino para el motor debido al consumo de corriente, aunque se puede hacer en pruebas pequeñas). Las entradas lógicas (IN1, IN2, IN3, IN4) del driver se conectan a los pines digitales del Arduino.

_🔨Componentes

🔌Conexiones

• Conexión del driver ULN2003 al Arduino:
  • Conecta el pin IN1 del driver ULN2003 al pin 8 de la placa Arduino.
  • Conecta el pin IN2 del driver ULN2003 al pin 9 de la placa Arduino.
  • Conecta el pin IN3 del driver ULN2003 al pin 10 de la placa Arduino.
  • Conecta el pin IN4 del driver ULN2003 al pin 11 de la placa Arduino.
  • Conecta el pin VCC del driver ULN2003 a 5V de la placa de alimentación.
  • Conecta el pin GND del driver ULN2003 a GND de la placa de alimentación.
• Conexiones del driver ULN2003 al Motor:
  • Conecta el pin AO del Buzze al pin 5 de la placa Arduino.
  • Conecta el pin VCC del Buzzer al pin de 5V de la placa Arduino.
  • Conecta el pin GND del Buzzer al pin GND de la placa Arduino.

0️⃣Código

El programa se basará en el MODO WAVE DRIVE(Una bobina activa a la vez)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

#include <Arduino.h>

void activarBobinas(int , int , int , int );
void girarMotorAntihorario(int);
void girarMotorHorario(int);

const int IN1 = 8; // Pin de entrada 1
const int IN2 = 9; // Pin de entrada 2
const int IN3 = 10; // Pin de entrada 3
const int IN4 = 11; // Pin de entrada 4
const int delayPaso = 5; // Tiempo entre pasos en milisegundos

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(IN4, OUTPUT);
}

void loop() {
  // Gira una vuelta completa en sentido horario
  Serial.println("Girando sentido horario...");
  girarMotorHorario(2048);
  delay(1000); // Pausa de un segundo

  // Gira una vuelta completa en sentido antihorario
  Serial.println("Girando sentido antihorario...");
  girarMotorAntihorario(2048);
  delay(1000); // Pausa de un segundo
}

void girarMotorHorario(int pasos) {
  for (int i = 0; i < pasos; i++) {
    activarBobinas(1, 0, 0, 0);
    delay(delayPaso);
    activarBobinas(0, 1, 0, 0);
    delay(delayPaso);
    activarBobinas(0, 0, 1, 0);
    delay(delayPaso);
    activarBobinas(0, 0, 0, 1);
    delay(delayPaso);
  }
}

void girarMotorAntihorario(int pasos) {
  for (int i = 0; i < pasos; i++) {
    activarBobinas(0, 0, 0, 1);
    delay(delayPaso);
    activarBobinas(0, 0, 1, 0);
    delay(delayPaso);
    activarBobinas(0, 1, 0, 0);
    delay(delayPaso);
    activarBobinas(1, 0, 0, 0);
    delay(delayPaso);
  }
}

void activarBobinas(int a, int b, int c, int d) {
  digitalWrite(IN1, a);
  digitalWrite(IN2, b);
  digitalWrite(IN3, c);
  digitalWrite(IN4, d);
}

🖌️Diseños

🎬Videos

📑Conclusión

El proyecto de control del motor paso a paso 28BYJ-48 utilizando Arduino y el driver ULN2003 sin recurrir a librerías preexistentes ha sido una demostración exitosa de la capacidad de programar a un nivel bajo la lógica de actuación. Al implementar directamente la secuencia de Medio Paso (o Half Step), no solo se logró un control de movimiento preciso y reproducible (alcanzando la alta resolución de approx 4096 pasos por revolución), sino que también se obtuvo una comprensión fundamental de la interacción entre el hardware y el software.

Lecciones Aprendidas y Ventajas de la Implementación Directa

• Dominio del Hardware: La necesidad de definir manualmente la secuencia de excitación (la tabla de 8 pasos) y la gestión del tiempo con delayMicroseconds() nos forzó a entender íntimamente cómo la señal digital del microcontrolador se traduce en un pulso de corriente que energiza las bobinas a través del driver ULN2003. Este driver, con sus transistores Darlington y diodos de protección, se confirmó como el puente de potencia esencial para aislar y proteger el Arduino.
• Eficiencia y Flexibilidad: Eliminar las librerías se traduce en un código más ligero y una ejecución más predecible, sin la sobrecarga inherente a las abstracciones de software. Esto otorga al diseñador la máxima flexibilidad para ajustar la velocidad (delay) y el modo de paso según los requisitos exactos de la aplicación (por ejemplo, optimizando para mayor torque o mayor suavidad de giro).
• Base para Sistemas Avanzados: La técnica de control directo es una habilidad crucial. Proporciona la base necesaria para migrar el control a técnicas más avanzadas, como la gestión por interrupciones o la implementación de algoritmos de microstepping más complejos, esenciales en aplicaciones críticas como la robótica de precisión y las impresoras 3D.

En resumen, este ejercicio confirmó que el control de un motor paso a paso no depende de herramientas prefabricadas, sino de la lógica binaria y temporal programada con detalle, abriendo la puerta a la optimización total del rendimiento del motor.