Motor de pasos 28BYJ-48 con driver ULN2003 y Arduino Uno

En este post vamos a conocer a StepperBot. Este robot se programó para moverse moverse en una trayectoria cuadrada en una pequeña mesa, haciendo giros de 90 grados en las esquinas, evitando caerse en el suelo.

El robot no tiene sensores para posicionamiento, orientación, o una forma de detectar los bordes de la mes. El movimiento es controlado sólo por el número de pasos predefinidos en cada dirección, modificable en el scketch. Los motores funcionan aproximadamente 8 voltios de corriente continua y 15 RPM en este ejemplo. Con el tiempo, los pequeños errores se acumulan y el robot se cae de la mesa, pero que por lo general tiene una duración de 10-15 minutos, antes de eso: suficientemente bueno para nosotros!

Comprar motor paso a paso 28BYJ-48  y driver ULN2003 baratos

 

Puede encontrar el motor paso a paso en a un precio increíble en AliExpress. Pincha en el siguiente enlace para acceder.

aliexpress

Comprar motor paso a paso 28BYJ-48 en AliExpress

Qué tiene de especial los motores por pasos/steppers motors

Un motor paso a paso se puede mover en incrementos angulares precisos, conocidos como pasos. A efectos prácticos, un motor paso a paso es muy parecido a un servo: se mueve a una posición predefinida. Los servos ,sin embargo, se limitan generalmente a un rango de 0-180 grado, mientras que un motor paso a paso puede girar de forma continua, similar a un motor ordinario de DC.

La ventaja de un motor paso a paso  es que se puede lograr mucho mayor precisión y control sobre el movimiento. La desventaja de usar steppers es que son un poco más compleja de controlar que los servos y los motores de corriente continua.

motor-paso-a-paso-28byj-para-arduino
Motor de pasos 28BYJ-48 con driver ULN2003

El 28BYJ-48 Hoja de datos del motor de pasos Datasheet

El 28BYJ-48 es un pequeño motor paso a paso de 5 voltios, bastante barato. Estos motores paso a paso son aparentemente ampliamente utilizados para controlar múltiples elementos y son producidos en masa. Debido a la relación de reducción de engranajes de «aproximadamente» 64:1 ofrece un par decente para su tamaño a una velocidad de unos 15 rotaciones por minuto (RPM). Con algunos programas de «trucos» para acelerar de forma gradual y una fuente de alimentación de tensión superior se puede obtener alrededor de 25+ RPM. Estos pequeños steppers se pueden comprar junto con un pequeño controlador del motor de pasos ULN2003 compatible con Arduino. El bajo costo y pequeño tamaño hace que el 28BYJ-48 una opción ideal para pequeñas aplicaciones robóticas y una excelente introducción a stepper control del motor con Arduino. Aquí están las especificaciones detalladas del motor paso a paso 28BYJ-48Hoja de datos del motor de pasos 28BYJ-48 Datasheet.

El motor cuenta con 4 bobinas de alambres que funcionan en una secuencia para girar el eje del motor magnético. Cuando se utiliza el método de paso completo, 2 de las 4 bobinas son activadas ​​en cada paso. La biblioteca de pasos por defecto que viene pre-instalada con el Arduino IDE utiliza este método. La ficha técnica del 28BYH-48 especifica que el método preferido para la conducción de este motor paso a paso es el método de medio paso, en el que primero se activa la bobina 1 solamente, despues la bobina 1 y 2 juntas, despues la bobina 2 solamente y así sucesivamente … Con 4 bobinas, esto significa 8 señales diferentes.

 Tipo de motor  Motor paso a paso unipolar
