Diseño y Construcción de un Robot Móvil Diferencial Controlado por ESP32

¡Bienvenido al fascinante mundo de la robótica móvil! 🤖 En este tutorial, te embarcarás en el proyecto de construir un robot móvil diferencial desde cero, utilizando el versátil microcontrolador ESP32. Este tipo de robot es ideal para aprender los fundamentos de la cinemática, la electrónica y la programación robótica.

🎯 ¿Qué Aprenderás en Este Tutorial?

Al finalizar esta guía, serás capaz de:

• Comprender los principios de funcionamiento de un robot diferencial.
• Seleccionar los componentes electrónicos y mecánicos adecuados.
• Realizar el montaje físico de la plataforma robótica.
• Programar el ESP32 para controlar los motores DC.
• Entender la importancia de la alimentación eléctrica en robótica.

🛠️ Materiales Necesarios

Para embarcarte en este proyecto, necesitarás los siguientes materiales. La mayoría son fáciles de conseguir en tiendas de electrónica o en línea.

📖 Fundamentos del Robot Móvil Diferencial

Un robot diferencial es un tipo de robot móvil que utiliza dos ruedas motrices montadas en un eje común, cada una impulsada por un motor independiente. Una o más ruedas pasivas (ruedas locas) se utilizan para el equilibrio y el soporte.

¿Cómo se Mueve?

• Hacia adelante/atrás: Ambas ruedas giran a la misma velocidad en la misma dirección.
• Giro sobre el eje: Una rueda gira hacia adelante y la otra hacia atrás a la misma velocidad.
• Giro por arco: Una rueda gira más rápido que la otra o solo una rueda gira, haciendo que el robot pivote alrededor de la rueda más lenta o estacionaria.

Aquí tienes un diagrama simple de la configuración:

⚙️ Montaje Mecánico: Paso a Paso

El montaje mecánico es la base de tu robot. Tómate tu tiempo para asegurar que todo esté firme y bien alineado.

Importante El equilibrio del robot es crucial. Un centro de gravedad mal ubicado puede afectar la estabilidad y la tracción.

🔌 Conexiones Electrónicas: Diagrama de Cableado

Las conexiones son el cerebro y el sistema nervioso de tu robot. ¡Presta mucha atención!

Utilizaremos un driver L298N por su simplicidad y capacidad para manejar dos motores DC. Si usas un TB6612FNG, las conexiones serán similares, pero con menos pines.

Aquí tienes un diagrama de conexión clave:

Tabla de Conexiones (ESP32 y L298N)

Alimentación Eléctrica

1. Conecta tu batería LiPo al módulo regulador de voltaje (buck converter).
2. Ajusta el regulador para que la salida sea de 5V. Usa un multímetro para verificar con precisión.
3. Conecta la salida de 5V del regulador al pin 5V del ESP32 y también al pin +5V (lógica) del L298N (si lo tiene y si no estás usando su regulador interno para el ESP32).
4. Conecta el voltaje completo de la batería (sin regular) a los pines +12V (motor power) del L298N.
5. Conecta los pines GND de la batería, el regulador, el ESP32 y el L298N entre sí.

✍️ Programación del ESP32: El Código de Control

Ahora viene la parte donde le damos vida a nuestro robot. Utilizaremos el IDE de Arduino y C++ para programar el ESP32. Primero, asegúrate de tener el soporte para ESP32 instalado en tu IDE (puedes buscar tutoriales en línea sobre cómo hacerlo).

Configuración del IDE de Arduino

1. Abre el IDE de Arduino.
2. Ve a Archivo > Preferencias y añade https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json en URLs adicionales de gestores de tarjetas.
3. Ve a Herramientas > Placa > Gestor de tarjetas... Busca esp32 e instálalo.
4. Selecciona tu placa ESP32 (ESP32 Dev Module o similar) en Herramientas > Placa.

Código Básico para Control de Motores

Este código te permitirá mover el robot hacia adelante, hacia atrás, girar y detenerse. Implementaremos funciones simples para cada acción.

// Definición de pines para el Motor A (Izquierdo)
const int in1 = 16; // Pin IN1 del L298N
const int in2 = 17; // Pin IN2 del L298N
const int enA = 13; // Pin ENA (PWM) del L298N

// Definición de pines para el Motor B (Derecho)
const int in3 = 18; // Pin IN3 del L298N
const int in4 = 19; // Pin IN4 del L298N
const int enB = 12; // Pin ENB (PWM) del L298N

// Configuración de canales PWM para ESP32
const int freq = 30000; // Frecuencia PWM (Hz)
const int ledChannelA = 0;
const int ledChannelB = 1;
const int resolution = 8; // Resolución PWM (8 bits = 0-255)

void setup() {
  // Configurar pines de dirección como salida
  pinMode(in1, OUTPUT);
  pinMode(in2, OUTPUT);
  pinMode(in3, OUTPUT);
  pinMode(in4, OUTPUT);
  
  // Configurar pines PWM
  ledcSetup(ledChannelA, freq, resolution);
  ledcAttachPin(enA, ledChannelA);
  ledcSetup(ledChannelB, freq, resolution);
  ledcAttachPin(enB, ledChannelB);

  Serial.begin(115200);
  Serial.println("Robot diferencial iniciado!");
}

// Función para mover el Motor A (Izquierdo)
void moveMotorA(int speed) {
  if (speed > 0) { // Adelante
    digitalWrite(in1, HIGH);
    digitalWrite(in2, LOW);
  } else if (speed < 0) { // Atrás
    digitalWrite(in1, LOW);
    digitalWrite(in2, HIGH);
  } else { // Detener
    digitalWrite(in1, LOW);
    digitalWrite(in2, LOW);
  }
  ledcWrite(ledChannelA, abs(speed)); // Establecer velocidad (PWM)
}

// Función para mover el Motor B (Derecho)
void moveMotorB(int speed) {
  if (speed > 0) { // Adelante
    digitalWrite(in3, HIGH);
    digitalWrite(in4, LOW);
  } else if (speed < 0) { // Atrás
    digitalWrite(in3, LOW);
    digitalWrite(in4, HIGH);
  } else { // Detener
    digitalWrite(in3, LOW);
    digitalWrite(in4, LOW);
  }
  ledcWrite(ledChannelB, abs(speed)); // Establecer velocidad (PWM)
}

// Funciones de movimiento del robot
void forward(int speed) {
  moveMotorA(speed);
  moveMotorB(speed);
  Serial.print("Moviendo adelante a velocidad: ");
  Serial.println(speed);
}

void backward(int speed) {
  moveMotorA(-speed);
  moveMotorB(-speed);
  Serial.print("Moviendo atrás a velocidad: ");
  Serial.println(speed);
}

void turnLeft(int speed) {
  moveMotorA(-speed); // Rueda izquierda atrás
  moveMotorB(speed);  // Rueda derecha adelante
  Serial.print("Girando izquierda a velocidad: ");
  Serial.println(speed);
}

void turnRight(int speed) {
  moveMotorA(speed);  // Rueda izquierda adelante
  moveMotorB(-speed); // Rueda derecha atrás
  Serial.print("Girando derecha a velocidad: ");
  Serial.println(speed);
}

void stopRobot() {
  moveMotorA(0);
  moveMotorB(0);
  Serial.println("Robot detenido.");
}

void loop() {
  // Ejemplo de secuencia de movimientos
  forward(150); // Mover adelante a velocidad media
  delay(2000);
  stopRobot();
  delay(1000);

  backward(100); // Mover atrás a velocidad baja
  delay(1500);
  stopRobot();
  delay(1000);

  turnLeft(120); // Girar izquierda
  delay(1500);
  stopRobot();
  delay(1000);

  turnRight(120); // Girar derecha
  delay(1500);
  stopRobot();
  delay(1000);

  forward(200); // Mover adelante a velocidad alta
  delay(3000);
  stopRobot();
  delay(5000); // Esperar más tiempo antes de repetir
}

