Control de motores de corriente continua con ESP32 y módulo L298N

¡Hola equipo! Bienvenidos a Ingtelecto Pro. Hoy vamos a transformar nuestro ESP32 de un simple "cerebro estático" a una máquina capaz de mover cosas en el mundo real. 🤖💨

Si alguna vez has intentado conectar un motor directamente a un microcontrolador, probablemente hayas notado que no funciona (y si insistes, verás humo). Los microcontroladores son débiles; pueden "pensar" rápido, pero no tienen la fuerza para mover un motor.

Aquí es donde entra el legendario L298N. Es el "músculo" que obedece al ESP32 para mover cargas pesadas. En este tutorial aprenderás a controlar la velocidad y el sentido de giro de dos motores DC, la base fundamental de cualquier carrito robot.

Analogía del Mundo Real: El Grifo de Agua

Imagina que quieres llenar una piscina. Tú (el ESP32) no tienes la fuerza para abrir la compuerta gigante de la presa. Pero sí tienes fuerza para girar una pequeña llave (Señal de Control).

Esa llave le dice al sistema hidráulico (L298N) que abra la compuerta real.

  • Dirección: ¿El agua sale o entra? (H-Bridge)
  • Velocidad: ¿Abro la llave al 100% o solo un poquito? (PWM)
Índice de contenido
  1. Materiales Necesarios
  2. Fundamentos Técnicos: ¿Cómo funciona la magia?
  3. Pinout del L298N y Consideraciones de Voltaje ⚡
  4. Conexiones y Diagramas ⚙️
    1. Tabla de Conexiones
  5. Código Maestro: Control Total
    1. Explicación Detallada del Código
  6. Solución de Problemas Comunes
  7. Conclusión

Materiales Necesarios

Vamos a montar el sistema de tracción básico.

Lista de Componentes ✅

  • 1 x Placa ESP32 (Cualquier modelo).
  • 1 x Módulo Controlador L298N (El disipador rojo clásico).
  • 2 x Motores DC con caja reductora (Los amarillos "TT Motors" son perfectos).
  • 1 x Fuente de poder externa (Batería de 9V, Portapilas AA o LiPo 7.4V).
  • Cables Jumper (Macho-Hembra y Macho-Macho).

Fundamentos Técnicos: ¿Cómo funciona la magia?

Puente H (H-Bridge)

Es un circuito interno que permite invertir la polaridad del motor.

  • Si le aplicas (+ y -), el motor gira a la derecha.
  • Si le aplicas (- y +), el motor gira a la izquierda.

El L298N tiene dos de estos puentes, por eso puede controlar dos motores independientemente.

PWM (Pulse Width Modulation)

Es la técnica para controlar la velocidad. En lugar de bajar el voltaje (que le quita fuerza al motor), encendemos y apagamos la energía muy rápido.

  • Ciclo 100%: Siempre encendido (Máxima velocidad).
  • Ciclo 50%: Mitad encendido, mitad apagado (Media velocidad).
  • Ciclo 0%: Siempre apagado (Detenido).

Pinout del L298N y Consideraciones de Voltaje ⚡

Este módulo tiene su truco. Presta atención para no quemar nada.

  • 12V (o VS): Entrada de energía para los motores (De 5V a 35V). ¡Aquí va tu batería externa!
  • GND: Tierra común. IMPORTANTE: Debes conectar aquí el negativo de tu batería Y TAMBIÉN el pin GND de tu ESP32. Si no unes las tierras, no funcionará.
  • 5V: Salida de energía. Si tu batería es de menos de 12V, este pin entrega 5V regulados que puedes usar para alimentar tu ESP32 (Pin VIN).
  • ENA / ENB: Habilitadores de velocidad. Si dejas el jumper puesto, van siempre al 100%. Si quitas el jumper, puedes inyectar PWM para regular velocidad.
  • IN1 - IN4: Pines de dirección.

Conexiones y Diagramas ⚙️

Vamos a conectar todo. Usaremos una configuración clásica para un robot diferencial (dos ruedas).

Tabla de Conexiones

Módulo L298N ESP32 / Batería
12V / VS Positivo (+) Batería Externa
GND Negativo (-) Batería y GND ESP32
IN1 GPIO 27
IN2 GPIO 26
IN3 GPIO 25
IN4 GPIO 33
ENA (Sin Jumper) GPIO 14
ENB (Sin Jumper) GPIO 32

Nota: Si tus motores son pequeños (tipo TT amarillos), aliméntalos con entre 6V y 9V. Si usas 12V directos podrían calentarse mucho.

Código Maestro: Control Total

Este código utiliza las funciones nativas más recientes del ESP32 para manejar PWM (`ledcAttachChannel`).

// TUTORIAL INGTELECTO PRO - ROBOT ESP32 L298N

// Control de Dirección y Velocidad
// --- DEFINICIÓN DE PINES ---

// Motor A (Derecha)

const int enA = 14; // Pin de Velocidad (PWM)

