Placa controladora de motores L298n de 4 canales. (Robot Arduino, Raspberry, PICAXE, ROS)

En esta entrada describo una placa controladora de 4 motores de Corriente Continua (CC). La cual usa 4 puentes H integrados en dos "chips" L298N". Escribo esta entrada porque no he encontrado en internet, información sobre este controlador, donde se muestre como se debe conectar y programar con Arduino. Al final de la entrada hay un pequeño "Sketch" de Arduino que muestra como se tiene que configurar Arduino para que funcione este controlador con un Arduino MEGA y 4 micro-motores de CC.

Controlador de motores L298N de 4 canales.

1-Cuatro ruedas direccionales :
El robot Andromina OFF ROAD V.1.2. es una plataforma robótica omnidireccional (robot omnidireccional  o robot holonómico). Es un robot que puede desplazarse en cualquier dirección sin la necesidad de alcanzar previamente una orientación específica. Es decir, es capaz de realizar giros, movimientos en cualquiera de las componentes del plano, bien sean traslaciones (hacia adelante, en reversa, laterales) o rotaciones. Para que el robot sea omnidireccional necesita ser controlado por una placa de motores de 4 canales independientes. En este tutorial mostramos el uso de una de estas placas de 4 canales.
Para que el robot Andromina pueda demostrar todo su potencial de maniobrabilidad se le debe montar una placa controladora de motores de Corriente Continua de 4 canales independientes. De esta manera podemos programar las velocidades y direcciones de las 4 ruedas totalmente independientes entre ellas. En la figura siguiente se muestra una de estas maniobras que el robot puede hacer. El robot gira sobre sí mismo, con respecto a una de sus ruedas. Todo el robot gira respecto al punto negro. La rueda que está en el punto negro está parada y las otras 3 giran y rotan a diferentes velocidades y en diferentes ángulos. Este movimiento solo se puede lograr con una placa de 4 canales.

Maniobra donde las 4 ruedas giran y rotan  todas independientemente.

2-La placa de motores : En la foto siguiente se muestra la placa controladora de los 4 motores de CC que he elegido. Esta placa llevaba 4 puente H en los 2 controladores de potencia L298N.

Descripción de las entradas y salidas de la placa L298N.

En el mercado hay diferentes modelos de este tipo de controlador de motores. Yo he elegido este modelo por :

1. Su precio económico.
2. Su reducido tamaño.
3. Tiene las mismas dimensiones que la mayoría de controladores de 2 canales. Son intercambiables. Se adapta muy bien en el robot Andromina.
4. Usa una configuración muy similar a la mayoría de controladores de 2 canales.
5. Lleva un regulador de voltaje extra de +5v y  1,5 amperios.

Otra opción para poder controlar los 4 motores de CC independientemente es montar dos placas L298N de dos canales cada una. Ver dicha placa en la foto siguiente. Esta opción aún es más económica, si se busca bien en internet. Pero tiene el inconveniente que necesitamos ocupar 12 entradas en la placa Arduino MEGA para poder controlar los 4 motores.

Placa L298N de dos canales.

3-El esquema : En la foto siguiente se muestra un ejemplo del esquema eléctrico que se tiene que realizar para conectar la placa con los 4 motores de la plataforma robótica Andromina. Más abajo está el programa de Arduino que se ha diseñado para este ejemplo de placa L298N y el Arduino Mega.

Esquema eléctrico con una placa L298N y un Arduino Mega.

En el "Sketch" también se muestra como se hace para invertir el sentido de giro de los motores. Invertiremos los valores "HIGH" y "LOW" de programa. En este esquema de ejemplo si alimentamos las dos placas con una batería de 12 voltios, la placa controladora de los motores suministrará 12 voltios a los 4 motores cuando le indiquemos un valor de 255 en los pines IN1, IN2 etc... (máxima velocidad). Si alimentamos con una batería de 6.3 voltios la placa de motores solo suministrará 6.3 voltios a los motores, a máxima velocidad. Para variar la velocidad variaremos este valor entre 0 y 255, ver "Sketch" más abajo.

4-El montaje : En la foto siguiente se muestra el montaje que se tiene que realizar para conectar esta placa con los 4 motores de la plataforma robótica Andromina.

Vista del circuito eléctrico realizado.

Si queremos usar esta controlador de 4 canales en la plataforma robótica Andromina no podemos usar Arduino UNO debemos usar Arduino MEGA. Ya que como mínimo necesitamos 8 salidas PWM, 4 para los motores de las ruedas y 4 para los servo motores que giran las ruedas. También necesitamos 8 salidas más para el control de la placa controladora de los 4 motores  L298N.

Para la realización de la conexión entre el controlador y Arduino es necesario eliminar 4 puentes que lleva la placa controladora, cuando llega del proveedor. Estos puentes se pueden ver en la fotografía siguiente y se deben eliminar para poder conectar los pines EN1, EN2, EN3 y EN4 a las salidas PWM de Arduino MEGA. Estos 4 pines controlan la velocidad de los 4 motores.

Vista del controlador L298N con los 4 puentes.

Otra ventaja que tiene esta placa controladora de motores es que lleva un regulador de voltaje integrado que suministra un voltaje de +5v y 1,5 Amperios. Podemos usar la salida +5v de la placa L298N para alimentar cualquier otro dispositivo de nuestro robot. Este regulador se puede ver en la foto superior. Es aconsejable colocar un tornillo que sujete el regulador al disipador de calor. Ver fotos superior e inferior. Ya que de serie no lleva este tornillo. Esto hace que el regulador no se caliente tanto cuando se le pide mucha intensidad. Y es más difícil fundir el regulador de voltaje.

