Pepe Chorva

Controlar un motor es fácil, le pasas corriente y listo, ya corre. Si quieres controlar la velocidad, es decir, que acelere, ya es un pelín más complejo, necesitas PWM, pero... si además quieres elegir en qué dirección tiene que girar, ya es la ostia necesitas lo que se denomina un puente H.

Este tutorial viene a ser una continuación del Howto ArduTanque DIY, el tanque ya está montado, falta hacer que se mueva. En este tutorial no me voy a detener en los posibles usos que se le puedan dar a un motor (desde mover ruedas u orugas a un ventilador, ducted-fan, etc), los límites los pones tu, yo sólo te voy a explicar cómo mover un motor (o varios).

Podría entrar a explicar toda la teoría de como influyen las corrientes eléctricas en el bobinado de un motor... pero ni tengo mucha idea, ni entra en el objetivo de este tutorial, así que vamos a ver directamente al tema, como controlar un motor.

Con un motor, si no necesitamos variar la velocidad ni el sentido, lo tenemos muy fácil, asignamos un pin de salida del arduino y le damos valor HIGH cada vez que lo queramos en marcha, al igual que haríamos para encender un LED.

La respuesta del motor será la misma que si lo conectáramos al pin +5V de arduino, es decir, todo o nada, va o no va.

Si utilizamos las salidas PWM del arduino, podemos variar la velocidad del motor, de forma que se multiplican las opciones para manejarlo (también se multiplica la complejidad computacional, pero hay que echarle valor, el resultado merece la pena).

Todo eso está muy bien, tiene muchas utilidades, es sencillo y es hasta chulo. . . pero yo quiero controlar un motor que se mueva adelante y atrás, para mi robot dominador del mundo.

Aquí es donde entra la electrónica como un elefante en una cacharrería, necesitamos algo más que un motor y un arduino. Concretamente, necesitamos montar lo que se denomina un puente H.

El puente H obtiene este nombre a partir de que la configuración del mismo se asemejaría a una H mayúscula. Tenemos los dos extremos superiores que son los selectores de dirección, que crean un circuito cada uno para que el motor gire en un sentido u otro. Estos circuitos se cruzan a través del motor, que está, por decirlo de alguna forma, en el palito horizontal de la H. No voy a detenerme en el funcionamiento del puente H, hay montones de esquemas que lo hacen, así que no voy a reinventar la rueda.

Para simplificar los circuitos, se utiliza un I.C. (circuito integrado), en este caso, un L293D. Este nos permite 2 puentes H independientes. El puente de diodos, en el caso del L293D no es necesario, está implementado internamente, pero en mi caso, el IC esta sobre un zócalo, por si en una de esas lo cambio por el L293B, que sí lo necesita. Nunca está de más un poco de protección extra.

Bueno, ahora ya tenemos el giro pero, ¿como conseguimos acelerar?

Para ello, necesitamos usar un pin del arduino con PWM para la entrada ENABLE del IC, que nos permite activar la salida hacia el motor y esto es lo que permite acelerar. Haremos un analogWrite con valor base 800 + 1/6 del valor que lea el C.A/D, sobre el pin del motor que nos interese. Este valor base nos da la frecuencia a la que debe transmitir el valor HIGH por el pin seleccionado.

El esquemático y el código para el ejemplo es el siguiente:

Muy importante, poner GNDs en común para no freir el arduino, las diferencias de los voltajes a los que trabajan el microcontrolador y los motores, pueden ser peligrosas para el arduino (y en general, para cualquier micro).

//Programa para controlar 2 motores con control de velocidad y giro con un L293
int switchPin = 7;    // switch para cambiar el sentido de giro de los motores
int motor1Pin1 = 3;   // Motor 1 adelante
int motor1Pin2 = 4;   // Motor 1 atras
int speedPin1 = 9;    // Motor 1 aceleracion (PWM) Pin enable del L293
int potPin = 0;       // Potenciometro para controlar velocidad motor 1
 
int ledPin = 13;      // LED
 
//int switchPin2 = 8;   // No implementado
int motor2Pin1 = 5;   // Motor 2 adelante
int motor2Pin2 = 6;   // Motor 2 atras
int speedPin2 = 10;   // Motor 2 aceleracion (PWM) Pin Enable del L293
int potPin2 = 1;      // Potenciometro para controlar velocidad motor 2
int speedpin = 0;     // tasa de velocidad a la que Arduino envia los datos
 