Tipo de conección  5 Conexión del cable (al controlador del motor)
voltaje  5-12 voltios DC
Frecuencia  100 Hz
Modo de Paso  Modo de medio paso recomendado (8 paso de la señal de control de secuencia)
Ángulo Paso Modo de medio paso: secuencia de señal de control 8 paso (recomendada) 5.625 grados por paso / 64 pasos por una revolución del eje del motor interno de modo de paso completo: secuencia de señal de control de 4 pasos 11.25 grados por paso / 32 pasos por una revolución de la interna eje de motor
Relación de transmisión Fabricante especifica 64: 1. Algunas personas pacientes y diligentes en los foros Arduino han desmontado el tren de engranajes de estos pequeños motores y determinó que la relación de transmisión exacta es de hecho 63,68395: 1. Mis observaciones confirman sus hallazgos. Estos medios que en el modo de medio paso recomendado tendremos: 64 pasos por rotación del motor x 63.684 relación de transmisión = 4076 pasos por vuelta completa (aproximadamente).
Cableado al controlador ULN2003 A (azul), B (rosa), C (Amarillo), D (naranja), E (rojo, de punto medio)
Peso 30g

Cableado del conductor del motor de pasos ULN2003 para Arduino Uno

El controlador del motor de pasos ULN2003 le permite controlar fácilmente el motor paso a paso 28BYJ-48 desde un microcontrolador, como el Arduino Uno. Un lado de la placa tiene un conector de 5 pines, donde se conecta el cable del motor paso a paso , y 4 LEDs para indicar que bobina se alimenta en cada momento. Los dos pines por debajo de las 4 resistencias, es donde se proporciona alimentación al motor paso a paso. Tenga en cuenta que no se recomienda alimentar el motor con la conexión de 5 V de la placa Arduino, ya que el motor puede drenar más corriente que el microcontrolador de la que puede manejar y podría dañarlo. En el centro del tablero tenemos el chip ULN2003. Debajo están las 4 entradas de control que se deben conectar a los cuatro pines digitales de Arduino.

Datos-ULN2003

Conecte el conductor ULN2003 IN1, IN2, IN3 y IN4 al pin digital 3, 4, 5 y 6, respectivamente, en la Arduino Uno. Conecte el cable positivo de una batería de 5-12V a la patilla «+» del conductor ULN2003 y el pin «-» a GND. Asegúrese de que el puente «on / off» está conectado. Si conecta la placa Arduino de una batería diferente, conecte los GND juntos.

Conexión de la placa Arduino Uno con el driver ULN2003 y el motor por pasos 28BYJ-48
Conexión de la placa Arduino Uno con el driver ULN2003 y el motor por pasos 28BYJ-48

Código motores paso a paso Arduino y la librería AccelStepper

La librería de pasos por defecto que viene pre-instalado con el Arduino IDE sólo admite el método de paso completo y ha limitado características. No se ejecuta el motor 28BYJ-48 de manera muy eficiente y conseguir que dos de ellos se muevan al mismo tiempo para un robot de accionamiento diferencial es un poco más difícil. Se encuentran ejemplos de código que utilizan el método de medio paso, sin bibliotecas adicionales. Son códigos funcionaba bien y fáciles de modificar, de modo que pueda ejecutar dos steppers al mismo tiempo. Además, estos códigos de ejemplo utilizan los retrasos para los pasos y causan algunos problemas cuando empezamos a añadir funciones más complejas en el circuito y conectar varios sensores.

Para mejorar el rendimiento disponemos de la biblioteca AccelStepper-1.48. Se ejecutan los motores por pasos 28BYJ-48 steppers de manera muy eficiente y también es compatible con la aceleración (que permite el paso a paso para llegar a una velocidad más alta). A continuación se muestra el código que lentamente se acelerará la 28BYJ-48 en una dirección y luego desacelera hasta detenerse y acelerar en la dirección opuesta. Naturalmente, asegúrese de descargar e instalar la biblioteca AccelStepper primero! AccelStepper-1.48

#include <AccelStepper.h>
#define HALFSTEP 8