const int in1 = 27; // Dirección 1

const int in2 = 26; // Dirección 2
// Motor B (Izquierda)

const int enB = 32; // Pin de Velocidad (PWM)

const int in3 = 25; // Dirección 1

const int in4 = 33; // Dirección 2
// --- CONFIGURACIÓN PWM ---

const int freq = 1000; // Frecuencia 1 KHz (Ideal para motores)

const int pwmChannelA = 0; // Canal interno 0

const int pwmChannelB = 1; // Canal interno 1

const int resolution = 8; // Resolución 8 bits (Valores 0 a 255)
void setup() {

// 1. Configurar pines de dirección como SALIDA

pinMode(in1, OUTPUT);

pinMode(in2, OUTPUT);

pinMode(in3, OUTPUT);

pinMode(in4, OUTPUT);
// 2. Configurar pines PWM (Nueva API ESP32 3.0+)

// Asociamos el pin físico al canal y frecuencia

ledcAttachChannel(enA, freq, resolution, pwmChannelA);

ledcAttachChannel(enB, freq, resolution, pwmChannelB);
Serial.begin(115200);

Serial.println("Robot Iniciado - Motores Listos");

}
void loop() {

Serial.println("Movimiento: ADELANTE a media velocidad");

moverAdelante(128); // Velocidad 0-255 (128 es 50%)

delay(2000);
Serial.println("Movimiento: GIRO RÁPIDO");

girarDerecha(200);

delay(1500);
Serial.println("Movimiento: DETENIDO");

detenerMotores();

delay(2000);
Serial.println("Movimiento: ATRÁS suave");

moverAtras(100);

delay(2000);

}
// --- FUNCIONES DE CONTROL ---
void moverAdelante(int velocidad) {

// Motor A Adelante

digitalWrite(in1, HIGH);

digitalWrite(in2, LOW);

ledcWrite(enA, velocidad); // Aplicar PWM
// Motor B Adelante

digitalWrite(in3, HIGH);

digitalWrite(in4, LOW);

ledcWrite(enB, velocidad);

}
void moverAtras(int velocidad) {

// Invertimos la lógica de los pines IN

digitalWrite(in1, LOW);

digitalWrite(in2, HIGH);

ledcWrite(enA, velocidad);
digitalWrite(in3, LOW);

digitalWrite(in4, HIGH);

ledcWrite(enB, velocidad);

}
void girarDerecha(int velocidad) {

// Motor A Atras, Motor B Adelante (Giro sobre su eje)

digitalWrite(in1, LOW);

digitalWrite(in2, HIGH);

ledcWrite(enA, velocidad);
digitalWrite(in3, HIGH);

digitalWrite(in4, LOW);

ledcWrite(enB, velocidad);

}
void detenerMotores() {

// Todo en LOW para frenar

digitalWrite(in1, LOW);

digitalWrite(in2, LOW);

digitalWrite(in3, LOW);

digitalWrite(in4, LOW);

ledcWrite(enA, 0);

ledcWrite(enB, 0);

}

Explicación Detallada del Código

  • ledcAttachChannel(): Esta es la forma moderna de activar PWM en el ESP32. Le dice al chip: "Prepara el temporizador para generar pulsos en este pin".
  • ledcWrite(pin, valor): Es el equivalente a analogWrite(). Un valor de 0 apaga el motor, 255 lo pone al máximo.
  • Funciones Modulares: En lugar de escribir todo en el loop, creamos funciones como moverAdelante(). Esto hace tu código mucho más limpio y fácil de reutilizar cuando le agregues sensores o WiFi.

Solución de Problemas Comunes

¿Los motores no giran o hacen un zumbido?

  • Zumbido sin movimiento: La velocidad (PWM) es muy baja. Los motores DC necesitan un "empujón" inicial. Prueba con valores superiores a 100 o 150.
  • No hace nada: Revisa el interruptor del L298N (algunos tienen un botón de encendido) y asegúrate de haber conectado las tierras (GND) juntas.
  • Giran al revés: No cambies el código. Simplemente invierte los cables rojo y negro del motor en el conector verde del L298N.

Conclusión

¡Tu Robot Tiene Vida! 🤖

Acabas de superar el obstáculo más grande en robótica: la etapa de potencia. Ya sabes cómo controlar la fuerza bruta de los motores con la inteligencia del ESP32.

¿Qué sigue?
Ahora que se mueve, ¿por qué no le das "ojos"? En el próximo tutorial podríamos integrar un Sensor Ultrasónico HC-SR04 para que tu robot esquive obstáculos automáticamente.

¡Sigue construyendo!

Carlos Julián

Carlos Julián es el fundador de Ingtelecto, es Ingeniero Mecatrónico, Profesor y Programador, cuenta con una Maestria en Ciencias de la Educación, creador de contenido educativo en redes sociales. Lee más sobre mi trayectoria aquí.

Estos temas te pueden interesar

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *

Tu puntuación: Útil

Subir