void setup() {
 
Serial.begin (9600);
 
//configuracion de pines
pinMode(switchPin, INPUT);
//pinMode(switchPin2, INPUT); //no usado
 
// Control Motor 1
pinMode(motor1Pin1, OUTPUT);
pinMode(motor1Pin2, OUTPUT);
pinMode(speedPin1, OUTPUT);
 
//Control Motor 2
pinMode(motor2Pin1, OUTPUT);
pinMode(motor2Pin2, OUTPUT);
pinMode(speedPin2, OUTPUT);
 
pinMode(ledPin, OUTPUT);
 
// Establece speedPinX en modo High para poder controlar la velocidad
digitalWrite(speedPin1, HIGH);
digitalWrite(speedPin2, HIGH);
 
// comprobacion de reseteo, si el led parpadea solo 3 veces, todo esta bien
// si vuelve a parpadear, significa que ha hecho un reset, revisar conexiones
// por si hubiera un corto
blink(ledPin, 3, 100);
}
 
void loop() {
 
//Si el switch no esta pulsado, gira en una direccion, si no en la contraria
if (digitalRead(switchPin) >0) {
 
digitalWrite(motor1Pin1, LOW);      // Establece el sentido de giro del motor 1
digitalWrite(motor1Pin2, HIGH);     //
 
speedpin = analogRead(potPin);      // Lectura del valor del potenciometro
speedpin = 800 + (speedpin/6);      // Para establecer la velocidad de giro
analogWrite (speedPin1, speedpin);  //
Serial.print("motor 1 = ");         //
Serial.println(speedpin);           //
delay (50);                         //
 
 
digitalWrite(motor2Pin1, LOW);      // Establece el sentido de giro del motor 2
digitalWrite(motor2Pin2, HIGH);     //
 
speedpin = analogRead(potPin2);     // Lectura del valor del potenciometro
speedpin = 800 + (speedpin/6);      // Para establecer la velocidad de giro
analogWrite (speedPin2, speedpin);  //
Serial.print("motor 2 = ");         //
Serial.println(speedpin);           //
delay(50);                          //
}
else {
digitalWrite(motor1Pin1, HIGH);     // Establece el sentido de giro del motor 1
digitalWrite(motor1Pin2, LOW);      //
 
speedpin = analogRead(potPin);      // Lectura del valor del potenciometro
speedpin = 800 + (speedpin/6);      // Para establecer la velocidad de giro
analogWrite (speedPin1, speedpin);  //
Serial.print("motor 1 = ");         //
Serial.println(speedpin);           //
delay (50);                         //
 
 
digitalWrite(motor2Pin1, HIGH);     // Establece el sentido de giro del motor 2
digitalWrite(motor2Pin2, LOW);      //
 
speedpin = analogRead(potPin2);     // Lectura del valor del potenciometro
speedpin = 800 + (speedpin/6);      // Para establecer la velocidad de giro
analogWrite (speedPin2, speedpin);  //
Serial.print("motor 2 = ");         //
Serial.println(speedpin);           //
delay(50);                          //
}
}
 
/*
Parpadeo del led, Significa que ha ejecutado la funcion setup()
si todo va bien, solo parpadea tres veces, si hay algun error que resetee el arduino,
volvera a verse el parpadeo del led
*/
void blink(int whatPin, int howManyTimes, int milliSecs) {
int i = 0;
for ( i = 0; i < howManyTimes; i++) {
digitalWrite(whatPin, HIGH);
delay(milliSecs/2);
digitalWrite(whatPin, LOW);
delay(milliSecs/2);
}
}
 

Para este ejemplo, controlo la velocidad de los dos motores del tanque de forma independiente con los potenciómetros, aunque la dirección en este caso sólo se controla mediante un botón, por simplicidad. Más adelante, con sensores de distancias, brújulas, sensores IR para hacer un siguelíneas, no hará falta este botón, ni los potenciómetros, por lo que es poco relevante su implementación.

Aquí un video del funcionamiento del ardutanque, ya se mueve!!! la conquista del mundo está cerca, MWHAHAHAHAHAAA!!!

El código de control del puente H está basado en el de esta página:

http://www.ecs.umass.edu/ece/m5/tutorials/H-Bridge_tutorial.html

Espero que os haya gustado.