Si todo marcha bien, ya sabemos
gestionar y procesar las entradas de nuestro proyecto. Además, hemos
visualizado sus valores en el monitor y hemos gestionado salidas simples como
leds o zumbadores.
Sin embargo, en la mayoría de los
proyectos que hagamos en el taller, tarde o temprano aparecerá un elemento que
nos gusta más: los motores. Con ellos abrimos
puertas, accionamos norias, elevamos ascensores. Sería una pasada que nuestra
placa Arduino pudiera manejarlos, ¿no? Pues la respuesta es obvia, Yes, you can!. Vamos a ver cómo lo podemos hacer.
Como ya hemos dicho, las salidas de
nuestra placa nos proporcionan una intensidad baja. Esa intensidad se queda
corta a la hora de accionar muchos elementos, como por ejemplo nuestros
queridos motores de cc –siii, corriente continua, tema 4 de Tercero ESO...-.
Podemos amplificar fácilmente esta
señal por medio de un transistor, pero vamos a aprender a usar un driver que
nos ofrece más posibilidades. Se trata del TB6612FNG.
El driver TB6612FNG nos permite
controlar dos motores basándose en un doble puente-H. Con él podemos fijar el
sentido de giro e incluso gracias a una salida tipo PWM ajustar la velocidad de
giro. Recuerda que las salidas PWM son aquellas que delante de su número
tienen el símbolo ~.
El aspecto que presenta el fabricado
por POLOLU es el siguiente:
A pesar de su aspecto, la conexión
es sencilla. Como siempre, lo primero que deberíamos hacer es ir al datasheet
del componente. Allí encontraremos todos los datos que nos hacen falta. Como se
te nota poco motivado, vamos a ir conectando cables y verás que no era tan
complicado. Empezando por la izquierda:
- GND y VCC: es la alimentación de micro. Podemos sacarla de un
GND y del +5V de
- AO1 y AO2: aquí conectaremos los dos bornes del motor A.
- BO1 y BO2: o, de output, salida, b del motor y 1
y 2 de cada una de ellas. Salidas para el motor B.
- Vmot y GND: alimentación externa para los motores, baterías,
fuente de alimentación…
Ya llevamos 8 pines y no tenemos
bajas, seguimos con la parte derecha:
- PWMA: controla la velocidad por medio de una salida digital
con PWM (modulación por ancho de pulsos) del motor A. Recuerda que tiene que tener el símbolo ~ delante.
- AIN2 y AIN1: para controlar el sentido de giro de un motor
necesitamos dos salidas digitales de la placa. Usaremos dos cualesquiera
para el motor A.
- STBY, standby: poniéndolo en LOW conseguimos parar los
motores. Lo conectaremos a otra salida digital.
- BIN1 y BIN2, in, entrada, b, del motor B, 1 y
2, cada una de las dos. Las
conectaremos a dos salidas
digitales de la placa.
- PWMB: control de velocidad del motor B. 0 parado, 255 velocidad máxima.
Ya lo tenemos conectado. Vamos con
el código.
//CONTROLANDO MOTORES CC
CON UN DRIVER 6612
//motor A conectado a A01y A02
//motor B conectado a B01 y B02
int STBY = 10; // definimos el
pin de standby
//para el motor A
int PWMA = 3; // control de
velocidad
int AIN1 = 9; //
dirección
int AIN2 = 8; //
dirección
// para el motor B
int PWMB = 5; // control de
velocidad
int BIN1 = 11; //
dirección
int BIN2 = 12; //
dirección
void setup(){
pinMode(STBY, OUTPUT); // definimos esos pines como salidas
pinMode(PWMA, OUTPUT);
pinMode(AIN1, OUTPUT);
pinMode(AIN2, OUTPUT);
pinMode(PWMB, OUTPUT);
pinMode(BIN1, OUTPUT);
pinMode(BIN2, OUTPUT);
}
void loop(){
mover(1,
255, 1); //
acciona el motor 1, velocidad máxima, adelante
mover(2, 255, 1); //
acciona el motor 2, velocidad máxima, adelante
delay(1000); //
durante un segundo
stop(); //
para los motores
delay(1000); //
espera 1 segundo
mover(1, 128, 0); //
acciona el motor 1, velocidad media , atrás
mover(2, 128, 0); //
acciona el motor 2, velocidad media , atrás
delay(1000);
stop();
delay(1000);
}
void
mover(int motor, int velocidad, int direccion){ //Vamos a definir la función mover, que va a acciona un
motor, fijar su velocidad y el sentido de giro. Definimos: //motor: llamaremos 1 al motor A, y 2 al
motor B
//velocidad: desde 0 a 255
//dirección: 0 para el
giro en sentido horario, 1 sentido antihorario
digitalWrite(STBY,
HIGH); //deshabilitar
standby para mover
boolean inPin1 =
LOW; // creamos la variable
booleana (solo puede ser HIGH/LOW) inpin1
boolean inPin2 = HIGH; // y le
asignamos el valor LOW. A inPin2 le
damos el valor HIGH
if(direccion
== 1){
inPin1
= HIGH;
inPin2
= LOW;
}
if(motor
== 1){
digitalWrite(AIN1,
inPin1);
digitalWrite(AIN2, inPin2);
analogWrite(PWMA, velocidad);
}else{
digitalWrite(BIN1, inPin1);
digitalWrite(BIN2, inPin2);
analogWrite(PWMB, velocidad);
}
}
void stop(){ //ahora si, accionamos el standby
digitalWrite(STBY,
LOW);
}
Lo que nosotros tendremos que hacer
será variar el loop y poner las condiciones que a nosotros nos interese.
El esquema con el mismo componente
pero de Sparkfun es el siguiente:
