Un chip típico para gobernar dos motores de continua, con una carga de hasta 2 Amperios por cada uno, incluyendo todo lo necesario para invertir la dirección de movimiento de estos y para controlar la velocidad de giro es chip L298.
La manera más cómoda de usar este chip es mediante un pequeño shield que nos permita conectarlo desde nuestros Arduinos. Originalmente diseñado por SparkFun.
Incluye dos únicos bridge, lo que nos limita a dos motores CC o a un único paso a paso, pero a cambio tenemos todo el control mediante pines directos de Arduino.
También podéis apreciar que dispone de una pequeña área de pruebas y prototipos, donde podréis soldar componentes adicionales, como LEDS, Bluetooth o WIFI o cualquier otra cosa que se os pueda ocurrir.
El shield utiliza 2 pines de Arduino para controlar cada motor. Uno regula la dirección de giro y el otro la velocidad mediante una señal PWM, lo que hacen un total de 4 pines dejando libres el resto.
El Ardumoto Shield se reserva los pines 12 y 13 para controlar la velocidad, y los pines 3 y 11, para controlar el sentido de giro de los motores A y B respectivamente.
| PIN ARDUINO | USO | NOTAS |
|---|---|---|
| 3 | PWM Motor A | Valores de 0 a 255 |
| 11 | PWM Motor B | Valores de 0 a 255 |
| 12 | Sentido Motor A | Es un Bool True / False |
| 13 | Sentido Motor B | Es un Bool True / False |
En el lado izquierdo de Ardumoto se pueden ver las conexiones para los motores A y B, así como un conector para alimentar los motores independientemente de la alimentación de Arduino.
No tiene demasiada importancia en qué orden conectáis los cables de los motores, siempre y cuando lo tengáis claro. Os recomiendo que os fijéis en los colores de los cables y conectéis ambos pares de igual modo para evitar sorpresas.
Fijaros también, que a los laterales de donde conectamos los motores hay un par de LEDs de colores que indican el estado del motor y su sentido de giro.
El programa
El shield Ardumoto usa simplemente los pines de control que se muestra en la tabla de más arriba, por lo que no requiere ninguna librería especial para mover los motores sino que usamos Arduino y sus pines para controlar el L298N y por tanto la velocidad y sentido de los motores conectados.
El programa que nos presenta SparkFun es de lo más sencillo y lo vamos a usar como ejemplo de control. Empezamos con algunas definiciones:
#define CW 0 //Sentido 1 #define CCW 1 //Sentido 2 #define MOTOR_A 0 #define MOTOR_B 1 const byte PWMA = 3; //control velocidad motor A const byte PWMB =11; //control velocidad motor B const byte DIRA =12; //Dirección motor A const byte DIRB =13; //Direction motor B
Y ahora vamos a definir un par de funciones sencillas. La primera la usaremos para arrancar uno de los motores con un sentido y velocidad dados:
void accionMotor(byte motor, byte dir, byte spd){
if (motor == MOTOR_A){
digitalWrite(DIRA, dir);
analogWrite(PWMA, spd);
}
else if (motor == MOTOR_B){
digitalWrite(DIRB, dir);
analogWrite(PWMB, spd);
}
}
Y la segunda es aún más sencilla, para parar un motor:
void stopMotor(byte motor){
accionMotor(motor, 0, 0);
}
Y como tenemos que programar los pines, porque no tenemos una librería que nos haga el trabajo sucio, podemos definir una función que lo haga:
void setupArdumoto(){
pinMode(PWMA, OUTPUT);
pinMode(PWMB, OUTPUT);
pinMode(DIRA, OUTPUT);
pinMode(DIRB, OUTPUT);
digitalWrite(PWMA, LOW);
digitalWrite(PWMB, LOW);
digitalWrite(DIRA, LOW);
digitalWrite(DIRB, LOW);
}
EL resto del programa tiene poco mérito. Básicamente vamos llamando a accionMotor() para hacer girar los motores en diferente sentido y con distinta velocidad.
No pretende ser más que un pequeño ejemplo de como se puede realizar el control de los motores conectados al Ardumoto Shield.
void loop(){
// Mueve Motor A, a diferentes velocidades
accionMotor(MOTOR_A, CCW, 255);
delay(1000);
accionMotor(MOTOR_A, CW, 127);
delay(1000);
stopMotor(MOTOR_A); // Parar Motor A
// Mueve Motor B a varias velocidades
accionMotor(MOTOR_B, CCW, 255);
delay(1000);
accionMotor(MOTOR_B, CW, 127);
delay(1000);
stopMotor(MOTOR_B); // Para Motor B
// Ahora girar ambos motores
accionMotor(MOTOR_A, CW, 255);
accionMotor(MOTOR_B, CW, 255);
delay(1000);
// Ahora retroceso a media maquina
accionMotor(MOTOR_A, CCW, 127);
accionMotor(MOTOR_B, CCW, 127);
}
Podemos conectar un módulo de bluetooth, y poder controlar nuestro robot (coche) con una aplicación de móvil.
Mi Arduino 