Controlador de Motor L298N con Arduino: Guía Completa, Esquemas y Código

En este tutorial de Arduino aprenderemos a controlar motores DC. Veremos técnicas básicas y haremos dos ejemplos para aprender a controlar motores DC usando el driver L298N y la placa Arduino.

Puedes ver el video o leer el tutorial a continuación.

Control PWM de Motor DC

Podemos controlar la velocidad del motor DC simplemente controlando el voltaje de entrada. El método más común es usando señal PWM.

PWM (modulación por ancho de pulso) permite ajustar el valor promedio del voltaje que llega al dispositivo encendiendo y apagando la energía a alta velocidad. El voltaje promedio depende del ciclo de trabajo (duty cycle), es decir, la proporción de tiempo que la señal está ON vs OFF en un período.

Según el tamaño del motor, podemos conectar una salida PWM de Arduino a la base de un transistor o gate de un MOSFET y controlar la velocidad controlando la salida PWM. La señal PWM de baja potencia enciende y apaga el gate del MOSFET por donde circula la alta potencia del motor.

Control de Motor DC con Puente H

Para controlar la dirección de rotación, invertimos el sentido de la corriente a través del motor. El método más común es usar un Puente H. Un circuito Puente H contiene cuatro elementos de conmutación (transistores o MOSFETs) con el motor en el centro formando una configuración en H. Activando dos interruptores particulares a la vez cambiamos la dirección de la corriente, cambiando así la rotación del motor.

Combinando PWM y Puente H tenemos control total sobre el motor DC. Hay muchos drivers con estas características y el L298N es uno de ellos.

Driver L298N

El L298N es un driver de doble Puente H que permite control de velocidad y dirección de dos motores DC simultáneamente. El módulo puede manejar motores de 5 a 35V, con corriente pico de 2A.

Veamos el pinout del L298N y cómo funciona. Tiene dos bloques de terminales para motor A y B, y otro para Tierra, VCC del motor y un pin de 5V que puede ser entrada o salida.

Esto depende del voltaje en VCC del motor. El módulo tiene un regulador de 5V integrado que se habilita/deshabilita con un jumper. Si el voltaje del motor es hasta 12V podemos habilitar el regulador y el pin 5V sirve como salida (ej. para alimentar Arduino). Si el voltaje supera 12V debemos quitar el jumper para no dañar el regulador; entonces el pin 5V será entrada y necesitaremos conectarle 5V para que el IC funcione.

Este IC tiene una caída de voltaje de ~2V. Por ejemplo, con 12V en la entrada, en los terminales del motor tendremos ~10V, no logrando la velocidad máxima de un motor de 12V.

Entradas de control lógico: Enable A y Enable B activan y controlan la velocidad. Si hay jumper, el motor va a máxima velocidad; si lo quitamos y conectamos PWM, controlamos la velocidad. Si conectamos a Tierra, el motor se desactiva.

Input 1 e Input 2 controlan la dirección del motor A; Input 3 e Input 4 la del motor B. Controlan los interruptores del Puente H interno. Si In1=LOW e In2=HIGH → adelante; inverso → atrás. Si ambas iguales (LOW o HIGH) → motor parado. Lo mismo para In3/In4 y motor B.

Arduino y Driver L298N

Hagamos aplicaciones prácticas. Primer ejemplo: controlar velocidad con potenciómetro y dirección con pulsador. Esquema:

Necesitas: driver L298N, motor DC, potenciómetro, pulsador, Arduino.

Componentes:

• Driver L298N ………………………………..
• Motor DC alto torque 12V …………..
• Motor DC con rueda plástica …….
• Placa Arduino ………………………………
• Protoboard y cables …………

Código Arduino

