Tutorial de Arduino + controlador de motores Dual H-Bridge

(Actualizado el 27/6/2019)

¡Buenos días, humanos, robots y cyborgs de la blogosfera! Hoy explicaremos cómo utilizar un controlador de motores dual de doble puente con Arduino.

El Puente-H es un circuito eléctrico muy utilizado para controlar motores DC, y permite cambiar tanto su velocidad como la dirección de giro. La placa que utilizaremos incluye dos de estos circuitos con los pines a punto para que podamos conectarlo cómodamente. ¡Genial!

La placa con que trabajaremos hoy…

¿Pero por qué necesitamos un controlador de motores? Sencillamente porque las placas como Arduino no tienen suficiente potencia para alimentar un motor DC. Un controlador de motores actúa, en cierto modo, como un “interruptor” encendido y apagado por Arduino, dejando pasar más o menos corriente hacia los motores.

¡Manos a la obra!

Vale, ¿qué necesitamos para este tutorial?

1. Placa Arduino y cable USB compatible
2. Motor DC, por lo menos uno.
3. Zócalo con pilas/baterías (i. e. algo que de calambre). Para los motores DC estándar que se usan en electrónica unos 5-6 voltios  y 600-800 mAh normalmente bastan, pero siempre tenemos que leer la documentación de nuestras piezas antes de conectar nada.
4. Y lógicamente: Hilo eléctrico, pines Macho-Hembra, y herramientas.

¿Cómo funciona el controlador? Un poco de anatomía…

He aquí un pequeño esquema del controlador de motores H-Bridge:

La placa se alimenta por los pines VMS y GND a través de una batería (rojo). Si además conectamos nuestra placa Arduino a GND y +5V la estaremos alimentando a través de la placa de motores. Es decir, el controlador proporcionará energía a Arduino.

Los pines para controlar los motores (en azul en el esquema) son los marcados como EA, I1, I2, EB, I3, I4. Los tres primeros sirven para controlar el motor A, y el resto controlan el motor B.

Centrémonos en los del motor A: I1 e I2 sirven para controlar la dirección. Si I1 está a HIGH e I2 a LOW, el motor avanza hacia delante. Si están al revés el motor avanza hacia atrás.

El pin EA sirve para controlar la velocidad del motor. Para cambiar la velocidad, Arduino tiene que enviar un pulso PWM a este pin. En la práctica (aunque en la realidad no es así), podemos pensar un pulso PWM como una señal entre 0 y 5 voltios que podemos controlar e ir variando a nuestro gusto. Si EA recibe un pulso correspondiente a 0V detendrá los motores, mientras que uno de 5V los pondrá a velocidad máxima.

Los pines del motor B (EB, I3, I4) funcionan igual.

Para conectar estos pines con Arduino son muy útiles los conectores Macho/Hembra. Pueden encontrarse en cualquier tienda de electróncia a un precio insignificante.

En cuánto a los motores en sí, se conectarán las regletas que en el esquema he marcado en Verde y Morado… ¡Y ojo con la polaridad! Depende de como los conectemos, los motores girarán en una dirección u otra.

El disipador (flecha naranja), sirve para enfriar el circuito de Puente-H que está justo debajo. Cuándo los motores lleven rato funcionando el circuito puede calentarse… y no queremos fundir nuestra nueva placa, ¿verdad?

La placa también lleva pines para conectar Resistencias Shunt (en el esquema marcados en amarillo). Hoy no vamos a utilizar ninguna, pero sirven para medir el corriente eléctrico que circula por los motores.

1. Ejemplo con un sólo motor

La primera parte del tutorial será un ejemplo sencillo en el que movemos un único motor.

Conexiones

Las conexiones de la placa de motores serán:

• • VMS al polo positivo de la batería
  • GND al polo negativo de la batería
  • EA al pin D11 de Arduino
  • I2 al pin D10 de Arduino
  • I1 al pin D9 de Arduino
  • Y conectamos el motor en sí a los pines verdes GND y VCC de la placa.

Podemos alimentar nuestra placa Arduino a través del controlador de motores si hacemos también estas conexiones:

• +5V al pin VCC de Arduino
• GND al pin GND de Arduino

Código

Vamos a crear un código simple que moverá el motor hacia delante y hacia atrás a una velocidad constante.

#define EA 11
#define I2 10
#define I1 9

