Conexión del motor paso a paso 28BYJ-48 y el módulo ULN2003 con Arduino

Conexión del motor paso a paso 28BYJ-48 y el módulo ULN2003 con Arduino
Actualizado el 5 agosto, 2021   0 comentarios

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.

Indice de contenidos:

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
Esquema de montaje del motor paso a paso Unipolar 28ByJ-48, modulo driver ULN2003 y Arduino

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.

Secuencia paso a paso. Paso completo simple.
Secuencia paso a paso. Paso completo simple.

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.

Secuencia paso a paso. Paso completo con dos bobinas.
Secuencia paso a paso. Paso completo con dos bobinas.

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.

 Secuencia paso a paso. Medio Paso.
Secuencia paso a paso. Medio Paso.

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.
}
También te puede interesar

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

*
*
*