Los motores paso a paso se utilizan ampliamente para controlar la gran cantidad de dispositivos comunes que vemos a diario. Desde persianas, impresoras 3D y reproductores de DVD hasta cámaras de seguridad y máquinas CNC, los motores paso a paso están más cerca de nosotros de lo que crees.
Los motores paso a paso se encuentran entre un motor de CC convencional y un servomotor. Pueden rotar continuamente como motores de CC y posicionarse con precisión (en pasos discretos) como servomotores
Si recién está comenzando con los motores paso a paso, el 28BYJ-48 es una excelente opción. Por lo general, vienen con una placa de controladora basada en ULN2003, lo que los hace muy fáciles de usar. Si quieres entender más en detalle como funciona un motor paso a paso te recomendamos leer este tutorial “Motores paso a paso “stepper”
¿Sabes cómo funcionan estos motores paso a paso?
Los motores paso a paso utilizan una rueda dentada (que tiene 32 dientes) y cuatro electroimanes que forman un anillo alrededor de la rueda.
Cada pulso alto enviado energiza la bobina, atrayendo los dientes más cercanos a la rueda dentada y girando el motor en incrementos de ángulo fijo y preciso conocidos como pasos.
El número de pasos que tiene el motor paso a paso en una rotación de 360 grados es en realidad el número de dientes en el engranaje.
La forma en que pulsa estas bobinas afecta en gran medida el comportamiento del motor.
La secuencia de pulsos determina la dirección de giro del motor.
La frecuencia de los pulsos determina la velocidad del motor.
El número de pulsos determina qué tan lejos girará el motor.
El motor paso a paso 28BYJ-48
El 28BYJ-48 es un motor paso a paso unipolar de 5 hilos que funciona con 5V. Es perfecto para proyectos que requieren un posicionamiento preciso, como abrir y cerrar una rendija de ventilación.
Otra ventaja es que es relativamente preciso en su movimiento y bastante fiable ya que el motor no utiliza escobillas de contacto.
Teniendo en cuenta su tamaño, el motor ofrece un torque decente de 34,3 mN.m a una velocidad de alrededor de 15 RPM. Proporciona un buen par incluso en estado de parada, que se mantiene mientras se suministra energía al motor.
El único inconveniente es que consume una cantidad considerable de energía e incluso consume cuando no se está moviendo.
Asignación de pines
28BYJ-48 es un motor paso a paso de 5 hilos. El pinout es el siguiente:
El 28BYJ-48 consta de dos bobinas y cada bobina tiene una derivación central. Las dos derivaciones centrales están conectadas internamente y salen como el quinto cable (cable rojo).
Un extremo de la bobina y una derivación central juntas forman una fase. Por lo tanto, 28BYJ-48 tiene un total de 4 fases.
El cable rojo siempre se coloca en ALTO. Cuando el otro extreo del cable de conecta a BAJO, la fase se energiza.
El motor paso a paso gira solo cuando las fases se energizan en una secuencia lógica conocida como secuencia de pasos.
Relación de reducción de engranajes
Según la hoja de datos, cuando el motor 28BYJ-48 funciona en modo de paso completo, cada paso corresponde a una rotación de 11,25°. Esto significa que hay 32 pasos por revolución (360°/11,25° = 32).
Aparte de esto, el motor tiene un juego de engranajes reductores de 1/64. (en realidad es 1/63.68395 pero para la mayoría de los propósitos 1/64 es una aproximación lo suficientemente buena)
Esto significa que en realidad hay 2038 pasos (32*63,68395 pasos por revolución = 2037,8864 aproximadamente 2038 pasos).
El consumo de energía
El 28BYJ-48 normalmente consume alrededor de 240 mA.
Dado que el motor consume mucha energía, es mejor alimentarlo directamente desde una fuente de alimentación externa de 5V en lugar de extraer esa energía del Arduino.
Ten en cuenta que el motor consume energía incluso en estado de reposo para mantener su posición.
Especificaciones técnicas
Aquí están las especificaciones completas:
Para obtener más detalles, consulta la siguiente hoja de datos.
La placa de controlador ULN2003
Debido a que el motor paso a paso 28BYJ-48 consume mucha corriente, un microcontrolador como Arduino no puede controlar el motor directamente. Requiere un controlador IC como ULN2003 para controlar el motor, por lo que este motor generalmente viene con una placa de controlador basada en ULN2003.
Conocido por su alta capacidad de corriente y alto voltaje, el controlador ULN2003 ofrece una mayor ganancia de corriente que un solo transistor y permite que la salida de bajo voltaje y baja corriente de un microcontrolador impulse un motor paso a paso de alta corriente.
El ULN2003 consta de una matriz de siete pares de transistores Darlington, cada par capaz de impulsar una carga de hasta 500 mA y 50V. En esta placa se utilizan cuatro de los siete pares.
La placa posee cuatro entradas de control, así como una conexión de alimentación. Adicionalmente posee un conector molex que conecta perfectamente los cables del motor, lo que facilita mucho la conexión del motor a la placa.
La placa tiene cuatro LEDs que muestran actividad en las cuatro líneas de entrada de control (para indicar el estado de avance). Proporcionan una buena vista al pasar los pasos.
La placa también viene con un jumper ON/OFF para deshabilitar la alimentación del motor si fuese necesario.
Configuración de pines de la placa del controlador paso a paso ULN2003
El pinout de la placa del controlador paso a paso ULN2003 es el siguiente:
IN1 – IN4 Los pines se utilizan para impulsar el motor. Conéctalos a los pines de salida digital en el Arduino.
GND es un pin de tierra común.
VDD el pin suministra energía al motor. Conéctalo a una fuente de alimentación externa de 5V. Debido a que el motor consume mucha energía, NUNCA debes usar la potencia de 5V del Arduino para impulsar este motor paso a paso.
Motor Connection Aquí es donde se conecta el motor. El conector solo permite una dirección.
Cableado del motor paso a paso 28BYJ-48 y el controlador ULN2003 a un Arduino
¡Ahora que sabemos todo sobre el motor, podemos comenzar a conectarlo a nuestro Arduino!
Comienza conectando la fuente de alimentación al controlador ULN2003. Usa una fuente de alimentación separada de 5V para alimentar el motor paso a paso.
Advertencia:
Ten en cuenta que es posible alimentar el motor paso a paso directamente desde el Arduino. Sin embargo, esto no se recomienda ya que el motor puede generar ruido eléctrico en tus líneas de alimentación pudiendo dañar el Arduino
Después, conecta la tierra de la fuente de alimentación externa a la tierra del arduino. Esto es muy importante para que podamos establecer la misma referencia de voltaje entre los dos.
Ahora conecta IN1, IN2, IN3, IN4 de la placa del controlador a los pines digitales Arduino 8, 9, 10 y 11 respectivamente.
Finalmente, conecta el cable del motor del motor paso a paso a la placa del controlador.
Cuando hayas terminado, deberías tener algo similar a la ilustración que se muestra a continuación.
Código Arduino: uso de la biblioteca paso a paso incorporada
La biblioteca paso a paso se ocupa de la secuencia de pasos y facilita el control de una amplia variedad de motores paso a paso, tanto unipolares como bipolares.
Aquí está el esquema simple que hace que el motor paso a paso gire lentamente en el sentido de las agujas del reloj y luego rápidamente en el sentido contrario a las agujas del reloj.
//Includes the Arduino Stepper Library
#include <Stepper.h>
// Defines the number of steps per rotation
const int stepsPerRevolution = 2038;
// Creates an instance of stepper class
// Pins entered in sequence IN1-IN3-IN2-IN4 for proper step sequence
Stepper myStepper = Stepper(stepsPerRevolution, 8, 10, 9, 11);
void setup() {
// Nothing to do (Stepper Library sets pins as outputs)
}
void loop() {
// Rotate CW slowly at 5 RPM
myStepper.setSpeed(5);
myStepper.step(stepsPerRevolution);
delay(1000);
// Rotate CCW quickly at 10 RPM
myStepper.setSpeed(10);
myStepper.step(-stepsPerRevolution);
delay(1000);
}
Explicación del código:
El Sketch comienza con la inclusión de la biblioteca Stepper incorporada en el IDE de arduino.
#include <Stepper.h>
A continuación, definimos una constante stepsPerRevolution que contiene el número de ‘pasos’ que dará el motor para completar una revolución. En nuestro caso, es 2038.
const int stepsPerRevolution = 2038;
El motor paso a paso unipolar 28BYJ-48 tiene una secuencia de pasos de IN1-IN3-IN2-IN4. Usaremos esta información para impulsar el motor mediante la creación de una instancia de una biblioteca paso a paso llamada mySteppercon una secuencia de pines de 8, 10, 9, 11.
Asegúrate de hacerlo bien o de lo contrario el motor no funcionará correctamente.
No hay nada que configurar en la función setup() porque la biblioteca Stepper configura internamente los cuatro pines de E/S como salidas.
void setup() {
}
En la función de bucle, usamos la función setSpeed() para establecer la velocidad a la que queremos que se mueva el motor paso a paso y luego usamos la función step() para decirle cuántos pasos debe girar. Pasar un número negativo, la función step() invierte la dirección de giro del motor.
El primer fragmento de código hace que el motor gire muy lentamente en el sentido de las agujas del reloj. Y el otro hace que el motor gire en sentido contrario a las agujas del reloj a una velocidad muy alta.
Ten en cuenta que la función step() es una función de bloqueo. Esto significa que esperará hasta que el motor haya terminado de moverse, para pasar el control a la siguiente línea de su boceto. Por ejemplo, si estableces la velocidad en, digamos, 1 RPM y llamas step(100) a un motor de 100 pasos, esta función tardará un minuto completo en finalizar.
Código Arduino – Uso de la biblioteca AccelStepper
La biblioteca Arduino Stepper está perfectamente bien para aplicaciones simples de un solo motor. Pero cuando desees controlar varios motores paso a paso, necesitará una mejor biblioteca.
Entonces, para nuestro próximo experimento, usaremos una biblioteca avanzada de motores paso a paso llamada biblioteca AccelStepper. Es mucho mejor que la biblioteca Arduino Stepper estándar de varias maneras:
Soporta aceleración y desaceleración.
Es compatible con la conducción de medio paso.
Admite varios motores paso a paso a la vez, con pasos independientes concurrentes en cada paso.
Esta biblioteca no está incluida en el IDE de Arduino, por lo que deberás instalarla primero.
Instalación de la biblioteca
Para instalar la biblioteca, ve a Sketch > Incluir bibliotecas > Administrar bibliotecas… Espera a que el Administrador de bibliotecas descargue el índice de la biblioteca y actualice la lista de bibliotecas instaladas.
Filtra su búsqueda escribiendo ‘accelstepper‘. Haz clic en la primera entrada y luego selecciona Instalar.
Código arduino
Aquí está el sketch simple que acelera el motor paso a paso en una dirección y luego desacelera para detenerse. Una vez que el motor hace una revolución, cambia la dirección de giro. Y sigue haciendo esto una y otra vez.
// Include the AccelStepper Library
#include <AccelStepper.h>
// Define step constant
#define FULLSTEP 4
// Creates an instance
// Pins entered in sequence IN1-IN3-IN2-IN4 for proper step sequence
AccelStepper myStepper(FULLSTEP, 8, 10, 9, 11);
void setup() {
// set the maximum speed, acceleration factor,
// initial speed and the target position
myStepper.setMaxSpeed(1000.0);
myStepper.setAcceleration(50.0);
myStepper.setSpeed(200);
myStepper.moveTo(2038);
}
void loop() {
// Change direction once the motor reaches target position
if (myStepper.distanceToGo() == 0)
myStepper.moveTo(-myStepper.currentPosition());
// Move the motor one step
myStepper.run();
}
Explicación del código:
Comenzamos por incluir la biblioteca AccelStepper recién instalada.
#include <AccelStepper.h>
Ahora, dado que queremos que nuestro motor funcione a pasos completos, definiremos una constante para él. Si desea que el motor funcione a medio paso, debes establecer la constante en 8.
#define FULLSTEP 4
A continuación, creamos una instancia de una biblioteca paso a paso llamada myStepper con una secuencia de pines de 8, 10, 9, 11 (recuerda que la secuencia de pasos para estos motores es IN1-IN3-IN2-IN4).
AccelStepper myStepper(FULLSTEP, 8, 10, 9, 11);
En la función de configuración, primero establecemos la velocidad máxima del motor en 1000, que es lo más rápido que pueden funcionar estos motores. Luego establecemos un factor de aceleración para que el motor agregue aceleración y desaceleración a los movimientos del motor paso a paso.
Luego establecemos la velocidad regular en 200 y establecemos el número de pasos en 2038 (ya que el 28BYJ-48 con su engranaje toma 2038 pasos por revolución).
En la función de bucle, usamos una declaración if para verificar qué tan lejos debe viajar el motor (leyendo la propiedad distanceToGo) hasta que alcance la posición de destino (establecida por moveTo). Una vez que distanceToGo llegue a cero, moveremos el motor en la dirección opuesta cambiando la posición moveTo al negativo de su posición actual.
Ahora, en la parte inferior del bucle, verás que hemos llamado a una función run(). Esta es la función más importante, ya que el paso a paso no se moverá hasta que se ejecute esta función.
void loop() {
// Change direction once the motor reaches target position
if (myStepper.distanceToGo() == 0)
myStepper.moveTo(-myStepper.currentPosition());
// Move the motor one step
myStepper.run();
}
Controla dos motores paso a paso 28BYJ-48 simultáneamente
Para nuestro próximo experimento, agregaremos un segundo conjunto de pasos 28BYJ-48 a nuestro Arduino para impulsar los dos motores simultáneamente.
Cableado
Deja las conexiones que hiciste anteriormente como están y conecta el nuevo paso a paso de la siguiente manera:
Una vez más, utilizaremos un suministro de 5V independiente para suministrar energía a la placa del controlador ULN2003. También asegúrate de conectar todas las GND entre si.
Ahora conecta IN1, IN2, IN3, IN4 de la segunda placa de controlador a los pines digitales Arduino 4, 5, 6 y 7 respectivamente.
La siguiente ilustración muestra el cableado.
Código arduino
Aquí hay un sketch que mueve un motor a pasos completos y el otro a medios pasos con algo de aceleración y desaceleración. Cuando los motores hagan una revolución, su dirección de giro cambiará.
// Include the AccelStepper Library
#include <AccelStepper.h>
// Define step constants
#define FULLSTEP 4
#define HALFSTEP 8
// Creates two instances
// Pins entered in sequence IN1-IN3-IN2-IN4 for proper step sequence
AccelStepper stepper1(HALFSTEP, 8, 10, 9, 11);
AccelStepper stepper2(FULLSTEP, 4, 6, 5, 7);
void setup() {
// set the maximum speed, acceleration factor,
// initial speed and the target position for motor 1
stepper1.setMaxSpeed(1000.0);
stepper1.setAcceleration(50.0);
stepper1.setSpeed(200);
stepper1.moveTo(2038);
// set the same for motor 2
stepper2.setMaxSpeed(1000.0);
stepper2.setAcceleration(50.0);
stepper2.setSpeed(200);
stepper2.moveTo(-2038);
}
void loop() {
// Change direction once the motor reaches target position
if (stepper1.distanceToGo() == 0)
stepper1.moveTo(-stepper1.currentPosition());
if (stepper2.distanceToGo() == 0)
stepper2.moveTo(-stepper2.currentPosition());
// Move the motor one step
stepper1.run();
stepper2.run();
}
Explicación del código:
Comenzamos por incluir la biblioteca AccelStepper.
#include <AccelStepper.h>
Ahora que vamos a accionar un motor a pasos completos y el otro a medios pasos, definiremos dos constantes.
#define FULLSTEP 4
#define HALFSTEP 8
Ahora creamos dos objetos de motor, uno para cada motor. Para configurarlos, usamos nuestras definiciones de pines y definiciones de pasos.
En la función de configuración, primero establecemos la velocidad stepper1 máxima de 1000. Luego establecemos un factor de aceleración para que el motor agregue aceleración y desaceleración a los movimientos del motor paso a paso. Luego establecemos una velocidad regular de 200 y establecemos el número de pasos en 2038.
Haremos exactamente lo mismo para stepper2, excepto que le indicaremos que se mueva a -2038 porque queremos que gire en la dirección opuesta.
void setup() {
// settings for motor 1
stepper1.setMaxSpeed(1000.0);
stepper1.setAcceleration(50.0);
stepper1.setSpeed(200);
stepper1.moveTo(2038);
// settings for motor 2
stepper2.setMaxSpeed(1000.0);
stepper2.setAcceleration(50.0);
stepper2.setSpeed(200);
stepper2.moveTo(-2038);
}
En la función de bucle, usamos dos declaraciones if, una para cada motor, para verificar qué tan lejos deben viajar los motores (leyendo la propiedad distanceToGo) hasta que alcancen su ubicación objetivo (establecida por moveTo). Una vez que distanceToGo llegue a cero, cambiaremos su posición moveTo a la negativa de su posición actual, para que comiencen a moverse en la dirección opuesta.
Finalmente los ponemos en movimiento llamando a la función run().
void loop() {
// Change direction once the motor reaches target position
if (stepper1.distanceToGo() == 0)
stepper1.moveTo(-stepper1.currentPosition());
if (stepper2.distanceToGo() == 0)
stepper2.moveTo(-stepper2.currentPosition());
// Move the motor one step
stepper1.run();
stepper2.run();
}
