Objetivos
Material requerido.
 |
Arduino Uno o compatible y con el firmware para S4A cargado. |
  |
Una Protoboard más cables. |
 |
Motor Shield V1. |
Motor 28BYJ-48 Unipolar |
Un Motor 28BYJ |
Manejando varios motores paso a paso
En la sesión anterior vimos que podíamos manejar un motor paso a paso unipolar como bipolar, mediante un integrado H-Bridge L293D.
Vimos que controlar un motor paso a paso es un pelín más complicado que controlar un motor de corriente continua (O un servo ya que estamos) porque no podemos simplemente dar una señal y esperar que se ponga a girar, si no que debemos controlar el movimiento mediante el control de la excitación de las bobinas (O coils en inglés).
Y como un motor paso a paso debe tener al menos 2 bobinas, necesitamos por tanto 2 H-Bridge, es decir un integrado del tipo L293D completo (Que tiene dos H-Bridges) y un buen número de cables colgando para conectar todo a nuestro Arduino.
Como esto es un auténtico asco y una garantía de errores o de cables cambiados o sueltos, en cuanto necesitas manejar un par de motores paso a paso, y no digamos ya los 5 motores paso a paso de una impresora 3D tipo RepRap, tenemos un lio.
Por ello y como no podía ser de otra manera, siempre hay alguien que ha tenido el problema y nos vende una solución. En este caso vamos a ver cómo manejar motores paso a paso con un viejo conocido nuestro: El Adafruit Motor Shield V1.
En el pasado usamos este shield para manejar cuatro motores CC para el Rover 4×4, ya que incluye dos integrados L293D, pero para mover motores paso a paso necesitamos 2 H-Bridge por cada motor, por lo que solo podemos manejar dos Steppers con él.
- Precisamente por la limitación de H-Bridges en los chips internos, podemos manejar 4 motores CC, o dos motores Stepper, o también 2 motores CC y un Stepper.
Vamos a dedicar esta sesión a ver como manejamos los motores Stepper con este sencillo y accesible Shield, antes de pasar a otros Shields dedicados más complejos
Conectando motores paso a paso al Motor Shield V1
Lo primero que tenéis que recordar es que necesitamos manejar las dos bobinas del motor independientemente, y eso nos lleva a tener que identificar los bornes de las bobinas claramente para conectarlas adecuadamente.
El primer motor paso a paso debe conectarse a M1 y M2, y el segundo motor a M3 M4. Donde M1 y M2 conectan cada una de las bobinas del motor 1. Al otro lado conectamos las bobinas del segundo motor.
Para usar el motor 28BYJ, ya vimos la distribución de conexiones en este esquema de colores:
Tenéis que hacer estas conexiones:
| Motor Shield | Motor | |
|---|---|---|
| M1 | A | 2 Pink |
| B | 4 Orange | |
| M2 | A | 1 Azul |
| B | 3 Yellow | |
| GND | GND | 5 Red |
Fijaros que el Motor Shield tiene entre M1 y M2 una conexion para GND, con lo que podemos conectar directamente el pin correspondiente y manejar el motor como unipolar, o dejarlo al aire y tratarlo como bipolar
En caso de que el motor paso a paso que vayáis a usar sea diferente de este, siempre podéis buscar en Internet el manual de vuestro motor y hacer las conexiones correspondientes.
Programa de control
El programa es muy sencillo ya que la librería de adafruit-Adafruit-Motor-Shield-library-1.0.0-0-g89a0973 se encarga de la parte más molesta, de gestionar los timings y el control de las bobinas.
Para ello tenemos que incluir la librería y definir una instancia de la clase AF_stepper, para nuestro motor, con un par de parámetros:
#include <AFMotor.h> AF_Stepper motor(256, 1); // A la puerta M1 M2
256 son los Steps por vuelta para nuestro motor (Podéis probar diferentes valores y ver lo que pasa) y 1 significa que usamos el motor conectado a M1 M2. SI conectamos un segundo motor a M3 M4, sería el motor 2.
void setup()
{
Serial.begin(9600);
Serial.println("Stepper test!");
motor.setSpeed(50); // 50 rpm
}
En el setup, fijamos la velocidad mediante setSpeed a 50 rpm.
- Os recomiendo que juguéis cambiando la velocidad y vayáis viendo lo que pasa. (¿Quien dijo miedo?)
Para presentar el programa principal, conviene antes que recordemos las diferentes maneras de excitar las bobinas de un motor paso a paso. Recordad que podíamos excitar solo una bobina cada vez (Single Coil), o dos bobinas a la vez (Double Coil), o una mezcla de ambas de forma alternativa para generar medios pasos (Interleve).
- Si queréis repasar esto un poquito podéis volver a la sesión previa donde ya vimos todo esto.
Cada uno de esos métodos tiene ventajas e inconvenientes y es cuestión de decidir cuál usar dependiendo de lo que queramos hacer. Podemos hacer un Pequeño resumen de cada modo:
SINGLE: Solo se excita una bobina cada vez (También se le suele llamar Wave Drive), No suele ser lo más frecuente porque el par es relativamente bajo, pero a cambio el consumo de energía es bajo.
DOUBLE: Se excitan dos bobinas cada vez (También se le llama Full Stepping). Es bastante frecuente si lo que se busca es par motor máximo, el doble que en single coil, pero también el doble de consumo.
INTERLEAVE: Se excitan pares de bobinas, lo que nos permite doble resolución, con un par y consumo intermedios. Naturalmente con el doble de posiciones la velocidad es la mitad.
MICROSTEPPING: En ligar de alimentar las bobinas con todo o nada, usamos tensiones PWM con una ciertas relaciones entre la alimentación de las dos bobinas, con lo que la transición entre pasos es más suave.
Reduce mucho el ruido del motor y la tensión mecánica, mejorando la vida útil del motor, pero a cambio la precisión se reduce y el par también
Entrar en una discusión detallado de estas técnicas sobrepasa con mucho la intención de este humilde tutorial y si tenéis interés, no vais a tener dificultad en bucear en Internet para encontrar sesudas discusiones al respecto.
De momento es suficiente con decir que la librería os permite cambiar sin problemas y sobre la marcha, el tipo de stepping de estos motores:
Así pues, ya podemos presentar el loop:
void loop()
{
Serial.println("Single coil steps");
motor.step(2000, FORWARD, SINGLE);
motor.step(1000, BACKWARD, SINGLE);
delay(1000);
Serial.println("Double coil steps");
motor.step(2000, FORWARD, DOUBLE);
motor.step(1000, BACKWARD, DOUBLE);
delay(1000);
Serial.println("Interleave coil steps");
motor.step(2000, FORWARD, INTERLEAVE);
motor.step(1000, BACKWARD, INTERLEAVE);
delay(1000);
Serial.println("Micrsostep steps");
motor.step(2000, FORWARD, MICROSTEP);
motor.step(1000, BACKWARD, MICROSTEP);
delay(1000);
}
La instrucción motor.step(), recibe el número de pasos a girar el motor, el sentido de giro como FORWARD y BACKWARD, y el método de excitación de las bobinas como SINGLE, DOUBLE, INTERLEAVE o MICROSTEP.
Aquí os dejo un mini video con el resultado:
Manejando más Steppers y de más potencia
El Adafruit motor Shield es un juguete muy simpático que os permitirá por muy poco dinero jugar con los motores y hacer pequeños proyectos que manejen cargas pequeñas.
Pero este Shield se queda pequeño en cuanto haya que poner fuerza encima de la mesa, y para eso Adafruit (Entre otros muchos) diseñó la versión V2 de la que espero hablar en futuras sesiones de modo específico:
Si rebuscáis un poco entre los vendedores encontrareis que hay tantos Shields de control de motores como casi de fabricantes y es conveniente que busquéis uno con un buen soporte de librería para no volveros muy locos al manejarlo.
Y cuando se requiere manejar 4 o 5 motores de paso a paso con una cierta potencia hay diferentes Shields disponibles para ello. Por ejemplo, las impresoras 3D de RepRap, o Prusa, las más comunes, utilizan un shield para 5 motores paso a paso con drivers de una cierta potencia, llamada RAMPS:
La RAMPS es un Shield para Arduino MEGA, que lleva control para 5 motores paso a paso con controladores Pololu. En la imagen superior podeis ver los cinco controladores instalados en el shield y los disipadores de aluminio que lleva cada uno.
En algun momento hablaremos de esta controladora que es muy barata porque se usa para las impresoras 3D y se vende como rosquillas lo que hace que haya disponible un software estándar parametrizable para su control.
Resumen de la sesión