Practical Robotics Engineering Projects: Build and Debug an ESP32 Rover

When tackling robotics engineering projects, the gap between a blinking LED and a moving autonomous platform is defined by power management, logic-level translation, and real-time operating system (RTOS) constraints. This guide walks through building, programming, and—most importantly—debugging a 2WD obstacle-avoiding rover using the ESP32. We will bypass the generic tutorials that ignore voltage mismatches and RTOS watchdog timers, focusing instead on the exact hardware realities and failure modes you will encounter on the bench.

Project Overview & Difficulty Rating

Spec-Sheet: Exact Parts List

Do not substitute the motor driver or battery without recalculating the voltage drops. The L298N uses bipolar junction transistors (BJTs), which drop roughly 2V across the H-bridge.

Hardware Wiring & Pin Mapping

The most common point of failure in beginner robotics engineering projects is ignoring logic-level thresholds. The HC-SR04 outputs a 5V pulse on its Echo pin. The ESP32 GPIO pins are strictly 3.3V tolerant. Feeding 5V directly into GPIO 19 will degrade the silicon and eventually brick the pin. You must build a voltage divider using a 10kΩ and 20kΩ resistor for the Echo line.

Pin Mapping Table

Complete ESP32 Rover Code

Target Board Variant: This code is written for the ESP32-WROOM-32 DevKit v1. In the Arduino IDE Boards Manager, select ESP32 Dev Module (ESP32 Arduino Core v3.x or later).

Unlike older 8-bit AVR code, ESP32 firmware runs on FreeRTOS. If your loop() function blocks for too long without yielding to the RTOS, the Wi-Fi/Bluetooth stack will starve, triggering a hardware watchdog reset. Furthermore, we use the modern ledcAttach() API introduced in ESP32 Core v3.0, replacing the deprecated ledcSetup() functions.

/*
 * ESP32 2WD Obstacle Avoiding Rover
 * Target: ESP32-WROOM-32 DevKit v1 (ESP32 Arduino Core 3.x)
 * Hardware: L298N, HC-SR04 (with voltage divider)
 */

// --- Pin Definitions ---
constexpr uint8_t PIN_IN1 = 12;
constexpr uint8_t PIN_IN2 = 13;
constexpr uint8_t PIN_IN3 = 14;
constexpr uint8_t PIN_IN4 = 27;
constexpr uint8_t PIN_ENA = 5;
constexpr uint8_t PIN_ENB = 18;
constexpr uint8_t PIN_TRIG = 23;
constexpr uint8_t PIN_ECHO = 19;

// --- Motor & Sensor Constants ---
constexpr uint32_t PWM_FREQ = 1000;      // 1kHz PWM frequency for DC motors
constexpr uint8_t PWM_RES = 8;           // 0-255 duty cycle resolution
constexpr uint32_t ECHO_TIMEOUT_US = 30000; // ~5 meters max range
constexpr float SPEED_OF_SOUND_CM_US = 0.0343;
constexpr int OBSTACLE_DIST_CM = 20;

// Motor speed (0-255)
constexpr uint8_t SPEED_NORMAL = 180;
constexpr uint8_t SPEED_TURN = 120;

void setup() {
  Serial.begin(115200);
  Serial.println("[BOOT] Initializing Rover...");

  // Configure Direction Pins
  pinMode(PIN_IN1, OUTPUT);
  pinMode(PIN_IN2, OUTPUT);
  pinMode(PIN_IN3, OUTPUT);
  pinMode(PIN_IN4, OUTPUT);
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);

  // Configure PWM using modern ESP32 Core 3.x API
  ledcAttach(PIN_ENA, PWM_FREQ, PWM_RES);
  ledcAttach(PIN_ENB, PWM_FREQ, PWM_RES);

  // Ensure motors are stopped on boot
  stopMotors();
  Serial.println("[BOOT] Rover Ready.");
}

void loop() {
  int distance = getDistanceCM();
  
  // Error handling: If sensor times out, distance is 0. Treat as clear path but log it.
  if (distance == 0) {
    Serial.println("[WARN] Ultrasonic timeout. Assuming clear path.");
    moveForward(SPEED_NORMAL);
  } 
  else if (distance < OBSTACLE_DIST_CM) {
    Serial.printf("[ACT] Obstacle at %d cm. Executing avoid maneuver.\n", distance);
    stopMotors();
    delay(100);
    moveBackward(SPEED_NORMAL);
    delay(300);
    stopMotors();
    turnRight(SPEED_TURN);
    delay(400);
    stopMotors();
  } 
  else {
    moveForward(SPEED_NORMAL);
  }

  // CRITICAL: Yield to FreeRTOS to prevent Task Watchdog Timeout
  yield(); 
  delay(50); // Small physical delay for sensor settling
}

int getDistanceCM() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);

  // Read pulse with explicit timeout to prevent blocking the RTOS
  long duration = pulseIn(PIN_ECHO, HIGH, ECHO_TIMEOUT_US);
  
  if (duration == 0) return 0; // Timeout occurred
  
  return (duration * SPEED_OF_SOUND_CM_US) / 2.0;
}

void moveForward(uint8_t speed) {
  digitalWrite(PIN_IN1, HIGH); digitalWrite(PIN_IN2, LOW);
  digitalWrite(PIN_IN3, HIGH); digitalWrite(PIN_IN4, LOW);
  ledcWrite(PIN_ENA, speed); ledcWrite(PIN_ENB, speed);
}

void moveBackward(uint8_t speed) {
  digitalWrite(PIN_IN1, LOW); digitalWrite(PIN_IN2, HIGH);
  digitalWrite(PIN_IN3, LOW); digitalWrite(PIN_IN4, HIGH);
  ledcWrite(PIN_ENA, speed); ledcWrite(PIN_ENB, speed);
}

