Building a DIY Mini FPV Drone with a Custom ESP32 Controller

The world of First Person View (FPV) drones is usually dominated by expensive radio protocols like ELRS or Crossfire. However, for hobbyists looking to learn the ropes of electronics and programming, building a drone from scratch using the ESP32 microcontroller is an incredibly rewarding project. The ESP32 provides built-in Wi-Fi and Bluetooth, but more importantly, it supports ESP-NOW—a low-latency connection protocol perfect for remote control applications.

In this guide, we will walk through the steps to build a mini brushed FPV drone and a custom-built handheld controller, both powered by the ESP32.

Why Use ESP32 for a Drone?

The ESP32 is a powerhouse for DIY projects. Unlike traditional Arduino boards, it features a dual-core processor, high clock speeds, and integrated wireless communication. By using the ESP-NOW protocol, we can achieve significantly lower latency than standard Wi-Fi, making it fast enough to pilot a small drone in real-time. Additionally, the ESP32 is affordable and widely available, making it the perfect brain for both our flight controller and our radio transmitter.

Required Components

For the Mini Drone:

• 1x ESP32 Development Board (NodeMCU or ESP32-WROOM)
• 4x 8520 Coreless Brushed Motors (1S)
• 4x 55mm Propellers
• 1x 1S LiPo Battery (300mAh - 600mAh)
• 1x DRV8833 or SI2302 MOSFETs (to drive the motors)
• 1x MPU6050 Gyroscope/Accelerometer
• 1x Mini FPV Camera & VTX Combo (e.g., Eachine TX06)
• 1x Lightweight 3D printed or carbon fiber frame

For the Custom Controller:

• 1x ESP32 Development Board
• 2x Analog Joystick Modules (similar to PS2 controller sticks)
• 1x 18650 Li-ion Battery or small LiPo
• 1x TP4056 Charging Module
• Various jumper wires and a breadboard or protoboard

The Secret Sauce: ESP-NOW Protocol

Standard Wi-Fi requires a "handshake" process that introduces lag. ESP-NOW is a connectionless protocol developed by Espressif that allows for direct transmission of short packets between ESP32 devices. This mimics the behavior of traditional RC transmitters, providing the snappy response times needed to keep a drone in the air.

Step 1: Building the Custom Controller

The controller reads the position of the two joysticks and sends that data (Throttle, Yaw, Pitch, Roll) to the drone. The analog sticks provide a voltage between 0V and 3.3V, which the ESP32 converts into a digital value using its Analog-to-Digital Converter (ADC).

Wiring the Controller

• Left Joystick VCC to ESP32 3V3, GND to GND.
• Left Joystick VRx (Yaw) to GPIO 34.
• Left Joystick VRy (Throttle) to GPIO 35.
• Right Joystick VCC to ESP32 3V3, GND to GND.
• Right Joystick VRx (Roll) to GPIO 32.
• Right Joystick VRy (Pitch) to GPIO 33.

Controller Code Snippet

Below is a simplified example of how the controller packages joystick data to send via ESP-NOW.

#include <esp_now.h>
#include <WiFi.h>

// Receiver MAC Address
uint8_t broadcastAddress[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};

struct PacketData {
  int throttle;
  int yaw;
  int pitch;
  int roll;
};

PacketData myData;

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  if (esp_now_init() != ESP_OK) {
    Serial.println("Error initializing ESP-NOW");
    return;
  }
  // Register peer and other setup...
}

void loop() {
  myData.throttle = map(analogRead(35), 0, 4095, 0, 255);
  myData.yaw = map(analogRead(34), 0, 4095, -100, 100);
  // Send data via esp_now_send...
  delay(20);
}

Step 2: The Drone Flight Controller

On the drone side, the ESP32 acts as the Flight Controller (FC). It must do three things simultaneously: receive data from the controller, read the MPU6050 gyroscope to stay level, and adjust the speed of the four motors using Pulse Width Modulation (PWM).

Driving the Motors

The ESP32 GPIO pins cannot provide enough current to drive motors directly. You must use MOSFETs or a dedicated motor driver chip like the DRV8833. The ESP32 sends a PWM signal to the gate of the MOSFET, which allows the high-current battery power to reach the motors.

The PID Loop

To keep the drone stable, you need a PID (Proportional, Integral, Derivative) algorithm. This algorithm compares the desired angle (from your joystick) to the actual angle (from the MPU6050) and makes micro-adjustments to the motor speeds hundreds of times per second.

Step 3: Setting Up the FPV System

The "FPV" part of the drone is handled by a standalone unit. Most mini FPV cameras come with a built-in video transmitter (VTX). These units usually require a 5V or 3.3V input.

Simply mount the camera to the front of your frame and wire it directly to your power distribution board or the ESP32's voltage regulator. The camera will broadcast an analog 5.8GHz signal that can be picked up by any standard FPV goggles or a phone-linked receiver.

Assembly and Calibration

Once the hardware is wired and the code is flashed, follow these steps for a successful first flight:

• Level Calibration: Place the drone on a flat surface and calibrate the MPU6050 so it knows what "level" feels like.
• Propeller Direction: Ensure your motors are spinning in the correct directions (Clockwise and Counter-Clockwise pairs) and that the props are not upside down.
• Center Sticks: Ensure your controller joysticks are sending neutral values when not touched.
• Safety First: For your first test, hold the drone loosely from the bottom or tether it to a table. Slowly increase the throttle to ensure it wants to lift straight up.

Conclusion

Building a custom drone with an ESP32 is a fantastic way to bridge the gap between pure coding and physical engineering. While it might not outperform a professional racing drone, the knowledge gained about wireless protocols, PID stabilization, and power management is invaluable. Plus, there is no feeling quite like seeing a machine you programmed yourself take to the skies!

Happy flying, and keep experimenting with your custom ESP32 builds!