Explicación del Código

• Definición de Pines: Se asignan los pines GPIO del ESP32 a los pines de control del L298N (IN1, IN2, IN3, IN4, ENA, ENB).
• PWM con ESP32: El ESP32 tiene un sistema de PWM (Pulse Width Modulation) más avanzado que el Arduino UNO, con múltiples canales. Usamos ledcSetup y ledcAttachPin para configurar y asociar los pines PWM a un canal (ledChannelA, ledChannelB) y una frecuencia/resolución.
• Funciones moveMotorA y moveMotorB: Estas funciones controlan individualmente la dirección (HIGH/LOW en INx) y la velocidad (ledcWrite) de cada motor. La velocidad se establece como un valor absoluto (0-255 para 8 bits de resolución PWM).
• Funciones de Movimiento del Robot: forward, backward, turnLeft, turnRight, stopRobot abstraen los movimientos complejos, llamando a las funciones individuales de los motores con las velocidades y direcciones adecuadas.
• loop(): Contiene una secuencia de ejemplo para probar los movimientos del robot. Puedes modificar esta sección para implementar comportamientos más complejos o añadir control remoto (Bluetooth/Wi-Fi).

✨ Primeras Pruebas y Depuración

Una vez que tengas el código cargado en tu ESP32, es hora de probar tu robot.

1. Desconecta la alimentación principal (batería) antes de subir el código.
2. Conecta el ESP32 a tu computadora por USB y sube el código.
3. Abre el Monitor Serie en el IDE de Arduino (asegúrate de la velocidad de 115200 baudios).
4. Conecta la batería (con el interruptor ON/OFF si lo instalaste). ¡El robot debería empezar a moverse según la secuencia programada!

Si algo no funciona:

• El robot no se mueve:
  • Verifica todas las conexiones de cables, especialmente la alimentación (voltaje y tierra).
  • Asegúrate de que la batería tenga carga suficiente.
  • Confirma que el driver L298N esté recibiendo alimentación tanto lógica (5V) como de motor (voltaje de la batería).
  • Revisa el código para posibles errores de pinout.
• El robot se mueve en la dirección incorrecta: Invierte los pines IN1/IN2 o IN3/IN4 para el motor correspondiente, o simplemente cambia la lógica en el código.
• Un motor funciona y el otro no: Revisa las conexiones específicas de ese motor, su driver y los pines GPIO asociados en el ESP32.
• El ESP32 no se carga o se desconecta: Asegúrate de tener los drivers correctos del ESP32 instalados y que el cable USB sea de buena calidad.

🚀 Próximos Pasos: Mejorando Tu Robot

¡Felicidades! Has construido y programado tu primer robot móvil diferencial. Pero esto es solo el principio. Aquí tienes algunas ideas para llevar tu robot al siguiente nivel:

• Control Remoto: Implementa control vía Bluetooth (usando una aplicación en tu teléfono) o Wi-Fi (creando una interfaz web simple en el ESP32).
• Sensores de Obstáculos: Añade sensores ultrasónicos (HC-SR04) o infrarrojos para que el robot pueda detectar y evitar obstáculos de forma autónoma.
• Seguidor de Líneas: Incorpora sensores TCRT5000 para que el robot siga una línea negra sobre un fondo blanco.
• Odometría: Utiliza encoders en los motores para medir con precisión la distancia recorrida y los ángulos girados, lo que es fundamental para una navegación más avanzada.
• Diseño de PCB Personalizado: Una vez que tu prototipo funcione, considera diseñar una placa de circuito impreso (PCB) para hacer las conexiones más robustas y profesionales.

Esperamos que este tutorial te haya proporcionado una base sólida para explorar el emocionante campo de la robótica. ¡Ahora sal y crea!