Motor paso a paso 28BYJ-48: todo lo que debes saber

28byj-48 motor paso a paso

El 28BYJ-48 es un motor paso a paso unipolar de bajo coste y gran precisión, ideal para proyectos de electrónica, para impresoras 3D, máquinas CNC, y robótica. Su tamaño compacto, bajo consumo y facilidad de uso lo convierten en una opción popular para aficionados y profesionales de la electrónica.

Además, junto a este motor, también se suele vender un módulo con ULN2003, para su control. De esta forma, tenemos todo lo necesario para poder utilizar este sistema de forma completa, utilizando un microcontrolador o una placa Arduino o similares.

¿Qué es el motor paso a paso 28BYJ-48?

motor eléctrico interior: estátor-rotor

Un motor paso a paso es un tipo de motor eléctrico que se mueve en pequeños pasos angulares discretos, en lugar de una rotación continua. Funciona utilizando un conjunto de electroimanes que se activan en una secuencia específica. Al activar diferentes electroimanes, se crea un campo magnético que atrae el rotor del motor, haciendo que gire un paso a la vez. La cantidad de pasos por revolución y la precisión del movimiento dependen del diseño específico del motor y de la secuencia de control utilizada.

Dentro de los motores paso a paso tenemos dos tipos:

  • Unipolares: tienen un solo conjunto de bobinas y requieren un controlador especial para invertir la corriente y hacer que el motor gire en ambas direcciones.
  • Bipolares: tienen dos conjuntos de bobinas independientes, lo que les permite girar en ambas direcciones sin necesidad de un controlador especial.

En el caso del 28BYJ-28 es de tipo unipolar, como he comentado anteriormente. Y, dentro de este grupo, se caracteriza por tener las siguientes especificaciones:

  • Paso a paso unipolar: control sencillo con solo 4 cables.
  • Reductor integrado: ofrece alta precisión (0.088° por paso) y par motor (3 N·cm).
  • Bajo consumo: 83 mA (modelo 5V) o 32 mA (modelo 12V).
  • Alimentación: 5V o 12V (según modelo).
  • Precio económico: desde 1.2€ por unidad, o un poco más si incluyen un módulo ULN2003.

En cuanto a las posibles aplicaciones, ya cite antes algunas de ellas, pero aquí te pongo nuevamente algunas ideas para tus proyectos:

  • Control de válvulas hidráulicas y neumáticas.
  • Robots articulados y brazos robóticos.
  • Posicionamiento de sensores.
  • Mesas giratorias para escáneres.
  • Impresoras 3D.
  • Máquinas CNC.

El motor paso a paso no funciona solo, necesita de otro elemento. En este caso, el 28BYJ-48 se controla mediante una placa con un integrado ULN2003, que permite amplificar la corriente de las salidas de Arduino para alimentar las bobinas del motor. Al activar las bobinas en la secuencia correcta, el motor gira paso a paso con gran precisión.

Tipos de secuencias de control y fases

Existen varias secuencias de control para el 28BYJ-48, las más comunes son:

  • Secuencia de onda completa: activa todas las bobinas al mismo tiempo.
  • Secuencia de medio paso: activa dos bobinas adyacentes al mismo tiempo.
  • Secuencia de paso microscópico: activa una bobina a la vez.

Veamos las fases de forma detallada:

  • Secuencia 1-fase: en secuencia de 1-fase encendemos una única bobina cada vez. Llevando esta secuencia de encendido a una tabla, en el pinout del motor habría que generar lo siguiente:
Paso A B A’ B’
1 ON OFF OFF OFF
2 OFF ON OFF OFF
3 OFF OFF ON OFF
4 OFF OFF OFF ON
  • Secuencia 2-fases: encendemos dos bobinas correlativas en cada fase, por lo que el campo magnético generado es mayor (un 41% más) por lo que el motor tiene más par, es decir, obtenemos más fuerza. Como punto negativo, aumentamos el consumo energético al doble. En cuanto a la tabla, sería:
Paso A B A’ B’
1 ON ON OFF OFF
2 OFF ON ON OFF
3 OFF OFF ON ON
4 ON OFF OFF ON
  • Secuencia en medio paso (half-step): esta es otra de las etapas que vamos a ver, tú puedes experimentar lo que más te interese. Aquí encendemos alternativamente uno y dos bobinas, consiguiendo una precisión de la mitad del paso. Se utiliza en aplicaciones donde se necesite la mayor precisión, aunque podría haber problemas cuando la aplicación esté al límite de par. Expresando la secuencia en forma de tabla resulta:
Medio-paso A B A’ B’
1 ON OFF OFF OFF
2 ON ON OFF OFF
3 OFF ON OFF OFF
4 OFF ON ON OFF
5 OFF OFF ON OFF
6 OFF OFF ON ON
7 OFF OFF OFF ON
8 ON OFF OFF ON

28BYJ-28 con Arduino

28byj-48 con Arduino

Lo primero es conectar de forma adecuada el módulo y el motor 28byj-48 a nuestra placa de Arduino, para ello, simplemente tienes que realizar las siguientes conexiones:

  • Pin – del ULN2003 a GND de Arduino.
  • Pin + del ULN2003 a Vcc (5v o en otros casos, si es un motor de 12v, habría que usar una fuente de alimentación con ese voltaje) de Arduino.
  • IN1, IN2, IN3 e IN4 del ULN2003 a las entradas digitales D8, D9, D10 y D11 de Arduino.
  • El motor 28byj-48, simplemente conectarlo al puerto que hay en el módulo ULN2003.

Ahora que está conectado, lo siguiente es usar un ejemplo en Arduino IDE, que tú podrás usar tal cual para experimentar o modificarlo a tu gusto. En este ejemplo, todas las tablas de fases están comentadas, como // delante de la línea, ya sabes… Si quieres usar una de ellas, simplemente borra // de delante de las instrucciones.

//Definir los pines
const int motorPin1 = 8;    // 28BYJ48 In1
const int motorPin2 = 9;    // 28BYJ48 In2
const int motorPin3 = 10;   // 28BYJ48 In3
const int motorPin4 = 11;   // 28BYJ48 In4
                   
//Definición de variables
int motorSpeed = 1200;   //Velocidad del motor
int stepCounter = 0;     //Contador de pasos
int stepsPerRev = 4076;  //Pasos para un giro completo

//Tablas de secuencia (descomentar la que necesites)
//Secuencia 1-fase
//const int numSteps = 4;
//const int stepsLookup[4] = { B1000, B0100, B0010, B0001 };

//Secuencia 2-fases
//const int numSteps = 4;
//const int stepsLookup[4] = { B1100, B0110, B0011, B1001 };

//Secuencia media fase
//const int numSteps = 8;
//const int stepsLookup[8] = { B1000, B1100, B0100, B0110, B0010, B0011, B0001, B1001 };

void setup()
{
  //Declarar los pines usados como salida
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop()
{
  for (int i = 0; i < stepsPerRev * 2; i++)
  {
    clockwise();
    delayMicroseconds(motorSpeed);
  }
  for (int i = 0; i < stepsPerRev * 2; i++)
  {
    anticlockwise();
    delayMicroseconds(motorSpeed);
  }
  delay(1000);
}

void clockwise()
{
  stepCounter++;
  if (stepCounter >= numSteps) stepCounter = 0;
  setOutput(stepCounter);
}

void anticlockwise()
{
  stepCounter--;
  if (stepCounter < 0) stepCounter = numSteps - 1;
  setOutput(stepCounter);
}

void setOutput(int step)
{
  digitalWrite(motorPin1, bitRead(stepsLookup[step], 0));
  digitalWrite(motorPin2, bitRead(stepsLookup[step], 1));
  digitalWrite(motorPin3, bitRead(stepsLookup[step], 2));
  digitalWrite(motorPin4, bitRead(stepsLookup[step], 3));
}


Sé el primero en comentar

Deja tu comentario

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

*

*

  1. Responsable de los datos: Miguel Ángel Gatón
  2. Finalidad de los datos: Controlar el SPAM, gestión de comentarios.
  3. Legitimación: Tu consentimiento
  4. Comunicación de los datos: No se comunicarán los datos a terceros salvo por obligación legal.
  5. Almacenamiento de los datos: Base de datos alojada en Occentus Networks (UE)
  6. Derechos: En cualquier momento puedes limitar, recuperar y borrar tu información.