¿Qué es un L298N?
El L298N es un controlador (driver) de motores, que permite encender y controlar dos motores de corriente continua desde Arduino, variando tanto la dirección como la velocidad de giro.
Como comentamos frecuentemente Arduino, y en general todos los autómatas, no disponen de potencia suficiente para mover actuadores. De hecho, la función de un procesador no debe ser ejecutar acciones si no mandar ejecutar acciones a drivers que realicen el “trabajo pesado”.
El L298N también puede controlar un único motor de paso a paso aunque, en general, preferiremos usar dispositivos específicamente diseñados para motores paso a paso.
La corriente máxima que el L298N puede suministrar a los motores es, en teoría, 2A por salida (hasta 3A de pico) y una tensión de alimentación de 3V a 35V.
Sin embargo, el L298N tiene una eficiencia baja. La electrónica supone una caída de tensión de unos 3V, es decir, la tensión que recibe el motor es unos 3V inferior a la tensión de alimentación.
Estas pérdidas se disipan en forma de calor lo que se traduce en que, a efectos prácticos, es difícil que podamos obtener más de 0.8-1A por fase sin exceder el rango de temperatura de funcionamiento.
El L298N incorpora protecciones contra efectos que pueden producirse al manejar motores de corriente continua. Dispone de protecciones contra sobre intensidad, sobre temperatura, y diodos de protección contra corrientes inducidas (flyback).
El controlador L298N es ampliamente usado en proyectos electrónico y robótica, por su sencillez de uso, bajo coste, y buena calidad precio.
Precio
Es controlador L298N es un componente barato, podemos encontrarlo por 1,40€ en vendedores internacionales de AliExpress o eBay.
¿Cómo funciona un L298N?
Básicamente un L298N consiste en dos puentes-H, uno para la salida A y otro para la salida B.
Un puente-H es un componente ampliamente utilizado en electrónica para alimentar una carga de forma que podemos invertir el sentido de la corriente que le atraviesa.
Internamente un puente-H es una formación de 4 transistores, conectados entre Vcc y GND, con la carga a alimentar entre ellos. Dibujado en esquema el conjunto tiene forma de “H”, de la que recibe su nombre su nombre.
Actuando sobre los 4 transistores, activando los transistores opuestos en diagonal de cada rama, podemos variar el sentido en el que la corriente atraviesa la carga
Conectando simultáneamente los transistores superiores o inferiores, podemos poner la carga Vcc o Gnd respectivamente, configuración que usaremos como freno.
Por último, nunca debemos encender ambos transistores de un mismo ramal (izquierda o derecha), ya que estaremos provocando un cortocircuito entre Vcc y GND.
La placa L298N incorpora electrónica que simplifica la conexión al puente H, agrupando las conexiones en 3 pines accesibles (por cada salida) y eliminando la posibilidad de generar un cortocircuito.
Dos de estos pines, IN1 y IN2 (IN3 y IN4 para la salida B), controlan el encendido de los transistores de cada una de las dos ramas, encendiendo el ramal superior o inferior de la misma.
El tercer pin (IEA/IEB) desactiva simultáneamente todos los transistores del puente-H, desconectando la carga por completo.
Esquema montaje
La placa de conexión del L298N incorpora una entrada de voltaje, una serie de jumpers para configurar el módulo, dos salidas A y B, y los pines de entrada que regulan la velocidad y el sentido de giro.
La entrada de tensión proporciona el voltaje que alimentará a los motores. El rango de entrada admisible es de 3V a 35V y se suministra mediante los 2 terminales izquierdos de la clema de conexión entrada.
El tercer terminal de la clema de conexión, Vlógico, está conectado con la electrónica del L298N y es necesario que tenga un valor entre 4.5 y 5.5V para que la placa funcione correctamente.
Para ello el módulo incorpora un regulador de voltaje que suministra la tensión necesaria en Vlógico. Este regulador puede desactivarse quitando el jumper de la placa. Desactivaremos el regulador cuando la tensión de alimentación sea inferior a 5V o superior a 15V.
Por tanto:
- Si el regulador está activado (jumper cerrado) Vlógico es una salida de 5V que podemos emplear para alimentar otros dispositivos.
- Si el regulador está desactivado (jumper abierto), Vlógico es una entrada a la que tendremos que proporcionar un voltaje de 4.5 a 5.5V.
No debemos introducir corriente en Vlógico con el regulador activado (jumper conectado) o podemos dañar el módulo.
Por otro lado, tenemos las dos clemas de conexión A y B que suministran la salida a los motores.
Por último, tenemos los pines de entrada que controlan la dirección y velocidad de giro.
- Los pines IEA, IN1 e IN2 controlan la salida A.
- Los pines IEB, IN3 e IN4 controlan la salida B.
Los pines IN1, IN2, y IN3 e IN4, controlan la dirección de giro, respectivamente, de la salida A y B.
Los pines IEA y IEB desactivan la salida. Podemos conectarlos permanentemente mediante el uso de un jumper, o conectar una señal PWM para controlar la velocidad de giro.
En el caso de querer usar ambas fases, y poder elegir tanto el sentido de giro como la velocidad, y alimentar desde una fuente de 12V, el esquema de conexión a Arduino sería el siguiente.
Mientras que la conexión, vista desde el lado de Arduino, sería la siguiente.
La alimentación de Arduino en este caso podría realizarse desde la fuente de 12V al pin Vin de Arduino (usando el regulador de voltaje de Arduino), o desde el pin Vlogico del L298N al pin 5V de Arduino (usando el regulador del L298N).
Siempre que uséis más de una fuente de tensión recordar poner en común todos los GND incluido el de Arduino. De lo contrario podéis dañar un componente.
Ejemplos de código
Para controlar los dos motores, debemos activar correctamente las salidas digitales conectadas a los pines IN1 y IN2 (salida A), o los pines IN3 e IN4 (salida B).
Las posibles combinaciones son:
| Adelante | Atrás | Freno | |
|---|---|---|---|
| IN1 (o IN3) | HIGH | LOW | LOW |
| IN2 (o IN4) | LOW | HIGH | LOW |
Respecto a los pines IEA y IEB, usaremos una salida PWM para controlar la velocidad de giro.
El siguiente código mueve hacia adelante el motor de la salida A al 80% de velocidad.
const int pinENA = 6;
const int pinIN1 = 7;
const int pinIN2 = 8;
const int speed = 200; //velocidad de giro 80% (200/255)
void setup()
{
pinMode(pinIN1, OUTPUT);
pinMode(pinIN2, OUTPUT);
pinMode(pinENA, OUTPUT);
}
void loop()
{
digitalWrite(pinIN1, HIGH);
digitalWrite(pinIN2, LOW);
analogWrite(pinENA, speed);
delay(1000);
}El código necesario para controlar el L298N no es complicado pero si no somos limpios puede crecer rápidamente de tamaño, lo cuál será un problema cuando lo integremos en proyectos más grandes, como vehículos o robots.
Por tanto resulta conveniente agrupar y reutilizar el código en funciones que simplifiquen su uso.
El siguiente código enciende ambos motores en un sentido, a continuación en sentido contrario, y finalmente los para por completo, para después volver a iniciar el ciclo.
const int pinENA = 6;
const int pinIN1 = 7;
const int pinIN2 = 8;
const int pinIN3 = 9;
const int pinIN4 = 10;
const int pinENB = 11;
const int waitTime = 2000; //espera entre fases
const int speed = 200; //velocidad de giro
const int pinMotorA[3] = { pinENA, pinIN1, pinIN2 };
const int pinMotorB[3] = { pinENB, pinIN3, pinIN4 };
void setup()
{
pinMode(pinIN1, OUTPUT);
pinMode(pinIN2, OUTPUT);
pinMode(pinENA, OUTPUT);
pinMode(pinIN3, OUTPUT);
pinMode(pinIN4, OUTPUT);
pinMode(pinENB, OUTPUT);
}
void loop()
{
moveForward(pinMotorA, 180);
moveForward(pinMotorB, 180);
delay(waitTime);
moveBackward(pinMotorA, 180);
moveBackward(pinMotorB, 180);
delay(waitTime);
fullStop(pinMotorA);
fullStop(pinMotorB);
delay(waitTime);
}
void moveForward(const int pinMotor[3], int speed)
{
digitalWrite(pinMotor[1], HIGH);
digitalWrite(pinMotor[2], LOW);
analogWrite(pinMotor[0], speed);
}
void moveBackward(const int pinMotor[3], int speed)
{
digitalWrite(pinMotor[1], LOW);
digitalWrite(pinMotor[2], HIGH);
analogWrite(pinMotor[0], speed);
}
void fullStop(const int pinMotor[3])
{
digitalWrite(pinMotor[1], LOW);
digitalWrite(pinMotor[2], LOW);
analogWrite(pinMotor[0], 0);
}Como vemos, con las funciones que hemos hecho resulta sencillo mover un robot adelante y atrás, e incluso es sencillo usarlas para hacer que gire o haga trayectorias. En un proyecto complejo, funciones similares estuvieran integradas dentro de nuestro modelo de objetos.
Usaremos el controlador de motores L298N frecuentemente en nuestros proyectos, y dentro de poco veremos algún proyecto como robots o vehículos que hacen uso del L298N.
Descarga el código
Todo el código de esta entrada está disponible para su descarga en Github. 