Adafruit Motor Shield V2
Material requerido
 |
Arduino Uno o compatible y con el firmware para S4A cargado. |
 |
Un Motor Shield v2 para arduino |
 |
Un Motor paso a paso para arduino |
Esta sesión es poco más que una traducción libre del magnífico documento de Adafruit sobre este Shield y que podéis encontrar aquí, y en el que encontrareis una información mucho más extensa sobre este Shield, de lo que pretendemos en este sencillo tutorial.
Controladoras de motores
Hemos dedicado ya unas cuantas sesiones a hablar del Motor Shield V1, que era una pieza de lo más simpática y accesible y que te permitía iniciarte con los motores de un modo económico sin demasiadas complicaciones.
Con un Shield de unos pocos euros y una librería sencilla puedes manejar 4 motores de continua o dos de paso a paso y además dos servos.
Pero como todo en la vida las ventajas suelen venir a cambio de ciertos compromisos. En este caso el Motor Shield V1, solo es capaz de soportar una carga limitada de un máximo de 0,6 Amperios.
Cunado necesitas cargas superiores ya vimos que existían otros Shields como el Ardumoto, que acepta cargas de hasta 2A lo que no está mal, pero que como en la vida no existe la felicidad completa, tiene el inconveniente de vernos limitados a dos motores de continua o único paso a paso.
Y claro más de uno empezó a preguntarse… ¿Tenemos que elegir entre un Shield excelente y versátil pero poco potente y uno más potente pero limitado?
Y como siempre que unos cuantos empiezan a hacerse este tipo de preguntas hay algún ingeniero avispado (Normalmente varios) que huele el dólar y te ofrece una solución para el problema.
En este caso los chicos de Adafruit, que son los padres del Motor Shield V1, decidieron rediseñarlo, pero con más potencia y manteniendo las prestaciones del Shield original, y al resultado le dieron el ingenioso nombre, quien lo diría, de Motor Shield V2.
Y esta es la tesis de esta pequeña sesión. Presentaros esta pequeña joyita que es el Motor Shield V2, que reproduce las características más interesantes del V1, como el número de motores que puede gobernar a la vez que aumenta la intensidad que puede aceptar para el gobierno de los diferentes motores, y por si alguien quiere más, permite apilar varios Shields V2 para controlar un número mayor de motores.
- En el próxima capitulo veremos cómo, porque requiere una explicación más tranquila de lo que ahora mismo seria posible
Motor Shield V2 de Adafruit
De Nuevo el Motor Shield V2 permite manejar 4 motores de corriente continua o 2 motores de paso a paso, o bien 2 motores de continua y un paso a paso, y además 2 servos adicionales, y lo hace rediseñando de arriba abajo el Shield V1.
En lugar de un chip L293D que ya nos es de lo más familiar, emplea un MOSFET TB6612 driver con una capacidad de 1,2 Amperios por canal y picos de hasta 3 Amperios, y con circuito de protección térmica incluida.
Además incluye un chip generador de PWM propio, con lo que libera nuestro Arduino de esta tarea y todo el conjunto se controla mediante el bus I2C.
Otra caracteristica nueva, muy de agradecer es que además permite apilar los Shield uno encima de otro hasta 32, lo que le da la capacidad de controlar un disparatado número de motores, pero que por ellos no quede, y por ultimo además de permitir separar la alimentación de motores y servos de la de nuestro Arduino, incluye un área de prototipos para soldar directamente lo que se nos ocurra sin necesidad de otros Shields.
Aquí tenéis la distribución del Shield V2:
Recordad que siempre es buena idea separar la alimentación de vuestros motores de la de Arduino para evitar cosas raras, pero especialmente si vuestros motores usan una tensión diferente de 5V.
- No os preocupéis por cual es el positivo y el negativo. No tiene importancia, pero sí que importa que todos los conectéis del mismo modo, más que nada, para que cuando quieras avanzar, todas las ruedas lo hagan en la misma dirección.
- Si los conectáis al atolondradamente cuando deis la orden de avanzar el espectáculo será un tanto caótico, fijo.
Para alimentar vuestros motores con una fuente externa, retirad el jumper de alimentación común y usad los bornes externos de alimentación de motores, veréis que se ilumina un pequeño LED azul para indicaros que hay tensión en la entrada.
Controlando Motores CC con el nuevo Shield
Antes de nada, como el Motor Shield V2 es un rediseño del original con diferentes componentes hay que utilizar una librería diferente de la que vimos con el Shield V1: Adafruit_Motor_Shield_V2_Library-master
Una vez descargada, instaladla por el procedimiento habitual que ya tenéis dominado y veamos cómo se usa la nueva librería, mediante C++
Para empezar hay que incluir algunas llamadas a librerías:
#include <Wire.h> #include <Adafruit_MotorShield.h> #include "utility/Adafruit_MS_PWMServoDriver.h"
Ya hemos comentado que este Shield se controla mediante I2C para poder gobernar mayor número de motores, pero de eso se encarga la librería, así que no os preocupéis.
Ahoratenemos que crear una instancia por cada motor que vayamos a manejar. Como esto solo es un ejemplo de uso y soy un vago irreductible, solo voy a conectar un motor y de ese modo espero que el ejemplo mínimo sea lo más didáctico posible.
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
Hemos creado con esto una instancia de motor, pero ahora debemos indicar a la librería el tipo del mismo, porque permite varios tipos, y es la librería la que va a hacer el control final:
Adafruit_DCMotor *myMotor = AFMS.getMotor(1);
Lo que solo significa que AFMS va devolver un puntero a un motor de tipo DC, y por cierto el 1 entre paréntesis, significa que lo hemos conectado a las bornes del M1. El resto ya no tiene dificultad.
void setup()
{ AFMS.begin(); // create with the default frequency 1.6KHz
myMotor->setSpeed(150);
myMotor->run(FORWARD);
myMotor->run(RELEASE);
}
Simplemente inicializamos el control del motor con el begin() muy al estilo de como lo hacemos con la puerta serie y después fijamos la velocidad consetSpeed, al que le pasamos un valor entre 0 y 255 para indicar la velocidad deseada.
- Ojo, si das valores muy bajos probablemente tu motor se parará por completo. Usa un mínimo de 80, pero esto depende de tu motor y de lo eficaz que sea (Y el que yo voy a usar no es de los mejores).
Para controlar el movimiento del motor usamos las keyword FORWARD (Adelante), REVERSE (Atrás) y RELEASE (Liberar o parar). Veamos un pequeño ejemplo de uso de un motor CC:
void loop()
{ uint8_t i;
myMotor->run(FORWARD);
for (i=0; i<255; i++)
{ myMotor->setSpeed(i);
delay(10);
}
for (i=255; i!=0; i--)
{ myMotor->setSpeed(i);
delay(10);
}
myMotor->run(BACKWARD);
for (i=0; i<255; i++)
{ myMotor->setSpeed(i);
delay(10);
}
for (i=255; i!=0; i--)
{ myMotor->setSpeed(i);
delay(10);
}
myMotor->run(RELEASE);
delay(1000);
}
Aquí estamos usando un operador del que no hemos hablado aun, (Y del que no quiero hablar por ahora) que es “->”. No le hagáis mucho caso y usadlo sin más. No muerde aunque parezca raro
Como veis la idea es simplemente fijar la dirección hacia adelante y luego hacia atrás e ir variando la velocidad de giro del motor. EL resultado lo podéis ver en este mini Video:
Controlando un motor paso a paso
Si ya conoces los motores paso a paso, poco voy yo a poder contarte, pero si eres nuevo en el tema, te recomiendo que empieces por la introducción a los Steppers que hicimos en unas sesiones previas y que te vendrán muy bien para coger 4 ideas importantes, antes de meternos en harina en esta sesión.
Esas sesiones eran:
- 97 Motores paso a paso.
- 98 Motores paso a paso: 28BYJ-48.
- 99 Controlando un motor unipolar como bipolar.
- 100 Motor Shield V1 y motores paso a paso.
No es muy distinto controlar un Stepper de un motor CC pero hay pequeñas diferencias que nos conviene tener en cuenta. Para empezar los motores paso a paso pueden tener un número de hilos desde 4 en adelante.
Yo voy a usar un típico motor bipolar para no complicarme la vida. Un NEMA 17, que es un Stepper muy potente y uno de los típicos, de por ejemplo las impresoras 3D, de 4 hilos.
Recordad que necesitamos usar 4 pines para controlar un motor bipolar, y atentos al conectar los hilos, que aquí sí que importa el orden, y si los ponéis al azar el motor hará cosas raras.
Muchas veces no está muy claro el orden en que debe ponerse los hilos, porque además hay fabricantes que los suministran con un conector mono y otros simplemente con los hilos colgando (Para ahorra hasta los céntimos, que la competencia es feroz)
Si no tenéis claro como conectarlos probad a seguir el mismo orden que os fija la salida del motor y haced una prueba con cuidado. En mi caso voy a conectar las dos bobinas de mi motor (Son 4 hilos en total) a los conectores M3 y M4 asegurándoos que dejáis libre el borne rotulado como GND (Que se usaría para Steppers de 5 y 6 hilos)
Os pongo una foto de mi montaje por si os sirve a alguien:
Si vuestro motor paso a paso es de 5 hilos, habrá uno que es el común y lo conectáis a GND. Y si es de 6 hilos basta con unir el punto medio de ambas bobinas y conectadlos directamente al GND
Programa de control
El programa para controlar Steppers es muy similar al de los motores de continua, pero, naturalmente tiene sus propias manías, que veremos enseguida Empezamos con las definiciones previas habituales:
#include <Wire.h> #include <Adafruit_MotorShield.h> #include "utility/Adafruit_MS_PWMServoDriver.h"
Y definir las instancias precisas de cada motor:
Adafruit_MotorShield AFMS = Adafruit_MotorShield(); Adafruit_StepperMotor *myMotor = AFMS.getStepper(200, 2)
En el setup usamos begin para inicalizar el motor y fijamos la velocidad de giro:
void setup()
{ AFMS.begin();
myMotor->setSpeed(10); // 10 rpm
}
Aquí la curiosidad radica en que lo que pasamos la velocidad es el número de revoluciones por minuto que queremos y podemos ir ya al loop:
void loop()
{ Serial.println("Single coil steps");
myMotor->step(100, FORWARD, SINGLE); // Avanza 100 pasos
myMotor->step(100, BACKWARD, SINGLE); // Retrocede 100 pasos
Serial.println("Double coil steps");
myMotor->step(100, FORWARD, DOUBLE);
myMotor->step(100, BACKWARD, DOUBLE);
Serial.println("Interleave coil steps");
myMotor->step(100, FORWARD, INTERLEAVE);
myMotor->step(100, BACKWARD, INTERLEAVE);
Serial.println("Microstep steps");
myMotor->step(50, FORWARD, MICROSTEP);
myMotor->step(50, BACKWARD, MICROSTEP);
}
La librería nos permite manejar las bobinas del motor de los diferentes modos posibles y que ya vimos en sesiones previas (Y por eso si no entiendes nada, es buen momento para que las eches una ojeadilla)
Aquí va un mini video con el resultado de este programa y un motor Nema 17:
Como no quisiera ponerme aún más pesado de lo habitual y en atención a nuestros sufridos lectores, dejaremos para la próxima sesión como mover servos con este Shield y también daremos un repaso a cómo usar varios Shields apilados para manejar más motores de los que un único Motor Shield V2 puede abarcar.
Resumen de la sesión