En este artículo vamos a ver el motor paso a paso 28BYJ-48 con Arduino. Este tipo de motores se utiliza en una gran cantidad de proyectos. Desde impresoras 3D a robots. En este artículo vamos a dar un repaso por los conceptos más importantes del motor paso a paso.
Lo primero que hay que destacar es su precio, lo podemos encontrar por unos 3€. Aunque parezca un componente complejo, resulta sencillo su manejo una vez entendamos cómo funciona. En este artículo voy a centrarme, sobre todo, en cómo debemos programar el motor paso a paso.
Indice de contenidos
Resumen de las características principales del motor paso a paso 28BYJ-48
Ya hablé de este tipo de motores en el podcast 73, te recomiendo que lo escuches. En el hacía un análisis pormenorizado de sus características. A continuación te hago un resumen.
- Motor paso a paso con 5 cables (unipolar 4 bobinas)
- Voltaje de funcionamiento 5V o 12V
- Viene con un circuito integrado
- 4 LEDs que indican cuando se excita una bobina
- 4 resistencias para proteger los LEDs
- Chip ULN2003 que contiene 3 transistores Darlington
- 4 entradas para el controlador, por donde entran los pulsos.
- Jumpers para seleccionar el voltaje de funcionamiento (5V o 12V)
- Hay que puentear el voltaje que no se utiliza
- Cada paso avanza 5,625º
- Caja reductora mediante engranajes 1/64
- Se consigue un paso de 5,625/64 = 0,088º
- Resistencia del bobinado de 50 Ω
- Torque de 34 Newton Metro más o menos 35 gramos por cm
- Frecuencia máxima 100Hz que equivale a un delay de 10 ms
Si quieres profundizar más puedes ver las hojas de características técnicas. Yo he encontrado dos, pero seguro que hay muchas más.
- 1ª Hoja de características técnicas motor paso a paso
- 2ª Hoja de características técnicas motor paso a paso
Motor paso a paso conectado a Arduino
Antes de ver las conexiones, hay que aclarar que este tipo de motores lleva un driver o etapa de potencia. Este componente nos permite suministrar la energía suficiente al motor paso a paso para que se mueva.
Para conectarlo puedes seguir el siguiente esquema eléctrico.
Alimentación con 5V del motor 28BYJ-48
Ten mucho cuidado con los jumpers de alimentación. Para alimentar el motor 28BYJ-48 desde una placa de Arduino, tenemos que puentear las conexiones con un jumper. Estos jumpers nos permiten seleccionar una alimentación de 5V o de 12V. Recuerda que el Arduino UNO trabaja con 5V cómo máximo.
Yo he utilizado un cable hembra. Conectas un extremo al pin 3 y el otro al pin 4. En las siguiente imagen te muestro el resultado final.
Programando el motor paso a paso
Existen dos formas de programar un motor paso a paso. De forma manual y a través de una librería. En este artículo vamos a ver las dos maneras que tenemos de hacerlo Pero antes debemos de conocer cómo funciona este tipo de motores.
Funcionamiento del motor unipolar de 4 bobinas
Debido a que el 28BYJ-48 es un motor unipolar (4 bobinas), lo podemos mover de tres maneras diferentes, movimiento normal, movimiento por ola o paso completo y movimiento de medio paso. Veamos como funcionan cada uno de estos movimientos.
Movimiento normal (par máximo)
Consiste en excitar, administrar corriente, a dos bobinas a la vez en cada paso. Se consigue el máximo par pero también es el máximo consumo.
| PASO | BOBINA A | BOBINA B | BOBINA C | BOBINA D | |
|---|---|---|---|---|---|
| 1 | HIGH | HIGH | LOW | LOW | |
| 2 | LOW | HIGH | HIGH | LOW | |
| 3 | LOW | LOW | HIGH | HIGH | |
| 4 | HIGH | LOW | LOW | HIGH |
Movimiento por ola o paso completo (par menor)
Consiste en excitar una bobina cada vez. El consumo se reduce pero también el par, por lo tanto es un consumo y par moderados.
| PASO | BOBINA A | BOBINA B | BOBINA C | BOBINA D | |
|---|---|---|---|---|---|
| 1 | HIGH | LOW | LOW | LOW | |
| 2 | LOW | HIGH | LOW | LOW | |
| 3 | LOW | LOW | HIGH | LOW | |
| 4 | LOW | LOW | LOW | HIGH |
Movimiento de medio paso
Se consigue un movimiento lento y suave con un par y consumo entre medias de los otros dos movimientos.
| PASO | BOBINA A | BOBINA B | BOBINA C | BOBINA D | |
|---|---|---|---|---|---|
| 1 | HIGH | LOW | LOW | LOW | |
| 2 | HIGH | HIGH | LOW | LOW | |
| 3 | LOW | HIGH | LOW | LOW | |
| 4 | LOW | HIGH | HIGH | LOW | |
| 5 | LOW | LOW | HIGH | LOW | |
| 6 | LOW | LOW | HIGH | HIGH | |
| 7 | LOW | LOW | LOW | HIGH | |
| 8 | HIGH | LOW | LOW | HIGH |
Asignando las bobinas a los pines
Las tablas anteriores nos van a indicar que valor tenemos que tener en las salidas digitales de Arduino. Según el esquema visto anteriormente, tenemos las siguientes conexiones.
| ARDUINO | 8 | 9 | 10 | 11 |
|---|---|---|---|---|
| BOBINA | A | B | C | D |
Programación manual del motor paso a paso
La primera manera de programar nuestro motor es de forma manual. Es un poco artesanal, pero nos permitirá utilizar el movimiento más adecuado en nuestro proyecto. A continuación te dejo el código de los tres tipos de movimiento.
Movimiento normal (par máximo)
|
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 |
/* Creado: Luis del Valle (ldelvalleh@programarfacil.com Movimiento normal motor 28BYJ-48 https://programarfacil.com */ // Definimos los pines donde tenemos conectadas las bobinas #define IN1 8 #define IN2 9 #define IN3 10 #define IN4 11 // Secuencia de pasos (par máximo) int paso [4][4] = { {1, 1, 0, 0}, {0, 1, 1, 0}, {0, 0, 1, 1}, {1, 0, 0, 1} }; void setup() { // Todos los pines en modo salida pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT); } void loop() { for (int i = 0; i < 4; i++) { digitalWrite(IN1, paso[i][0]); digitalWrite(IN2, paso[i][1]); digitalWrite(IN3, paso[i][2]); digitalWrite(IN4, paso[i][3]); delay(10); } } |
Movimiento por ola (par menor)
|
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 |
/* Creado: Luis del Valle (ldelvalleh@programarfacil.com Movimiento por ola motor 28BYJ-48 https://programarfacil.com */ // Definimos los pines donde tenemos conectadas las bobinas #define IN1 8 #define IN2 9 #define IN3 10 #define IN4 11 // Secuencia de pasos (par máximo) int paso [4][4] = { {1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1} }; void setup() { // Todos los pines en modo salida pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT); } void loop() { for (int i = 0; i < 4; i++) { digitalWrite(IN1, paso[i][0]); digitalWrite(IN2, paso[i][1]); digitalWrite(IN3, paso[i][2]); digitalWrite(IN4, paso[i][3]); delay(10); } } |
Movimiento de medio paso
|
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 |
/* Creado: Luis del Valle (ldelvalleh@programarfacil.com Movimiento por ola motor 28BYJ-48 https://programarfacil.com */ // Definimos los pines donde tenemos conectadas las bobinas #define IN1 8 #define IN2 9 #define IN3 10 #define IN4 11 // Secuencia de pasos (par máximo) int paso [8][4] = { {1, 0, 0, 0}, {1, 1, 0, 0}, {0, 1, 0, 0}, {0, 1, 1, 0}, {0, 0, 1, 0}, {0, 0, 1, 1}, {0, 0, 0, 1}, {1, 0, 0, 1} }; void setup() { // Todos los pines en modo salida pinMode(IN1, OUTPUT); pinMode(IN2, OUTPUT); pinMode(IN3, OUTPUT); pinMode(IN4, OUTPUT); } void loop() { for (int i = 0; i < 8; i++) { digitalWrite(IN1, paso[i][0]); digitalWrite(IN2, paso[i][1]); digitalWrite(IN3, paso[i][2]); digitalWrite(IN4, paso[i][3]); delay(10); } } |
Programación del motor paso a paso a través de una librería
La otra manera de programar un motor 28BYJ-48 no es tan artesanal y reduce el código bastante. Se trata de utilizar la librería Steper que viene incluida con el entorno de desarrollo oficial de Arduino. Esta librería nos facilita el uso de este tipo de motores y viene adaptada para motores bipolares.
|
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 |
/* Creado: Luis del Valle (ldelvalleh@programarfacil.com Utilización librería Steper con motor 28BYJ-48 https://programarfacil.com */ // Incluímos la librería para poder utilizarla #include <Stepper.h> // Esto es el número de pasos por revolución #define STEPS 4096 // Número de pasos que queremos que de #define NUMSTEPS 100 // Constructor, pasamos STEPS y los pines donde tengamos conectado el motor Stepper stepper(STEPS, 8, 9, 10, 11); void setup() { // Asignamos la velocidad en RPM (Revoluciones por Minuto) stepper.setSpeed(5); } void loop() { // Movemos el motor un número determinado de pasos stepper.step(NUMSTEPS); delay(2000); } |
Conclusión
Los motores 28BYJ-48 son muy útiles en proyectos de poca envergadura. Si lo que necesitamos es más precisión y fuerza (par motor), debemos irnos a otro tipo de motores. Existen shields para Arduino que nos facilitan la tarea de alimentación de motores paso a paso. Uno de los más conocidos el Adafruit Motor Shield. Un componente excepcional para nuestros proyectos robóticos.
Si te ha gustado el artículo lo puedes compartir, cualquier duda o sugerencia en los comentarios, gracias :)
Gracias a Shutterstock por ceder los derechos de la imagen
