Motor paso a paso con Raspberry PI Pico: cableado 28BYJ-48 y ULN2003 y código MicroPython

Los motores paso a paso pueden transformar la lógica de su código en movimiento en proyectos robóticos. El motor paso a paso 28BYJ-48 (con controlador de motor ULN2003) es el modelo más económico y funciona con un código simple en Rapsberry PI Pico

En este tutorial, le mostraré cómo conectar y usar el 28BYJ-48 y el ULN2003 con Raspberry PI Pico, con código MicroPython.

Tenga en cuenta que, si necesita el código para las placas de computadora Raspberry PI, puede consultar mi tutorial Controlando un motor paso a paso con Raspberry Pi Zero W.

Un motor paso a paso es un motor eléctrico de CC sin escobillas. Su hardware hace posible dividir una rotación completa en varios pasos iguales. En comparación con los motores de CC comunes, son mucho más precisos pero tienen menos velocidad de rotación. Por lo general, encajan bien en aplicaciones para controlar cámaras, brazos robóticos o siempre que necesite realizar rotaciones precisas. Al elegir el motor paso a paso que utilizará para su proyecto, verifique cuidadosamente la fuerza de torsión y la velocidad requeridas (generalmente disponibles en la hoja de datos del fabricante), ya que pueden afectar su resultado final.

Como los motores paso a paso son dispositivos hambrientos de corriente, generalmente se incluye un controlador de motor para administrar la fuente de alimentación y mantenerla aislada de los circuitos del microcontrolador.

El motor paso a paso 28BYJ-48 funciona alimentando una secuencia específica en los pines del controlador ULN2003. Los estados para cada paso de la secuencia son los siguientes:

SEQ0 SEQ1 SEQ2 SEQ3 SEQ4 SEQ5 SEQ6 SEQ7
IN4 1 1 0 0 0 0 0 1
EN 3 0 1 1 1 0 0 0 0
EN 2 0 0 0 1 1 1 0 0
EN 1 0 0 0 0 0 1 1 1

Para mover el paso a paso, primero debe producir la secuencia 1 en los pines, luego la secuencia 2, luego la secuencia 3, y así sucesivamente. Mover el paso a paso en la dirección opuesta se puede lograr simplemente trabajando en la secuencia opuesta (secuencia 0, secuencia 7, secuencia 6, etc.).

En este tutorial, usaré el motor paso a paso 28BYJ-48 y el controlador de motor ULN2003, que generalmente se venden juntos.

Lo que necesitamos

Como de costumbre, sugiero agregar desde ahora a su carrito de compras de comercio electrónico favorito todo el hardware necesario, para que al final pueda evaluar los costos generales y decidir si continúa con el proyecto o los elimina del carrito de compras. Entonces, el hardware será solo:

Consulta precios de hardware en los siguientes enlaces:

Procedimiento paso a paso

Preparar cableado

Organice el cableado de acuerdo con el siguiente diagrama, de acuerdo con el pinout de Raspberry PI Pico:

A continuación encontrará algunas imágenes detalladas de mi laboratorio:

Obtener y comprender mi código picoStepper.py

Ahora descargue el siguiente archivo para usar su motor paso a paso 28BYJ-48 con ULN2003:

Puede cargarlo en su almacenamiento Raspberry PI Pico o ejecutarlo desde su computadora.

Explicaré todas las líneas de código en los siguientes párrafos.

En primer lugar, se importan los módulos necesarios:

from machine import Pin from time import sleep

Luego definimos algunas variables. El primero identifica cuál es el número de GP de Raspberry PI Pico conectado con ULN2003, en orden con IN1, IN2, IN3 e IN4. De acuerdo con mi cableado, uso GP0, GP1, GP2 y GP3, entonces:

motor_GP = [0,1,2,3]

Luego uso un puntero de secuencia. Esta va a ser una variable global para que la función que mueve el motor paso a paso pueda actualizarla en cada paso:

seq_pointer=[0,1,2,3,4,5,6,7]

También uso una matriz «stepper_obj». Esto incluirá los objetos de 4 pines de Raspberry PI Pico, para simplificar el siguiente código:

stepper_obj = []

La última variable enumera todos los pasos de secuencia como una matriz de matriz. Tenga en cuenta que arrSeq[0] es igual a Seq0 de la tabla anterior:

arrSeq = [[0,0,0,1],           [0,0,1,1],           [0,0,1,0],           [0,1,1,0],           [0,1,0,0],           [1,1,0,0],           [1,0,0,0],           [1,0,0,1]]

Antes de entrar en la función/bucle principal, inicializo todos los pines de Raspberry PI Pico para generar y agregar esos objetos (la función Pin() crea un objeto) a mi stepper_obj. Como puede ver, la estructura de la matriz permite configurar los 4 pines Raspberry PI Pico con un bucle de una sola línea. Se advierte al usuario que los pines se inicializarán con un mensaje de shell:

print("Setup pins...") for gp in motor_GP: stepper_obj.append(Pin(gp, Pin.OUT))

La función stepper_move() es donde se gestionan todas las cosas. Requiere una variable de entrada: dirección. Debe ser «+1» o «-1» para tener rotación hacia adelante o hacia atrás.

La declaración «global» hace que esta función pueda editar la variable seq_pointer:

def stepper_move(direction): # direction must be +1 or -1     global seq_pointer

Cuando el código ingresa a esta función, giramos el puntero de secuencia en 1 paso.

Al comienzo de este script, seq_pointer es igual a [0,1,2,3,4,5,6,7]. Ejecutando “seq_pointer[1:]+seq_pointer[:1]” obtendremos un nuevo valor para seq_pointer igual a [1,2,3,4,5,6,7,0]. La siguiente ejecución implementará la misma rotación.

Por otro lado, de seq_pointer = [0,1,2,3,4,5,6,7]ejecutando “seq_pointer[-1:]+seq_pointer[:-1]” obtendremos un nuevo valor para seq_pointer igual a [7,0,1,2,3,4,5,6].

En cada iteración, el primer valor de la matriz seq_pointer será el puntero real que se usará para seleccionar cómo alimentar los pines GP de acuerdo con el mapa arrSeq:

    seq_pointer=seq_pointer[direction:]+seq_pointer[:direction]

Entonces, seq_pointer[0] será nuestro puntero en cada paso. Usado como índice para arraySeq, obtendremos la lista ordenada de valores para establecer en nuestros Pines. Por ejemplo:

  • cuando seq_pointer = [7,0,1,2,3,4,5,6]
  • -> puntero_seq[0] = 7
  • -> arrSeq[seq_pointer[0]]= arrSeq[7] = [1,0,0,1]

Entonces, la siguiente fila calcula la potencia para establecer en cada Raspberry PI Pico Pin y asigna ese valor dentro de un solo ciclo for:

    for a in range(4): stepper_obj[a].value(arrSeq[seq_pointer[0]][a])

Antes de cerrar la función stepper_move(), agregamos un retraso porque una ejecución demasiado rápida resultará en ningún movimiento…:

    sleep(0.001)

Una vez hecho esto, mover el paso a paso 28BYJ-48 hacia adelante se logrará llamando a la función stepper_move() con el parámetro de dirección establecido en 1, como en el siguiente ciclo:

while True:     stepper_move(1)

Si necesita retroceder, solo necesita cambiar «1» en «-1»:

while True:     stepper_move(-1)

Ejecutar el script picoStepper.py

Ejecute este script en su Thonny IDE (F5) y su motor paso a paso comenzará a girar.