// Motor pin definitions
#define motorPin1  3     // IN1 on the ULN2003 driver 1
#define motorPin2  4     // IN2 on the ULN2003 driver 1
#define motorPin3  5     // IN3 on the ULN2003 driver 1
#define motorPin4  6     // IN4 on the ULN2003 driver 1

// Initialize with pin sequence IN1-IN3-IN2-IN4 for using the AccelStepper with 28BYJ-48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);

void setup() {
  stepper1.setMaxSpeed(1000.0);
  stepper1.setAcceleration(100.0);
  stepper1.setSpeed(200);
  stepper1.moveTo(20000);

}//--(end setup )---

void loop() {

  //Change direction when the stepper reaches the target position
  if (stepper1.distanceToGo() == 0) {
    stepper1.moveTo(-stepper1.currentPosition());
  }
  stepper1.run();
}

El código anterior no llevará este motor a su límite. Se puede experimentar con los ajustes de aceleración y de velocidad para ver todas las posibilidades. Tenga en cuenta que para velocidades nigher, es probable que necesite una fuente DC voltaje más alto. Si ha consiguido pogramar su motor paso a paso, aquí está el código que se utiliza en el StepperBot del vídeo de arriba. Se tendrá que ajustar la velocidad, así como las variables «turnSteps» y «lineSteps» en función de sus bases y del tamaño de las ruedas.

#include <AccelStepper.h>
#define HALFSTEP 8

// motor pins
#define motorPin1  3     // IN1 on the ULN2003 driver 1
#define motorPin2  4     // IN2 on the ULN2003 driver 1
#define motorPin3  5     // IN3 on the ULN2003 driver 1
#define motorPin4  6     // IN4 on the ULN2003 driver 1

#define motorPin5  8     // IN1 on the ULN2003 driver 2
#define motorPin6  9     // IN2 on the ULN2003 driver 2
#define motorPin7  10    // IN3 on the ULN2003 driver 2
#define motorPin8  11    // IN4 on the ULN2003 driver 2

// Initialize with pin sequence IN1-IN3-IN2-IN4 for using the AccelStepper with 28BYJ-48
AccelStepper stepper1(HALFSTEP, motorPin1, motorPin3, motorPin2, motorPin4);
AccelStepper stepper2(HALFSTEP, motorPin5, motorPin7, motorPin6, motorPin8);

// variables
int turnSteps = 2100; // number of steps for a 90 degree turn
int lineSteps = -6600; //number of steps to drive straight
int stepperSpeed = 1000; //speed of the stepper (steps per second)
int steps1 = 0; // keep track of the step count for motor 1
int steps2 = 0; // keep track of the step count for motor 2

boolean turn1 = false; //keep track if we are turning or going straight next
boolean turn2 = false; //keep track if we are turning or going straight next

void setup() {
  delay(3000); //sime time to put the robot down after swithing it on

  stepper1.setMaxSpeed(2000.0);
  stepper1.move(1);  // I found this necessary
  stepper1.setSpeed(stepperSpeed);

  stepper2.setMaxSpeed(2000.0);
  stepper2.move(-1);  // I found this necessary
  stepper2.setSpeed(stepperSpeed);

}
void loop() {

  if (steps1 == 0) {
    int target = 0;
    if (turn1 == true) {
      target = turnSteps;
    }

    else {
      target = lineSteps;
    }

    stepper1.move(target);
    stepper1.setSpeed(stepperSpeed);
    turn1 = !turn1;
  }

  if (steps2 == 0) {
    int target = 0;
    if (turn2 == true) {
      target = turnSteps;
    }

    else {
      target = -lineSteps;
    }

    stepper2.move(target);
    stepper2.setSpeed(stepperSpeed);
    turn2 = !turn2;
  }

  steps1 = stepper1.distanceToGo();
  steps2 = stepper2.distanceToGo();

  stepper1.runSpeedToPosition();
  stepper2.runSpeedToPosition();
}

Deja un comentario

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

Este sitio usa Akismet para reducir el spam. Aprende cómo se procesan los datos de tus comentarios.