The Best Robotics Projects for Makers: Building a PID-Controlled ESP32 Rover

If you are searching for the best robotics projects to bridge the gap between blinking LEDs and actual autonomous control theory, you need to move beyond open-loop motor spinning. The hallmark of a mature embedded robotics project in 2026 is closed-loop feedback. Specifically, Proportional-Integral-Derivative (PID) control applied to sensor data.

This guide walks you through building an ESP32-based autonomous rover that uses PID to maintain a set distance from an obstacle using an ultrasonic sensor, while smoothly adjusting motor speeds. We will cover the hardware decision matrix, exact pin mappings, modern ESP32 Arduino Core v3.x firmware, and the specific debugging steps required when the silicon inevitably misbehaves.

The Decision Tree: Picking Your Microcontroller and Motor Driver

Many legacy tutorials default to the Arduino Uno paired with an L298N motor driver. In 2026, this is a suboptimal choice for robotics. The L298N uses bipolar junction transistors (BJTs), which drop 1.5V to 2.0V across the H-bridge, robbing your motors of torque and wasting battery life as heat. Furthermore, the Uno lacks the clock speed for high-frequency PID loops and native wireless telemetry.

The Verdict: Pick the ESP32 DevKit V1 (30-pin variant) paired with the TB6612FNG MOSFET motor driver. The ESP32 provides dual-core processing (assigning the PID loop to Core 1 and WiFi telemetry to Core 0), while the TB6612FNG handles up to 1.2A continuous per channel with minimal voltage drop (Pololu TB6612FNG Specs).

Hardware Spec Sheet and Pin Mapping

Before soldering or plugging into a breadboard, verify your exact module variants. The 30-pin and 38-pin ESP32 DevKits have different ground and 3V3 layouts. This mapping assumes the standard 30-pin board.

Required Parts List

• MCU: ESP32 DevKit V1 (30-pin, ESP32-WROOM-32E module)
• Motor Driver: TB6612FNG Dual Motor Driver Carrier (MOSFET-based)
• Motors: 2x JGA25-370 12V DC Gear Motors (150 RPM, with quadrature encoders if extending)
• Sensor: HC-SR04 Ultrasonic Sensor (Note: Requires a logic level shifter or voltage divider for the Echo pin, as it outputs 5V and the ESP32 GPIO is 3.3V tolerant. A simple 2kΩ/3kΩ resistor divider works perfectly).
• Power: 3S LiPo Battery (11.1V nominal) with an XT60 connector and a buck converter set to 5.0V for the ESP32 VIN pin.

Pin Mapping Table

Complete PID Rover Firmware (ESP32 DevKit V1)

This code targets the ESP32 DevKit V1 (30-pin) using the modern ESP32 Arduino Core v3.x API. It utilizes the updated ledcAttach() functions rather than the deprecated ledcSetup() legacy functions. It implements a basic Proportional-Integral-Derivative loop to maintain a target distance of 20cm from an obstacle.

// Target Board: ESP32 DevKit V1 (30-pin)
// Core: ESP32 Arduino Core v3.x

// --- Pin Definitions ---
#define PIN_M1_PWM  27
#define PIN_M1_DIR1 26
#define PIN_M1_DIR2 25

#define PIN_M2_PWM  33
#define PIN_M2_DIR1 32
#define PIN_M2_DIR2 14

#define PIN_STBY    13
#define PIN_TRIG    5
#define PIN_ECHO    18

// --- PID Constants ---
float Kp = 8.0, Ki = 0.5, Kd = 2.0;
float targetDistance = 20.0; // Target distance in cm
float integral = 0, previousError = 0;

// --- Motor Control Functions ---
void setMotor(int dir1Pin, int dir2Pin, int pwmPin, int speed) {
  // speed range: -255 (reverse) to 255 (forward)
  if (speed > 0) {
    digitalWrite(dir1Pin, HIGH);
    digitalWrite(dir2Pin, LOW);
  } else if (speed < 0) {
    digitalWrite(dir1Pin, LOW);
    digitalWrite(dir2Pin, HIGH);
  } else {
    digitalWrite(dir1Pin, LOW);
    digitalWrite(dir2Pin, LOW);
  }
  ledcWrite(pwmPin, abs(speed));
}