void turnRight(uint8_t speed) {
  digitalWrite(PIN_IN1, HIGH); digitalWrite(PIN_IN2, LOW);
  digitalWrite(PIN_IN3, LOW); digitalWrite(PIN_IN4, HIGH);
  ledcWrite(PIN_ENA, speed); ledcWrite(PIN_ENB, speed);
}

void stopMotors() {
  digitalWrite(PIN_IN1, LOW); digitalWrite(PIN_IN2, LOW);
  digitalWrite(PIN_IN3, LOW); digitalWrite(PIN_IN4, LOW);
  ledcWrite(PIN_ENA, 0); ledcWrite(PIN_ENB, 0);
}

Debugging: Motor Jitter and the "Guru Meditation Error"

When moving from static bench tests to a rolling chassis, you will inevitably encounter the exact error string below printed to the serial monitor right before the ESP32 reboots:

Guru Meditation Error: Core 1 panic'ed (Interrupt wdt timeout on CPU1)

This is the Task Watchdog Timer (TWDT) triggering. The ESP32 runs FreeRTOS; if a task monopolizes the CPU and fails to feed the watchdog, the hardware assumes the system is locked and force-resets it.

The First Three Things to Check When It Fails

1. Missing yield() or blocking pulseIn(): If your ultrasonic sensor cable is disconnected, pulseIn() without a timeout parameter will block the CPU for a full second, instantly tripping the WDT. Always use the 3-parameter version: pulseIn(pin, state, timeout).
2. Voltage Brownout on the 3.3V Rail: TT motors generate massive back-EMF and current spikes when starting/stopping. If the ESP32 shares a weak power rail, the 3.3V LDO on the DevKit will droop, causing a brownout reset. Ensure the LM2596 buck converter is rated for at least 2A and add a 100µF electrolytic capacitor across the ESP32 Vin and GND pins.
3. I2C/SPI Bus Lockups: If you add an OLED screen later, a loose SDA/SCL wire can cause the Wire library to hang indefinitely inside an ISR. Use pull-up resistors (4.7kΩ) on I2C lines and keep wires under 10cm.

Extending and Simplifying the Build

Depending on your budget and end-goal, you can alter the hardware profile of this robotics engineering project.

How to Simplify (Lower Cost & Complexity)

• Drop the LiPo: Swap the 2S LiPo and buck converter for a simple 4x AA battery holder (6V nominal). Wire the 6V directly to the L298N 12V input, and use the L298N's onboard 5V regulator to power the ESP32. Tradeoff: The onboard 5V regulator is notoriously weak and will overheat if you add Wi-Fi telemetry.
• Sensor Swap: Replace the HC-SR04 with an infrared obstacle sensor (e.g., FC-03). It requires no timing code, just a simple digital HIGH/LOW read, eliminating the WDT risk entirely.

How to Extend (Advanced Robotics)

• Upgrade to TB6612FNG: The L298N wastes ~2V as heat. The TB6612FNG uses MOSFETs, dropping only ~0.5V. It runs cooler, is physically smaller, and handles 3.3V logic natively without level shifting.
• Add micro-ROS: To integrate this into professional robotics engineering projects, install the micro_ros_arduino library. This allows the ESP32 to act as a ROS 2 node over Wi-Fi, publishing odom data and subscribing to cmd_vel twist messages from a Raspberry Pi running Nav2.
• Swap to Time-of-Flight: Replace the HC-SR04 with a VL53L0X I2C ToF sensor. It provides millimeter accuracy, ignores ambient sunlight, and eliminates acoustic blind spots.

FAQ: Common Questions on Robotics Engineering Projects

What are the best microcontrollers for beginner robotics engineering projects?

For pure beginners, the Arduino Uno R3 or Nano remains the standard due to 5V logic tolerance (meaning you can wire 5V sensors directly without voltage dividers) and massive library support. However, for projects requiring Wi-Fi telemetry, camera integration, or RTOS multitasking, the ESP32-WROOM-32 is the undisputed king of the sub-$10 tier. If you need native USB and high-speed motor control, the Raspberry Pi Pico (RP2040) offers Programmable I/O (PIO) blocks that can handle quadrature encoders without CPU overhead.

How do I prevent my ESP32 from resetting when the rover motors start?

This is a classic voltage sag issue. When both TT motors start simultaneously, they can pull 1.5A+ instantaneously. If your power supply cannot deliver this transient current, the voltage drops below the ESP32's brownout detector threshold (usually ~2.4V on the internal rail). Fix this by: 1) Using a high-discharge-rate battery (like a LiPo, not alkaline AAs), 2) Adding a large bulk capacitor (470µF - 1000µF) near the motor driver power inputs, and 3) Staggering the motor start times in code by 50ms.

Can I use these robotics engineering projects with ROS 2 (Robot Operating System)?

Yes, but not natively via standard Arduino code. You must use micro-ROS, a middleware designed to run on resource-constrained microcontrollers. You will need a host machine (or a Raspberry Pi on the rover) running the micro-ROS agent to bridge the ESP32's serial/Wi-Fi transport to the main ROS 2 DDS network. This allows your ESP32 rover to be controlled using standard ROS 2 navigation stacks.

Why is the L298N motor driver getting extremely hot?

The L298N uses older BJT Darlington pair topology, which inherently drops 1.5V to 2.5V across the H-bridge as heat. If you are running 2A through the motors, the chip is dissipating up to 5W of thermal energy. The included heatsink is often insufficient. If it is too hot to touch (>70°C), you are likely stalling the motors or exceeding the continuous current rating. Switch to a modern MOSFET-based driver like the DRV8833 or TB6612FNG to eliminate this thermal loss.