/* Control Motor DC Arduino - PWM | Puente H | L298N - Ejemplo 01
by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 6
#define in2 7
#define button 4
int rotDirection = 0;
int pressed = false;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(button, INPUT);
  // Dirección inicial
  digitalWrite(in1, LOW);
  digitalWrite(in2, HIGH);
}

void loop() {
  int potValue = analogRead(A0); // Leer potenciómetro
  int pwmOutput = map(potValue, 0, 1023, 0, 255); // Mapear 0-1023 a 0-255
  analogWrite(enA, pwmOutput); // Enviar PWM a pin Enable L298N
  // Leer botón - Antirrebote
  if (digitalRead(button) == true) {
    pressed = !pressed;
  }
  while (digitalRead(button) == true);
  delay(20);
  // Si botón presionado - cambiar dirección
  if (pressed == true && rotDirection == 0) {
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
    rotDirection = 1;
    delay(20);
  }
  if (pressed == false && rotDirection == 1) {
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
    rotDirection = 0;
    delay(20);
  }
}

Descripción: Definimos pines y variables. En setup configuramos modos de pin y dirección inicial. En loop leemos el potenciómetro, mapeamos su valor (0-1023) a 0-255 para PWM (0-100% ciclo de trabajo) y enviamos la señal PWM al pin Enable del L298N.

Verificamos si se presionó el botón (con antirrebote) y cambiamos la dirección invirtiendo estados de Input 1 e Input 2. El pulsador funciona como toggle: cada presión invierte la dirección.

Control de Coche Robot Arduino con L298N

Ahora construimos nuestro coche robot. Esquema:

Necesitas: 2 motores DC, driver L298N, Arduino, joystick. Para alimentación usé tres baterías Li-ion 3.7V (11V total). Chasis de contrachapado 3mm, motores con soportes metálicos, ruedas y rueda loca delantera.

Código Arduino (abajo está el completo):

int xAxis = analogRead(A0); // Leer eje X joystick
int yAxis = analogRead(A1); // Leer eje Y joystick

Tras definir pines, en loop leemos ejes X e Y del joystick. Este tiene dos potenciómetros en entradas analógicas (valores 0-1023). En posición central ambos valen ~512.

Consideramos centro el rango 470-550. Si movemos eje Y hacia atrás (<470) ponemos ambos motores en reversa y convertimos valores descendentes (470→0) en PWM ascendente (0→255).

// Eje Y para control adelante/atrás
if (yAxis < 470) {
  digitalWrite(in1, HIGH); digitalWrite(in2, LOW); // Motor A atrás
  digitalWrite(in3, HIGH); digitalWrite(in4, LOW); // Motor B atrás
  motorSpeedA = map(yAxis, 470, 0, 0, 255);
  motorSpeedB = map(yAxis, 470, 0, 0, 255);
}

Si movemos eje Y adelante (>550) ponemos motores adelante y convertimos 550→1023 a PWM 0→255. En centro, velocidad cero.

Eje X para giro izquierda/derecha:

// Eje X para control izquierda/derecha
if (xAxis < 470) {
  int xMapped = map(xAxis, 470, 0, 0, 255);
  // Girar izquierda: reducir motor izquierdo, aumentar derecho
  motorSpeedA = motorSpeedA - xMapped;
  motorSpeedB = motorSpeedB + xMapped;
  if (motorSpeedA < 0) motorSpeedA = 0;
  if (motorSpeedB > 255) motorSpeedB = 255;
}

Convertimos lecturas X a valores de velocidad 0-255. Para girar izquierda, reducimos motor izquierdo y aumentamos derecho. Usamos "if" extra para limitar rango 0-255.

Mismo método para girar derecha.

Relacionado: Cómo hacer controlador velocidad motor PWM con temporizador 555

Según voltaje y motor, a bajas velocidades el motor no arranca y zumba. En mi caso, no arrancaban con PWM <70. Así que limité el rango a 70-255. Al final enviamos velocidades finales (PWM) a los pines Enable del L298N.

// Evitar zumbido a bajas velocidades (ajustar según tus motores)
if (motorSpeedA < 70) motorSpeedA = 0;
if (motorSpeedB < 70) motorSpeedB = 0;
analogWrite(enA, motorSpeedA); // PWM motor A
analogWrite(enB, motorSpeedB); // PWM motor B

Código completo del coche robot:

/* Control Motor DC Arduino - PWM | Puente H | L298N Ejemplo 02 - Control Coche Robot
by Dejan Nedelkovski, www.HowToMechatronics.com */
#define enA 9
#define in1 4
#define in2 5
#define enB 10
#define in3 6
#define in4 7
int motorSpeedA = 0;
int motorSpeedB = 0;

void setup() {
  pinMode(enA, OUTPUT);
  pinMode(enB, OUTPUT);
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
}

void loop() {
  int xAxis = analogRead(A0);
  int yAxis = analogRead(A1);
  // Eje Y adelante/atrás
  if (yAxis < 470) {
    digitalWrite(in1, HIGH); digitalWrite(in2, LOW);
    digitalWrite(in3, HIGH); digitalWrite(in4, LOW);
    motorSpeedA = map(yAxis, 470, 0, 0, 255);
    motorSpeedB = map(yAxis, 470, 0, 0, 255);
  } else if (yAxis > 550) {
    digitalWrite(in1, LOW); digitalWrite(in2, HIGH);
    digitalWrite(in3, LOW); digitalWrite(in4, HIGH);
    motorSpeedA = map(yAxis, 550, 1023, 0, 255);
    motorSpeedB = map(yAxis, 550, 1023, 0, 255);
  } else {
    motorSpeedA = 0; motorSpeedB = 0;
  }
  // Eje X izquierda/derecha
  if (xAxis < 470) {
    int xMapped = map(xAxis, 470, 0, 0, 255);
    motorSpeedA = motorSpeedA - xMapped;
    motorSpeedB = motorSpeedB + xMapped;
    if (motorSpeedA < 0) motorSpeedA = 0;
    if (motorSpeedB > 255) motorSpeedB = 255;
  }
  if (xAxis > 550) {
    int xMapped = map(xAxis, 550, 1023, 0, 255);
    motorSpeedA = motorSpeedA + xMapped;
    motorSpeedB = motorSpeedB - xMapped;
    if (motorSpeedA > 255) motorSpeedA = 255;
    if (motorSpeedB < 0) motorSpeedB = 0;
  }
  // Evitar zumbido
  if (motorSpeedA < 70) motorSpeedA = 0;
  if (motorSpeedB < 70) motorSpeedB = 0;
  analogWrite(enA, motorSpeedA);
  analogWrite(enB, motorSpeedB);
}

Eso es todo. En el próximo video mejoraremos este coche añadiendo Bluetooth y radio para control por smartphone e inalámbrico.

Preguntas en comentarios y revisa mi colección de proyectos Arduino.