Tiene la capacidad de manejar hasta 4 motores de CC o 2 motores paso a paso y dos servos, pero añade muchas mejoras.
En lugar de un controlador darlington L293D, ahora tenemos los controladores MOSFET TB6612 con capacidad de corriente de 1,2A por canal (puede generar un pico de hasta 3A durante aproximadamente 20 ms a la vez). También tiene caídas de voltaje mucho más bajas en el motor, por lo que obtiene más torque de sus baterías, y también hay diodos de retorno incorporados.
En lugar de usar los pines PWM de Arduino, tenemos un chip controlador PWM totalmente dedicado a bordo. Este chip maneja todos los controles de motor y velocidad sobre I2C. Solo dos pines GPIO (SDA y SCL) más 5v y GND son necesarios para impulsar los múltiples motores, y dado que es I2C, también puede conectar cualquier otro dispositivo I2C a los mismos pines. Esto también lo hace compatible con cualquier Arduino, como el Uno, Leonardo, Due y Mega R3.
Diseño completamente apilable: 5 pines de selección de dirección significa hasta 32 shield apilables: ¡eso son 64 motores paso a paso o 128 motores de CC!
Veamos las especificaciones :
- 2 conexiones para servos de 5V conectados al temporizador dedicado de alta resolución de Arduino.
- 4 puentes H: el chipset TB6612 proporciona 1,2 A por puente (3 A para picos breves de 20 ms) con protección de apagado térmico y diodos internos de protección de contragolpe. Puede hacer funcionar motores de 4,5 V CC a 13,5 V CC.
- Hasta 4 motores de CC bidireccionales con selección de velocidad individual de 8 bits (por lo tanto, aproximadamente 0,5% de resolución)
- Hasta 2 motores paso a paso (unipolar o bipolar) de bobina simple, doble bobina, intercalados o micropasos.
- Botón de reinicio de Arduino en la parte superior
- Puente y bloque de terminales de 2 clavijas con protección de polaridad para conectar alimentación externa, para suministros lógicos / de motor separados.
Instalar la librería Adafruit Motor Shield V2
Para usar el shield en Arduino, debes instalar la biblioteca Adafruit Motorshield v2. Esta biblioteca no es compatible con la biblioteca AF_Motor anterior utilizada para los shield v1. Sin embargo, si tiene un código para el shield anterior, adaptar el código para usar el nuevo shield no es difícil.
Para comenzar a controlar motores, debes instalar la biblioteca Adafruit_Motor_Shield_V2_Library . Está disponible en el administrador de la biblioteca de Arduino, por lo que recomendamos usarlo.
Desde el IDE abre el administrador de la biblioteca y escribe adafruit motor para localizar la biblioteca. Haga clic en Instalar.
También se instalará, alguna que otra librería para que esta funcione, como la librería AccelStepper.
Motor de corriente continua.
La librería incluye algunos ejemplos para que puedas comenzar rápidamente. Podemos comenzar con el ejemplo del motor de CC. Puedes usar cualquier motor de CC que pueda ser alimentado de 6V a 12VDC.
Primero, reinicia el IDE para asegurarse de que la nueva librería esté cargada.
Enchufa el shield en el Arduino y conecta un motor de CC al puerto del motor 1; no importa qué cable vaya a qué bloque de terminales, ya que los motores son bidireccionales. Conéctalo a los dos puertos terminales superiores, no lo conectes al pin del medio (GND).
También debe suministrar 5-12 VCC para alimentar el motor. Hay dos maneras de hacer esto:
- Puedes alimentar Arduino a través del conector de CC del shield e insertar el puente VIN.
- Puede alimentar Arduino a través del conector DC o el puerto USB del arduino. Y Luego alimentar el shield a través del puerto del terminal de alimentación del motor de 5-12 VCC y retirar el puente VIN.
Si el LED verde junto al bloque de terminales de alimentación no se enciende con intensidad, ¡no continúes!
Una vez verificado que el motor está conectado correctamente y que el LED de encendido esté iluminado, podemos cargar nuestro código.
En el IDE, cargue Archivo-> Ejemplos-> Adafruit_MotorShield-> DCMotorTest
Deberías ver y escuchar que el motor de CC se enciende y se mueve hacia adelante y hacia atrás.
Prueba de motor paso a paso.
El escudo puede manejar steppers unipolares (5 hilos y 6 hilos) y bipolares (4 hilos). El código es el mismo para motores unipolares o bipolares, el cableado es ligeramente diferente.
Conecta el shield en el Arduino y conecta un motor paso a paso al puerto 2 del motor; a diferencia de los motores de CC, el orden de los cables sí ‘importa’. Conecta los dos puertos terminales superiores a la bobina n.° 1 y a los dos puertos terminales inferiores a la bobina n.° 2.
- Si tienes un motor bipolar, no lo conectes nada al pin del medio (GND).
- Si estás utilizando un motor unipolar con 5 cables, conecta el cable común a GND.
- Si estás utilizando un motor unipolar con 6 cables, puedes conectar los dos ‘cables de la bobina central’ juntos a GND.
También debes suministrar de 5 a 12 VCC para alimentar el motor.
Igual que para los motres DC hay dos maneras de hacer esto:
- Puedes alimentar Arduino a través del conector de CC del shield e insertar el puente VIN.
- Puede alimentar Arduino a través del conector DC o el puerto USB del arduino. Y Luego alimentar el shield a través del puerto del terminal de alimentación del motor de 5-12 VCC y retirar el puente VIN.
Una vez que haya verificado que el motor está conectado correctamente y que el LED de encendido esté iluminado, podemos cargar nuestro código.
En el IDE, cargue Archivo-> Ejemplos-> Adafruit_MotorShield-> StepperTest
Deberías ver y escuchar que el motor paso a paso se enciende y se mueve hacia adelante y hacia atrás.
Hay cuatro formas de mover un motor paso a paso, con diferentes compensaciones de velocidad, torqué y suavidad. Este código de ejemplo demostrará los cuatro.
Library Reference
clase Adafruit_MotorShield
La clase Adafruit_MotorShield representa un shield de motor y debe crearse una instancia antes de que se pueda utilizar cualquier DCMotor o StepperMotors. Se deberá declarar un objeto tipo Adafruit_MotorShield para cada shield apilado.
Adafruit_MotorShield (uint8_t addr = 0x60);
El constructor tiene un parámetro opcional para especificar la dirección i2c del shield. La dirección predeterminada del constructor (0x60). Si tienes más de un shield, cada shield debe tener una dirección única.
void begin(uint16_t freq = 1600);
Se debe llamar a begin() en setup() para inicializar el shield. Se puede utilizar un parámetro de frecuencia opcional para especificar algo diferente al máximo predeterminado: frecuencia PWM de 1,6 KHz.
Adafruit_DCMotor * getMotor (uint8_t n);
Esta función devuelve uno de los 4 objetos de motor de CC predefinidos controlados por el shield. El parámetro especifica el canal de motor asociado: 1-4.
Adafruit_StepperMotor * getStepper (pasos uint16_t, uint8_t n);
Esta función devuelve uno de los 2 objetos de motor paso a paso predefinidos controlados por el shield. El primer parámetro especifica el número de pasos por revolución. El segundo parámetro especifica el canal paso a paso asociado: 1-2.
clase Adafruit_DCMotor
La clase Adafruit_DCMotor representa un motor de CC conectado al shield. Debe declarar un Adafruit_DCMotor para cada motor.
Adafruit_DCMotor ();
El constructor no acepta argumentos. El objeto de motor generalmente se inicializa asignando un objeto de motor recuperado de la clase del shield como se muestra a continuación:
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
Adafruit_DCMotor *myMotor = AFMS.getMotor(1);
Adafruit_DCMotor *myOtherMotor = AFMS.getMotor(2);
void run(uint8_t);
La función run () controla el estado del motor. El parámetro puede tener uno de 3 valores:
- FORWARD – Gira hacia adelante.
- BACKWARD – Gira en la dirección inversa.
- RELEASE – Detener la rotación.
Ten en cuenta que las direcciones «FORWARD» y «BACKWARD» son arbitrarias. Si no coinciden con la dirección real de Tu vehículo o robot, simplemente cambiA los cables del motor.
También ten en cuenta que «RELEASE» simplemente corta la energía al motor. No aplica ningún frenado.
void setSpeed (uint8_t);
La función setSpeed () controla el nivel de potencia entregado al motor. El parámetro de velocidad es un valor entre 0 y 255.
Ten en cuenta que setSpeed solo controla la potencia entregada al motor. La velocidad real del motor dependerá de varios factores, entre ellos: el motor, la fuente de alimentación y la carga.
clase Adafruit_StepperMotor
La clase Adafruit_StepperMotor representa un motor paso a paso unido al shield. Debes declarar un Adafruit_StepperMotor para cada motor paso a paso.
Adafruit_StepperMotor ();
El constructor no acepta argumentos. El motor paso a paso generalmente se inicializa asignando un objeto paso a paso recuperado del shield como se muestra a continuación:
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
Adafruit_StepperMotor *myMotor = AFMS.getStepper(200, 2);
void step(uint16_t steps, uint8_t dir, uint8_t style = SINGLE);
La función step () controla el movimiento paso a paso.
- El primer parámetro especifica cuántos pasos se deben mover.
- El segundo parámetro especifica la dirección: FORWARD o BACKWARD.
- El último parámetro especifica el estilo de paso: SINGLE, DOUBLE, INTERLEAVED o MICROSTEP
La función step() es sincrónica y no regresa hasta que se completan todos los pasos. Cuando se completa, el motor permanece encendido para aplicar un «par de retención» para mantener la posición.
void setSpeed (uint16_t);
La función setSpeed () controla la velocidad de rotación del motor paso a paso. La velocidad se especifica en RPM.
void release(void);
La función de release () quita toda la energía del motor. Llama a esta función para reducir los requisitos de potencia si no se requiere par de retención para mantener la posición.
Alimentación de motores
Lo primero que importa es saber qué voltaje va a utilizar el motor.
Lo segundo que hay que averiguar es cuánta corriente necesitará el motor. Los chips de controlador de motor que vienen con el kit están diseñados para proporcionar hasta 1.2 A por motor, con una corriente máxima de 3A. Ten en cuenta que una vez que se dirija hacia 2A probablemente debamos colocar un disipador de calor en el controlador del motor; de lo contrario, obtendremos un error térmico, y posiblemente quemando el chip.
No podemos hacer funcionar los motores con una batería de 9 V, ¡ es mejor no perder el tiempo y baterías!
Es recomendable utilizar una batería grande de plomo-ácido o NiMH. También es recomendable configurar dos fuentes de alimentación (fuente dividida), una para Arduino y otra para los motores. ¡El 99% de los ‘problemas extraños del motor’ se deben al ruido en la línea de alimentación por compartir fuentes de alimentación y / o no tener una fuente de alimentación lo suficientemente potente! Incluso los motores de CC pequeños pueden consumir hasta 3 amperios cuando se detienen.
Si desea tener una sola fuente de alimentación de CC para Arduino y motores.
Digamos que un adaptador o un solo paquete de baterías con salida de 6-12 VCC, simplemente conéctelo al conector de CC del Arduino o al bloque de terminales de alimentación de 2 pines en el escudo. IMPORTANTE: Coloca el puente de alimentación en el protector del motor.
Tenga en cuenta que puede tener problemas con los reinicios de Arduino si el suministro de la batería no puede proporcionar energía constante. No puedeS usar una batería de 9V para esto, debe ser de 4 a 8 baterías AA.
Si desea que Arduino se alimente desde USB y los motores se alimenten con una fuente de alimentación de CC.
Conecta el cable USB. Luego conecta la alimentación del motor al bloque de terminales de alimentación en el shield. No coloques el puente en el shield.
Este es un método sugerido para alimentar tu proyecto de motor, ya que tiene una fuente dividida, una fuente de alimentación para la lógica y una fuente para motores.
Si desea tener 2 fuentes de alimentación de CC separadas para el Arduino y los motores.
Enchufa el suministro para el Arduino en el conector de CC y conecta el suministro del motor al bloque de terminales de alimentación. Asegúrate de que has quitado el puente del protector del motor.
Pase lo que pase, si desea utilizar el motor de CC o motores paso a paso, el LED de protección del motor debe estar encendido para indicar una buena potencia del motor.
Uso RC Servos
Los servos tienen una conexión de cabezal hembra de 3 pines, + 5V, tierra y entradas de señal. El shield simplemente saca las líneas de salida PWM de los pines 9 y 10 de Arduino a dos cabezales de 3 pines para que sea fácil de conectar.
Puedes utilizar la librería Servo incorporada.
La energía para los Servos proviene del regulador de 5V integrado de Arduino, alimentado directamente desde el conector de alimentación USB o DC en el Arduino.
Uso de motores de CC
Los motores de CC se utilizan para todo tipo de proyectos robóticos.
El shield puede accionar hasta 4 motores de CC bidireccionalmente. Eso significa que se pueden conducir hacia adelante y hacia atrás. La velocidad también se puede variar en incrementos del 0,5% utilizando el PWM integrado.
Para conectar un motor a M1, M2, M3 o M4.
#include <Wire.h>
#include <Adafruit_MotorShield.h>
#include"utility/Adafruit_MS_PWMServoDriver.h"
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
Adafruit_DCMotor *myMotor = AFMS.getMotor(1);
AFMS.begin();
myMotor->run(FORWARD);
Uso motores paso a paso.
Este protector de motor admite hasta 2 motores paso a paso. La librería funciona de manera idéntica para motores bipolares y unipolares.
- Para motores unipolares: para conectar el paso a paso, primero averigüa qué pines están conectados a qué bobina y qué pines son centrales. Si es un motor de 5 cables, 1 es la toma central para ambas bobinas. La bobina 1 debe conectarse a un puerto del motor (digamos M1 o M3) y la bobina 2 debe conectarse al otro puerto del motor (M2 o M4).
- Para motores bipolares: es como los motores unipolares, excepto que no hay un quinto cable para conectar a tierra. El código es exactamente el mismo.
Ejecutar un motor paso a paso es un poco más complicado que ejecutar un motor de CC, pero sigue siendo muy fácil.
#include <Wire.h>
#include <Adafruit_MotorShield.h>
#include "utility/Adafruit_PWMServoDriver.h"
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
Adafruit_StepperMotor *myMotor = AFMS.getStepper(200, 2);
Establezce la velocidad del motor usando setSpeed (rpm) donde rpm es la cantidad de revoluciones por minuto a que deseas que gire el motor paso a paso.
Luego, cada vez que desees que el motor se mueva, llama al procedimiento step (#steps, dirección, tipo de paso). #steps es la cantidad de pasos que le gustaría que siguiera. La dirección es FORWARD o BACKWARD y el tipo de paso es SINGLE, DOUBLE, INTERLEAVE o MICROSTEP.
- SINGLE significa activación de bobina simple
- DOUBLE significa que se activan 2 bobinas a la vez (para un par mayor)
- INTERLEAVE significa que alterna entre simple y doble para obtener el doble de resolución (pero, por supuesto, es la mitad de la velocidad).
- MICROSTEP es un método en el que las bobinas son PWM para crear un movimiento suave entre los pasos.
De forma predeterminada, el motor ‘mantendrá’ la posición después de que termine el movimiento. Si deseas liberar todas las bobinas, para que pueda girar libremente, llama a release().
Apilamiento de shields.
Lo único a tener en cuenta al apilar shields es que cada shield debe tener una dirección I2C única. La dirección predeterminada es 0x60.
Puedes ajustar la dirección de los shield para que oscile entre 0x60 y 0x7F para un total de 32 direcciones únicas.
La dirección binaria que se programa con los puentes de dirección se agrega a la dirección I2C base.
Para programar el desplazamiento de la dirección, usa una gota de soldadura para puentear el puente de dirección correspondiente para cada ‘1’ binario en la dirección.
El puente más a la derecha es el bit de dirección # 0, luego a la izquierda está el bit de dirección # 1, etc.hasta el bit de dirección # 4
0: Dirección = 0x60 Offset = binario 0000 (no se requieren puentes)
1: Dirección = 0x61 Desplazamiento = binario 0001 (puente A0 como en la foto de arriba)
2: Dirección = 0x62 Desplazamiento = binario 0010 (puente A1, a la izquierda de A0)
3: Dirección = 0x63 Desplazamiento = binario 0011 (puente A0 y A1, dos puentes más a la derecha)
4: Dirección = 0x64 Offset = binario 0100 (puente A2, puente intermedio)
Escribir código para varios shield
Primero debemos crear un Controlador de shield de Motor para cada shield, con la dirección asignada.
Adafruit_MotorShield AFMSbot(0x61); // un jumper closed
Adafruit_MotorShield AFMStop(0x60); // no jumpers
Un shield de motor se llamará AFMSbot (shield inferior) y otro es AFMStop (shield superior) para que podamos mantenerlos separados. Cuando crees el objeto de shield, especifica la dirección que se estableció anteriormente.
Entonces podemos solicitar los motores conectados a cada uno:
// En el shield superior, conectamos dos motores paso a paso, cada uno con 200 pasos
Adafruit_StepperMotor *myStepper2 = AFMStop.getStepper(200, 1);
Adafruit_StepperMotor *myStepper3 = AFMStop.getStepper(200, 2);
// En el shield inferior, conectamos un motor paso a paso, con 200 pasos
Adafruit_StepperMotor *myStepper1 = AFMSbot.getStepper(200, 2);
// y un motor DC al puerto 1 -> M1
Adafruit_DCMotor *myMotor1 = AFMSbot.getMotor(1);
Ambos shield deben iniciarse, antes de usar los motores conectados:
AFMSbot.begin(); // Start the bottom shield
AFMStop.begin(); // Start the top shield
Puedes probar este código por sí mismo configurando dos shield, ejecutando el ejemplo Archivo-> Ejemplos-> Adafruit_MotorShield-> StackingTest.
Fuentes:
Ideas motrices y tutoriales
Mi Arduino 