void setup()
{
pinMode(EA, OUTPUT);
pinMode(I1, OUTPUT);
pinMode(I2, OUTPUT);
}

void loop()
{
//Establecemos la velocidad a 200
analogWrite(EA, 200);

//Hacia delante
digitalWrite(I1, HIGH);
digitalWrite(I2, LOW);

delay(2000);

//Y para atras
digitalWrite(I1, LOW);
digitalWrite(I2, HIGH);

delay(2000);
}

El programa no necesita mucha explicación. Establecemos los pines como salidas en void setup(). Entonces en void loop() ponemos la velocidad a 200 y vamos alternando los pines I1 e I2 para que el motor vaya hacia delante y hacia atrás en intervalos de dos segundos.

Notemos que para cambiar el estado de los pines I1 e I2 utilizamos la función digitalWrite(), puesto que estos pines sólo pueden estar encendidos o apagados. Para controlar la velocidad con el pin EA utilizamos la función analogWrite() que recibe un valor entre 0-255 y genera el pulso PWM correspondiente

2. Funciones de movimiento

Una vez hemos comprendido el código anterior y, por lo tanto, cómo funciona la placa, podemos crear nuestras propias funciones para hacer movimientos.

Conexiones adicionales

Para este ejemplo podemos poner un segundo motor (aunque no es obligatorio). Hay añadir estas tres conexiones además de las que ya tenemos hechas:

• EB al pin D5 de Arduino
• I4 al pin D7 de Arduino
• I3 al pin D6 de Arduino
• Conectar el segundo motor a la otra regleta

Código

Para este segundo código vamos a escribir tres funciones: adelante(), atras() y parar(). Todas las funciones recibirán como parámetro el motor que hay que mover. Además, adelante() y atras() recibirán un entero entre 0-255 que será la velocidad.

#define EA 11
#define EB 5
#define I1 9
#define I2 10
#define I3 6
#define I4 7
 
 
void adelante(int motor, int velocidad)
{
  //Comprobamos cual de los dos motores hay que mover
  if(motor == 1)
  {
    //Si es el motor 1, activamos los pines EA, I1, I2
    //EA gestiona la velocidad, y I1/I2 la direccion de giro
    analogWrite(EA, velocidad);
    digitalWrite(I1, HIGH);
    digitalWrite(I2, LOW);
  }
  else
  {
    //Si es el motor 2, activamos los pines EB, I3, I4
    //EB gestiona la velocidad, y I3/I4 la direccion de giro
    analogWrite(EB, velocidad);
    digitalWrite(I3, HIGH);
    digitalWrite(I4, LOW);
  }
}
 
void atras(int motor, int velocidad)
{
  //El funcionamiento es analogo al de la funcion adelante()
  if(motor == 1)
  {
    analogWrite(EA, velocidad);
    digitalWrite(I1, LOW);
    digitalWrite(I2, HIGH);
  }
  else
  {
    analogWrite(EB, velocidad);
    digitalWrite(I3, LOW);
    digitalWrite(I4, HIGH);
  }
}
void parar(int motor)
{
  if(motor == 1)
  {
    digitalWrite(I1, LOW);
    digitalWrite(I2, LOW);
  }
  else
  {
    digitalWrite(I3, LOW);
    digitalWrite(I4, LOW);
  }
}
 
void setup()
{
  //Configuramos todos los pines para que sean salidas
  pinMode(EA, OUTPUT);
  pinMode(I1, OUTPUT);
  pinMode(I2, OUTPUT);
  pinMode(EB, OUTPUT);
  pinMode(I3, OUTPUT);
  pinMode(I4, OUTPUT);
}
 
void loop()
{
  //Llamamos las funciones para mover los motores
  adelante(1, 100);
  delay(1000);
  atras(1, 100);
  delay(1000);
  parar(1);
  
  adelante(2, 100);
  delay(1000);
  atras(2, 100);
  delay(1000);
  
  adelante(1, 100);
  adelante(2, 100);
  delay(1000);
  atras(1, 100);
  atras(2, 100);
  delay(1000);
  parar(2);
}

Esto es todo. ¿Qué tal ha funcionado? ¿Se mueven los dos motores? Como siempre puedes dejarme tus dudas en los comentarios y te echaré una mano con los problemas que tengas.

Y si te sirvió este tutorial no dudes en darle like a nuestra página de Facebook y/o Twitter. Nos gusta mucho estar en contacto con nuestros lectores humanos 😉