// --- Sensor Function with Error Handling ---
float getDistanceCM() {
  digitalWrite(PIN_TRIG, LOW);
  delayMicroseconds(2);
  digitalWrite(PIN_TRIG, HIGH);
  delayMicroseconds(10);
  digitalWrite(PIN_TRIG, LOW);
  
  // 30000us timeout prevents blocking forever if echo pin is stuck
  unsigned long duration = pulseIn(PIN_ECHO, HIGH, 30000); 
  
  if (duration == 0) {
    // Timeout or error: return max distance to prevent blind crashing
    return 200.0; 
  }
  
  float distance = (duration * 0.0343) / 2.0;
  return distance;
}

void setup() {
  Serial.begin(115200);
  
  // Initialize Direction Pins
  pinMode(PIN_M1_DIR1, OUTPUT);
  pinMode(PIN_M1_DIR2, OUTPUT);
  pinMode(PIN_M2_DIR1, OUTPUT);
  pinMode(PIN_M2_DIR2, OUTPUT);
  pinMode(PIN_STBY, OUTPUT);
  
  // Initialize Ultrasonic Pins
  pinMode(PIN_TRIG, OUTPUT);
  pinMode(PIN_ECHO, INPUT);
  
  // Modern ESP32 LEDC PWM setup (Core v3.x)
  // Frequency 1000Hz, 8-bit resolution (0-255)
  ledcAttach(PIN_M1_PWM, 1000, 8);
  ledcAttach(PIN_M2_PWM, 1000, 8);
  
  digitalWrite(PIN_STBY, HIGH); // Enable motor driver
  Serial.println("PID Rover Initialized.");
}

void loop() {
  float currentDistance = getDistanceCM();
  float error = targetDistance - currentDistance;
  
  // Anti-windup clamping for the integral term
  integral += error;
  if (integral > 100) integral = 100;
  if (integral < -100) integral = -100;
  
  float derivative = error - previousError;
  float output = (Kp * error) + (Ki * integral) + (Kd * derivative);
  previousError = error;
  
  // Constrain output to 8-bit PWM limits
  int motorSpeed = constrain((int)output, -255, 255);
  
  // Apply to both motors (Forward/Reverse based on distance error)
  setMotor(PIN_M1_DIR1, PIN_M1_DIR2, PIN_M1_PWM, motorSpeed);
  setMotor(PIN_M2_DIR1, PIN_M2_DIR2, PIN_M2_PWM, motorSpeed);
  
  // Telemetry
  Serial.printf("Dist: %.1f cm | Err: %.1f | PWM: %d\n", currentDistance, error, motorSpeed);
  
  // Fixed time step for PID stability (20ms = 50Hz loop)
  delay(20); 
}

Debugging: When the Rover Fails to Boot or Move

Embedded robotics projects rarely compile and run perfectly on the first power cycle. When dealing with inductive loads (motors) and sensitive 3.3V logic, power integrity is usually the culprit. Here is the decision path for the two most common fatal errors.

The First Three Things to Check When It Fails

1. Measure the 5V Rail Under Load: Use a multimeter to probe the ESP32 VIN and GND pins while the motors are commanded to spin. If it dips below 4.5V, your voltage regulator is undersized or your battery C-rating is too low.
2. Verify the Echo Pin Voltage Divider: The HC-SR04 outputs a 5V pulse. Feeding 5V directly into GPIO 18 will fry the ESP32's input protection diodes over time, leading to phantom readings. Measure the voltage at GPIO 18 with an oscilloscope or multimeter; it must not exceed 3.3V.
3. Check the STBY Pin: The TB6612FNG has an active-high Standby pin. If GPIO 13 is not pulled HIGH (or if it's floating), the H-bridges are disabled, and the motors will remain dead despite correct PWM signals.

Extending or Simplifying the Build

Robotics is an iterative discipline. Depending on your bench capabilities and budget, you should scale this project up or down.

How to Simplify (The Budget Build)

If the TB6612FNG and JGA25 motors are out of budget, downgrade to an L298N driver and TT yellow gearmotors (approx. $4 for the pair). Trade-off: You must increase the battery voltage to 4S LiPo (14.8V) to compensate for the L298N's massive 2V voltage drop, and you will need to lower the PWM frequency to ~500Hz to prevent the L298N from overheating due to switching losses.

How to Extend (The Advanced Build)

To turn this into a truly autonomous mapping rover, add quadrature encoders to the JGA25 motors and swap the simple distance PID for a velocity PID loop. Furthermore, integrate a FreeRTOS task on Core 0 to handle MQTT telemetry, streaming the PID error and motor RPM to a dashboard like Grafana over WiFi, while Core 1 remains strictly dedicated to the 50Hz control loop. This dual-core separation is the exact architecture used in commercial AGVs (Automated Guided Vehicles) and represents the pinnacle of hobbyist robotics design.