Regulador de voltaje con el tornillos roscado al disipador de calor.

También es aconsejable colocar un condensador de 16v y 1500 micro faradios (o más grande) a la entrada del la placa de motores. Ver esquema eléctrico más arriba. Este condensador suministra corriente extra y mantiene el voltaje más estable en el momento que se activan los 4 motores a la vez.
5-Los robots Andromina :

Vista del chasis del roboa Andromina OFF ROAD.

Vista del chasis del roboa Andromina ON ROAD.

En las dos fotos siguientes se puede ver el montaje del robot Andormina ON ROAD con una placa controladora de 4 motores L298N y un Arduino MEGA + una "shield". También hay una pantalla LCD.Para más información sobre este robot ver esta entrada de este blog: Robot Andromina

Vista superior del robot Andrómina con la placa controladora de 4 motores L298N.

Vista frontal del robot Andrómina con la placa controladora de 4 motores L298N.

Esquema completo del robot con la placa controladora de 4 motores L298N y 

6-El sketch de Arduino :

/* Programa de prueba para Arduino MEGA + la placa que controla los 4 motores, L298N de 4 canales, los 4 motores de CC son independientes (28-05-2014). Autor: J.T.C..
El funcionamiento de esta placa de 4 canales es el mismo que la placa de 2 canales, pero con el doble de entradas y salidas.
*////  Declaración de las variables del controlador de los 4 motores independientemente ///////////////////
  int EN1=2;   //connected to Arduino's port 2 (output pwm), motor 1.
  int EN2=3;   //connected to Arduino's port 3 (output pwm), motor 2.
  int EN3=4;   //connected to Arduino's port 4 (output pwm), motor 3.
  int EN4=5;   //connected to Arduino's port 5 (output pwm), motor 4.
  int IN1=22;  //connected to Arduino's port 22 , motor 1.
  int IN2=23;  //connected to Arduino's port 23 , motor 1.
  int IN3=24;  //connected to Arduino's port 24 , motor 2.
  int IN4=25;  //connected to Arduino's port 25 , motor 2.
  int IN5=26;  //connected to Arduino's port 26 , motor 3.
  int IN6=27;  //connected to Arduino's port 27 , motor 3.
  int IN7=28;  //connected to Arduino's port 28 , motor 4.
  int IN8=29;  //connected to Arduino's port 29 , motor 4.
//// Configuración de Arduino ///////////////////////////////////////////////////////////////////
void setup(){
//// Configuración de los pines de la placa controladora de 4 motores DC L298N.////////////////////////////////////////
   pinMode(EN1,OUTPUT); // Configuración de la salida PWM, motor 1.
   pinMode(EN2,OUTPUT);
   pinMode(EN3,OUTPUT);
   pinMode(EN4,OUTPUT);
   pinMode(IN1,OUTPUT); // Configuración de la salida, sentido de giro, motor 1.
   pinMode(IN2,OUTPUT);
   pinMode(IN3,OUTPUT);
   pinMode(IN4,OUTPUT);
   pinMode(IN5,OUTPUT);
   pinMode(IN6,OUTPUT);
   pinMode(IN7,OUTPUT);
   pinMode(IN8,OUTPUT);
   delay(500);}
//// Inicio del programa //////////////////////////////////////////////////////////////////////
void loop(){
//// Activa el Motor 1 //////////////////////////////////////////////////////////////////////////////
  digitalWrite(IN1,LOW);  // IN1 y IN2 Configuran la dirección de giro del motor 1. Se tienen que cambiar "invertir" los dos valores HIGH y LOW para invertir el giro.
  digitalWrite(IN2,HIGH); //
  analogWrite(EN1,255);   // Inicia la marcha del motor 1, el valor 0 indica parado y el valoe 255 máxima velocidad.
  delay(2000);
  analogWrite(EN1,0);     // Para la marcha del motor 1
//// Activa el Motor 2 //////////////////////////////////////////////////////////////////////////////
  digitalWrite(IN3,LOW);  // IN3 y IN4 Configuran la dirección de giro del motor 2. Se tienen que cambiar "invertir" los dos valores HIGH y LOW para invertir el giro.
  digitalWrite(IN4,HIGH); //
  analogWrite(EN2,255);   // Inicia la marcha del motor 2
  delay(2000);
  analogWrite(EN2,0);     // Para la marcha del motor 2
//// Activa el Motor 3 //////////////////////////////////////////////////////////////////////////////
  digitalWrite(IN5,LOW);  // IN5 y IN6 Configuran la dirección de giro del motor 3. Se tienen que cambiar "invertir" los dos valores HIGH y LOW para invertir el giro.
  digitalWrite(IN6,HIGH); //
  analogWrite(EN3,255);   // Inicia la marcha del motor 3
  delay(2000);
  analogWrite(EN3,0);     // Para la marcha del motor 3
//// Activa el Motor 4 //////////////////////////////////////////////////////////////////////////////
  digitalWrite(IN7,LOW);  // IN7 y IN8 Configuran la dirección de giro del motor 3. Se tienen que cambiar "invertir" los dos valores HIGH y LOW para invertir el giro.
  digitalWrite(IN8,HIGH); //
  analogWrite(EN4,255);   // Inicia la marcha del motor 4
  delay(2000);
  analogWrite(EN4,0);}      // Para la marcha del motor 4
//// Fin del programa //////////////////////////////////////////////////////////////////////////