Funcionamiento del módulo controlador de motores L298N

En este tutorial explicaremos cómo controlar dos motores de corriente continua con el módulo L298N, realizaremos un ejemplo básico, primero sin utilizar ninguna librería y después, con la biblioteca LEANTEC_ControlMotor.h

El L298N es un módulo para controlar motores. Es fácil de programar y es capaz de controlar motores de corriente continua de una forma sencilla. Este tipo de módulo se puede usar para multitud de aplicaciones, ya que permite controlar la velocidad y la dirección de los motores.

CONEXIÓN Y FUNCIONAMIENTO

Incorpora una entrada de voltaje. El rango de tensiones en el que trabaja este módulo va desde 3V hasta 35V, dependiendo de la configuración del Jumper regulador; y cuenta con una intensidad de hasta 2A. Con el Jumper puesto sirve para controlar motores de 5 a 12V y tendremos una salida de 5V para otros módulos. Sin el Jumper regulador, sirve para controlar motores de 12 a 35V y en este caso, el tercer pin actuará como una entrada de 5V para alimentar la parte lógica del driver.

Las salidas para los motores 1 y 2 nos darán la energía para mover los motores. Tened en cuenta la polaridad al conectarlos, para que cuando más tarde hagamos que se muevan, funcionen como deberían. Si no tendríamos solo que invertir las conexiones.

Los pines IN1 e IN2 nos sirven para controlar el sentido de giro del motor 1, y los pines IN3 e IN4 el del motor 2. Funcionan de forma que si IN1 está a HIGH e IN2 a LOW, el motor 1 gira en un sentido, y si está IN1 a LOW e IN2 a HIGH lo hace en el otro. Y lo mismo con los pines IN3 e IN4 y el motor 2.

• IN1 -> HIGH; IN2 -> LOW : gira en un sentido
• IN1 -> LOW; IN2 -> HIGH : gira en el sentido contrario

Para controlar la velocidad de giro de los motores tenemos que quitar los jumpers y usar los pines ENA y ENB. Los conectaremos a dos salidas PWM de Arduino de forma que le enviemos un valor entre 0 y 255 que controle la velocidad de giro. Si tenemos los jumpers colocados, los motores girarán siempre a la misma velocidad.

El esquema de montaje que vamos a utilizar va a ser el siguiente, aunque podéis usar los pines que queráis siempre que respetemos que los que conectemos a ENA y ENB sean PWM.

PROGRAMACIÓN

Sabiendo todo esto, ya estamos en posición de empezar a programar. Vamos a hacer un ensayo que mueva los motores en ambos sentidos, adelante y atrás, y en sentidos contrarios el uno del otro, variando también la velocidad de movimiento.

Comenzamos asignando los pines que vamos a usar y declarándolos como salida:

// Motor 1
int ENA = 10;
int IN1 = 9;
int IN2 = 8;

// Motor 2
int ENB = 5;
int IN3 = 7;
int IN4 = 6;

void setup (){
 // Declaramos todos los pines como salidas
 pinMode (ENA, OUTPUT);
 pinMode (ENB, OUTPUT);
 pinMode (IN1, OUTPUT);
 pinMode (IN2, OUTPUT);
 pinMode (IN3, OUTPUT);
 pinMode (IN4, OUTPUT);
}
void Adelante (){
 //Dirección motor A
 digitalWrite (IN1, HIGH);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 100); //Velocidad motor A
 //Dirección motor B
 digitalWrite (IN3, HIGH);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 100); //Velocidad motor B
}
void Atras (){
 //Dirección motor A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, HIGH);
 analogWrite (ENA, 128); //Velocidad motor A
 //Dirección motor B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, HIGH);
 analogWrite (ENB, 128); //Velocidad motor B
}
void Derecha (){
 //Dirección motor A
 digitalWrite (IN1, HIGH);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 200); //Velocidad motor A
 //Dirección motor B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, HIGH);
 analogWrite (ENB, 100); //Velocidad motor A
}
void Izquierda (){
 //Dirección motor A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, HIGH);
 analogWrite (ENA, 50); //Velocidad motor A
 //Dirección motor B
 digitalWrite (IN3, HIGH);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 150); //Velocidad motor A
}
void Parar (){
 //Dirección motor A
 digitalWrite (IN1, LOW);
 digitalWrite (IN2, LOW);
 analogWrite (ENA, 0); //Velocidad motor A
 //Dirección motor B
 digitalWrite (IN3, LOW);
 digitalWrite (IN4, LOW);
 analogWrite (ENB, 0); //Velocidad motor A
}
void loop (){
 Adelante ();
 delay (5000);
 Atras ();
 delay (2000);
 Derecha ();
 delay (2000);
 Izquierda ();
 delay (2000);
 Parar ();
 delay (4000);
}

Como podéis observar en el código se han creado 4 funciones con las diferentes posibilidades de marcha y una para detener los motores. La funciones son:

• Adelante
• Atras
• Derecha
• Izquierda
• Parar

¿Y si lo hacemos con la biblioteca LEANTEC_ControlMotor.h?

Esta librería controla la velocidad y la dirección de los motores del robot. La forma de usarla es así:

Configuramos los pines con la sentencia:

ControlMotor control (MotorDer1, MotorDer2, MotorIzq1, MotorIzq2, PWM_Derecho, PWM_Izquierdo)

• • MotorDer1: Enable 1 del motor Derecho (Pin 7)
  • MotorDer2: Enable 2 del motor Derecho (Pin 6)
  • MotorIzq1: Enable 1 del motor Izquierdo (Pin 9)
  • MotorIzq2: Enable 2 del motor Izquierdo (Pin 8)
  • PWM_Derecho: PWM del motor derecho (Debe ser un pin que admita PWM de Arduino, pin 5)
  • PWM_Izquierdo: PWM del motor Izquierdo (Debe ser un pin que admita PWM de Arduino, pin 10)

Para controlar el motor utilizamos la función:

control.Motor(Velocidad, giro);

La primera variable es la velocidad que va de 0 a 255 y la segunda el % de giro que va de 0 a 100. Si la velocidad es positiva el robot va hacia delante, si la velocidad es negativa el robot retrocede. Para girar a la derecha el giro debe ser mayor a 0, para la izquierda menor que cero, y si el giro es de 100 gira sobre su propio eje (una rueda avanza y otra retrocede). En resumen:

• • Giro a la derecha > 0
  • Giro a la izquierda < 0
  • Giro sobre su propio eje 100

Para este código utilizamos el mismo esquema de montaje que en el anterior.

#include  "LEANTEC_ControlMotor.h" //Incluimos la librería control de motores 
// Configuramos los pines que vamos a usar
ControlMotor control(7,6,9,8,5,10); // MotorDer1,MotorDer2,MotorIzq1,MotorIzq2,PWM_Derecho,PWM_Izquierdo

void setup(){ 
  //En esta ocasión no necesitamos configurar pines ya que la librería lo hace.
} 
 
void loop() {
  // hacia delante
  control.Motor(150,1);
  delay (3000);
  // retrocede
  control.Motor(-150,1);
  delay(3000);
  // a la izquierda
  control.Motor(150,100);
  delay(3000);
  // a la derecha
  control.Motor(200,-100);
  delay(3000);
  // parar
  control.Motor(0,1);
  delay(3000);
}