Conexión del motor paso a paso 28BYJ-48 y el módulo ULN2003 con Arduino
| Actualizado:
Comentarios: 0
En este artículo veremos el motor paso a paso unipolar 28BYJ-48. Es un motor barato y que podemos utilizar en gran cantidad de proyectos como robots, impresoras 3D o fotocopiadoras. Nos vamos a centrar en la programación del motor con Arduino y su conexión.
Contenido
Los motores paso a paso se caracterizan por efectuar movimientos muy presisos en ángulos pequeños. El motor paso a paso unipolar 28BYJ-48 viene con el módulo ULN2003 que nos va a servir para proporcionar la corriente necesaria al motor.
Esquema de montaje
La conexión entre el módulo controlador y el motor es sencilla ya que tiene un conector con ranuras para guiar la unión entre los dos dispositivos.
El módulo ULN2003 posee cuatro leds que nos indicarán qué bobina está activada en cada momento.
La salida de 5V de la placa Arduino es suficiente para alimentar un motor, pero si el proyecto tiene más elementos conectados, deberíamos usar una fuente de alimentación externa de 5V, porque se puede exceder la corriente que es capaz de suministrar el microcontrolador.
Los pines IN1, IN2, IN3 e IN4 se conectan a cuatro salidas digitales del Arduino:
- Pin 8 -> IN1
- Pin 9 -> IN2
- Pin 10 -> IN3
- Pin 11 -> IN4
Programación
Podemos programar de dos formas el motor paso a paso, manual o con la librería Stepper que nos permite controlar motores paso a paso unipolares o bipolares.
Programación del motor unipolar de 4 bobinas, paso completo simple
Se activa una bobina en cada secuencia, esto hace que el motor tenga un paso más suave pero por el contrario tenga menos torque y menos retención.
Si nos fijamos en el esquema representamos el motor como si fueran 4 bobinas, la flecha nos indica cómo ira girando el rotor. En el paso 1 hacemos pasar la corriente por la bobina A, en el paso 2 la corriente pasa por la bobina B, generando un campo magnético y provocando la rotación del rotor 90º en sentido horario.
En resumen, un ciclo requiere 4 pasos, un giro completo del rotor 8 ciclos y un giro completo del eje exterior 64 vueltas del rotor, por lo que se necesitan 2048 pasos para una revolución.
Nº de pasos para una vuelta = 4 x 8 x 64 = 2048
Con el siguiente código conseguimos una vuelta completa del motor:
int IN1 = 8; // pin digital 8 a IN1
int IN2 = 9; // pin digital 9 a IN2
int IN3 = 10; // pin digital 10 a IN3
int IN4 = 11; // pin digital 11 a IN4
int tiempo = 20; // tiempo entre pasos, minimo 10 ms.
void setup(){
// todos los pines se configuran salida
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop(){
// 512*4 = 2048 pasos para un giro completo
for (int i = 0; i < 512; i++) {
digitalWrite(IN1, HIGH); // paso 1
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
delay(tiempo);
digitalWrite(IN1, LOW); // paso 2
digitalWrite(IN2, HIGH);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
delay(tiempo);
digitalWrite(IN1, LOW); // paso 3
digitalWrite(IN2, LOW);
digitalWrite(IN3, HIGH);
digitalWrite(IN4, LOW);
delay(tiempo);
digitalWrite(IN1, LOW); // paso 4
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, HIGH);
delay(tiempo);
}
// paramos 5 segundos
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
delay(5000);
}Este código resulta bastante largo, para solucionarlo podemos utilizar un array bidimensional para indicar qué bobina es la que se va activar en cada momento.
int IN1 = 8; // pin digital 8 a IN1
int IN2 = 9; // pin digital 9 a IN2
int IN3 = 10; // pin digital 10 a IN3
int IN4 = 11; // pin digital 11 a IN4
int tiempo = 20; // tiempo entre pasos, mínimo 10 ms.
// Array bidimensional con la secuencia de pasos
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 se configuran salida
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop(){
// 512*4 = 2048 pasos
for (int i = 0; i < 512; i++){
// bucle que recorre el array fila a fila
for (int i = 0; i < 4; i++){
// valores que se van a aplicar
digitalWrite(IN1, paso[i][0]);
digitalWrite(IN2, paso[i][1]);
digitalWrite(IN3, paso[i][2]);
digitalWrite(IN4, paso[i][3]);
delay(tiempo);
}
}
// paramos 5 segundos
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
delay(tiempo);
}Como veréis el array bidimensional es {{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, 1}}; si os habéis fijado en la tabla donde se explican qué bobina es la que se activa en cada paso, ¿no os resulta familiar?
Programación del motor unipolar paso completo con dos bobinas (máximo torque)
Es la recomendada por el fabricante ya que permite el máximo torque o fuerza.
Si nos fijamos en el paso 1, se hace pasar la corriente por las bobinas A y B a la misma vez, haciendo que el rotor quede entre ambas bobinas. De esta forma para completar un ciclo se requieren 4 pasos, un giro completo del rotor esta compuesto por 8 ciclos y el giro completo del eje exterior necesita dar 64 vueltas. Exactamente igual que el anterior.
El código para una vuelta completa sería:
int IN1 = 8; // pin digital 8 a IN1
int IN2 = 9; // pin digital 9 a IN2
int IN3 = 10; // pin digital 10 a IN3
int IN4 = 11; // pin digital 11 a IN4
int tiempo = 20; // tiempo entre pasos, mínimo 10 ms.
// Array bidimensional con la secuencia de pasos
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 se configuran salida
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop(){
// 512*4 = 2048 pasos
for (int i = 0; i < 512; i++){
// bucle que recorre el array fila a fila
for (int i = 0; i < 4; i++){
// valores que se van a aplicar
digitalWrite(IN1, paso[i][0]);
digitalWrite(IN2, paso[i][1]);
digitalWrite(IN3, paso[i][2]);
digitalWrite(IN4, paso[i][3]);
delay(tiempo);
}
}
// paramos 5 segundos
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
delay(tiempo);
}Programación del motor unipolar de medio paso
Permite que el motor gire con un ángulo menor obteniendo mayor presición.
En este caso tenemos 8 pasos para completar el ciclo, permite que el rotor gire en un ángulo menor, aumentando la presición. En el paso 1 solamente se activa la bobina A, mientras que en el paso 2 activamos la bobina A y B, lo que provoca el giro de 45 grados.
En este caso un ciclo necesita 8 pasos, el giro completo del rotor 8 ciclos y un giro completo del eje exterior necesita dar 64 vueltas. Para dar una vuelta completa necesita 8 x 8 x 64 = 4096 pasos para una revolución. El código sería:
int IN1 = 8; // pin digital 8 a IN1
int IN2 = 9; // pin digital 9 a IN2
int IN3 = 10; // pin digital 10 a IN3
int IN4 = 11; // pin digital 11 a IN4
int tiempo = 20; // tiempo entre pasos, minimo 10 ms.
// Array bidimensional con la secuencia de pasos
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 se configuran salida
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
void loop(){
// 512*8 = 4096 pasos
for (int i = 0; i < 512; i++){
// bucle que recorre el array fila a fila
for (int i = 0; i < 8; i++){
// valores que se van a aplicar
digitalWrite(IN1, paso[i][0]);
digitalWrite(IN2, paso[i][1]);
digitalWrite(IN3, paso[i][2]);
digitalWrite(IN4, paso[i][3]);
delay(tiempo);
}
}
// paramos 5 segundos
digitalWrite(IN1, LOW);
digitalWrite(IN2, LOW);
digitalWrite(IN3, LOW);
digitalWrite(IN4, LOW);
delay(tiempo);
}Librería Stepper para controlar el motor paso a paso
Es una biblioteca que nos va a permitir controlar los motores paso a paso unipolares o bipolares.
Las funciones que vamos a utilizar:
Stepper(pasos, pin1, pin2, pin3, pin4), crea un nuevo objeto conectado a la placa Arduino. Los parámetros que utiliza son:
-
- pasos-> número de pasos en una revolución del motor
- pin1, pin2, pin3, pin4 -> pines que están conectados al motor.
setSpeed(rpms), configura la velocidad del motor en revoluciones por minuto.
step(pasos), enciende el motor durante un número determinado de pasos.
Código para hacer avanzar el motor:
#include "Stepper.h";
// creamos el objeto motor
Stepper motor(2048, 8, 10, 9, 11);
void setup() {
motor.setSpeed(2);
}
void loop() {
motor.step(200); // cantidad de pasos
delay(2000); // 2 seg.
}Como podéis observar en la cabecera del programa se ha incluido la librería y se crea un objeto llamado motor.
#include "Stepper.h";
Stepper motor(2048, 8, 10, 9, 11);En la función Stepper indicamos el número de pasos de nuestro motor, 2048 para el motor 28BYJ-48, ¿cómo se llega a este número? Lo hemos explicado en el apartado «Programación del motor unipolar paso completo con dos bobinas (máximo torque)». Importante, esta biblioteca solo permite el método de paso completo o máximo torque. Los siguientes parámetros son los pines a los que esta conectado el motor.
¿Por qué en los parámetros de los pines hemos puesto 8, 10, 9, 11? Para que gire en en el sentido contrario de las agujas del reloj, si ponemos la secuencia 8, 9, 10, 11 girará en el sentido horario.
En la función setup configuramos la velocidad en rpm, para nuestro motor los valores pueden ser 1, 2 ó 3:
void setup() {
motor.setSpeed(2);
}En la función loop indicamos el número de pasos que avanzará el motor con la función:
motor.step(200);Para cambiar el sentido de giro, simplemente le indicamos el número de pasos con un número negativo. Por ejemplo:
#include "Stepper.h"
// creamos el objeto motor
Stepper motor(2048, 8, 10, 9, 11);
void setup() {
motor.setSpeed(1);
}
void loop() {
motor.step(200); // cantidad de pasos
delay(2000); // 2 seg.
motor.step(-300); // cantidad de pasos
delay(2000); // 2 seg.
}
