Uno de los motores paso a paso más populares es el 28BYJ-48. Tras el artículo que se publicó en este mismo blog, ya deberías conocer todo lo que necesitas sobre este tipo de motores de precisión en los que puedes controlar el giro para que avance lentamente o se quede estático en una posición que quieras. Eso permite que tengan multitud de aplicaciones, desde industriales, hasta robótica, pasando por otras muchas que se te ocurran.
El 28BYJ-48 es un pequeño motor paso a paso de tipo unipolar, y fácil de integrar con Arduino, ya que posee un módulo driver/controlador modelo ULN2003A que se suele incluir junto con él. Todo por un precio muy barato y un tamaño bastante compacto. Esas características también lo hacen ideal para comenzar a practicar con estos dispositivos.
Características del 28BYJ-48
El motor 28BYJ-498 es un motor paso a paso que tiene las siguientes características:
- Tipo: motor paso a paso o stepper unipolar
- Fases: 4 (full step), al haber 4 bobinas en su interior.
- Resistencia: 50 Ω.
- Par de motor: 34 N/m, es decir, si se pasan los Newton por metro a Kg, sería una fuerza equivalente a poner unos 0.34 Kg por cm en su eje. Suficiente para levantar con una polea algo más de un cuarto de kilo.
- Consumo: 55 mA
- Pasos por vuelta: 8 de tipo half step (45º cada uno)
- Reductora integrada: sí, de 1/64, por lo que divide cada paso en 64 más pequeños para mayor precisión, por tanto, llega a los 512 pasos de 0.7º cada uno. O también se puede ver como 256 pasos completos por vuelta (full step).
Los pasos completos o medios, o full y half steps, son los modos en los que puede trabajar. Si lo recuerdas, en el artículo sobre los motores paso a paso dije que el ejemplo del código para Arduino IDE se trabajaba a par pleno.
Para más información, puedes descargar su datasheet, como por ejemplo este. En cuanto al pinout, no te tienes que preocupar demasiado, aunque también puedes ver información en el datasheet del modelo que hayas comprado. Pero este concreto tiene una conexión que te permite conectar todos los cables de una vez, sin preocuparte de polarización ni de donde va cada uno, solo insertar en el controlador y listo…
En cuanto al controlador o driver de motor que incluye este motor 28BYJ-48, tienes el ULN2003A, uno de los más populares y que puedes usar con Arduino de forma muy sencilla. Posee un array de transistores Darlington que soporta hasta 500mA y dispone de pines de conexión para enlazar las 4 bobinas con pines de la placa Arduino numerados del IN1 al IN4, como viste en el artículo del motor paso a paso que cité anteriormente. Desde Arduino, puedes tener cables desde el pin 5v y GND a los dos pines de la placa del módulo controlador marcadas como -+ (5-12v) para alimentar a la placa y el motor stepper.
Por cierto, con los transistores Darlington se permite usar un par de transistores bipolares colocados juntos y que actúan como un transistor único. Eso aumenta mucho la ganancia de la señal en el «transistor» único resultante, y también permite conducir corrientes y tensiones más elevadas.
El par Darlington, como se conoce al «transistor» único formado por la combinación de dos transistores bipolares. Se originó en los Bell Labs en 1952, por Sidney Darlington, de ahí su nombre. Estos transistores se conectan de tal forma que un NPN tiene su colector conectado con el colector del segundo transistor NPN. Mientras que el emisor del primero va a la base del segundo. Es decir, el transistor o par resultante tiene tres conexiones como un único transistor. La base del primer transistor y el colector/emisor del segundo transistor…
Dónde comprar el motor
Los puedes encontrar en multitud de tiendas especializadas en electrónica, y también de forma online como Amazon. Por ejemplo, puedes comprarlos en:
- Por unos 6€ puedes tener un motor 28BYJ-48 con el módulo controlador.
- No products found. y cables para sus conexiones, por si necesitas más de un motor para el robot o proyecto que estés haciendo…
Programación del 28BYJ-48 con Arduino
Antes de nada, deberías tener claros los conceptos de un motor paso a paso, por lo que te recomiendo leer el artículo de Hwlibre sobre estos elementos. Estos motores no están diseñados para ser alimentados de forma continua, sino irlos polarizando en sus distintas fases para que avancen solo los grados que queremos. Para excitar las fases y controlar el giro del eje, tendrás que ir alimentando de forma adecuada cada conexión.
El fabricante recomienda excitar 2 bobinas cada vez.
- Para que funcione al máximo par, con la velocidad más rápida y con el consumo máximo, puedes usar esta tabla:
| 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 |
- Para excitar solo una bobina cada vez, y que funcione en modo wave drive (par a la mitad, pero bajo consumo), podrías usar la siguiente tabla:
| 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 |
- O para avances medios (half steps), puedes usar esto otro para conseguir mayor precisión de giro en pasos más cortos:
| 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 | LOW | LOW | LOW | HIGH |
Y puedes pensar… ¿y ésto qué tiene que ver con la programación de Arduino? Pues la verdad es que mucho, ya que puedes crear una matriz o array con los valores en Arduino IDE para que el motor se mueva a tu antojo, y luego usar dicho array en bucle o cuando lo necesites… Teniendo en cuenta que LOW=0 y HIGH=1, es decir, ausencia de voltaje o voltaje alto, puedes crear las señales que Arduino debe enviar al controlador para accionar el motor. Por ejemplo, para dar pasos medios podrías usar el código para la matriz:
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} };
Es decir, para el código completo del sketch de Arduino IDE, puedes usar este ejemplo básico para ir probando cómo funciona el motor paso a paso 28BYJ-48. Con él, podrás hacer girar el eje del motor una vez tengas todo el esquema conectado adecuadamente. Intenta modificar los valores o alterar el código para la aplicación que necesites en tu caso:
// Definir pines conectados a las bobinas del driver
#define IN1 8
#define IN2 9
#define IN3 10
#define IN4 11
// Secuencia de pasos a par máximo del motor. Realmente es una matriz que representa la tabla del unipolar que he mostrado antes
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 como salida, ya que el motor no enviará señal a Arduino
pinMode(IN1, OUTPUT);
pinMode(IN2, OUTPUT);
pinMode(IN3, OUTPUT);
pinMode(IN4, OUTPUT);
}
// Bucle para hacerlo girar
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);
}
}
Como puedes apreciar, en este caso funcionaría con par máximo activando de dos en dos las bobinas…