Build a 5-inch reconnaissance drone, step by step

This guide assumes you have never built a quad and want one that flies, then thinks. It is written in build order, not theory order: nothing appears before you need it, and every step names the mistake it is there to prevent.

Credit where it is due. The airframe half follows the method the FPV community has converged on — Oscar Liang's build logs for wiring and assembly order, Joshua Bardwell's Betaflight walkthroughs for setup and troubleshooting, Painless360 for anything ArduPilot. Those are the sources I learned from and the ones to watch if you prefer video. What I have added is the part they do not cover: making the aircraft autonomous, and running a detector on board.

The decision that shapes every purchase

Betaflight or ArduPilot? It is not a preference, it decides whether the project is possible. Betaflight is a superb manual-flight firmware with no meaningful autonomous mission layer. ArduPilot gives you GUIDED mode, position hold, mission upload and a MAVLink API — exactly what a companion computer needs.

If your goal is racing or cinematic flying: Betaflight, stop reading at Part B. If your goal is "the drone finds things and tells me where", you need ArduPilot, and you should choose a flight controller with enough UARTs on day one.

Tools, and the three that are not optional

A1 · Frame assembly

Lay every part on the bench and count it against the manual before you touch a screw. Frames ship with different arm thickness and standoff length, and the manual is the only thing that tells you which screw goes where.

A2 · Motors, and the screw that kills them

The most common way to destroy a motor is a screw 2 mm too long. It threads through the arm, through the motor base, into the stator winding — where it looks perfect and works for one flight.

A3 · Power train and pads

Solder in the order below. Each step is testable before the next, which is the whole point: you want the cheapest possible failure.

A4 · Mounting the stack

A5 · Receiver, GPS, video

• ELRS receiver — solder to a free UART, bind it before you hide it under a plate. Binding after assembly is a hobby in itself.
• GPS + compass — on a mast, as far from the VTX and the Pi as the frame allows. Compass interference is the number one cause of "toilet-bowling" in position hold. Calibrate outdoors, away from metal and magnets.
• VTX — power from a filtered 5 V/9 V rail, never from the Pi. Antenna connected before power-up, every single time.
• Camera — for the AI build, skip the analog camera entirely and mount the Pi Camera Module 3 on a damped plate. Two cameras is weight you do not need.

B1 · The flashing sequence

B2 · Betaflight path (manual flight)

B3 · ArduPilot path (autonomy)

This is the path this build uses: ArduPilot exposes MAVLink, which is what the Pi speaks.

# ArduPilot parameters worth setting explicitly (read them back — names move between versions)
PARAM_SET FRAME_CLASS      1     # 1 = Quad
PARAM_SET FRAME_TYPE       1     # 1 = X
PARAM_SET SERIAL2_PROTOCOL 2     # 2 = MAVLink2  (UART wired to the Pi)
PARAM_SET SERIAL2_BAUD     57    # 57600
PARAM_SET ARMING_CHECK     1     # 1 = all checks on. Never 0.

B4 · Prove it before it leaves the bench

C1 · Power

Separate UBEC, separate ground, 5 A available. The Pi 5 will brown out under motor acceleration otherwise, and a brownout mid-flight looks exactly like a software crash.

# Watch the rail while you punch the throttle on the bench
watch -n 0.2 'vcgencmd measure_volts; vcgencmd measure_temp; vcgencmd get_throttled'
# 0x0 = clean. Anything else = undervoltage or thermal throttling. Fix before flight.

C2 · UART to the flight controller

# /boot/firmware/config.txt — enable the primary UART, free it from bluetooth
enable_uart=1
dtoverlay=disable-bt

# /boot/firmware/cmdline.txt — remove this token, or a login console sits on the port
#   console=serial0,115200

sudo reboot
ls -l /dev/serial0        # -> ttyAMA0

# The whole link, tested in four lines. A heartbeat means wiring, baud and protocol are correct.
from pymavlink import mavutil
m = mavutil.mavlink_connection("/dev/serial0", baud=57600)
m.wait_heartbeat(timeout=10)
print("heartbeat from system", m.target_system)

C3 · Camera

# Camera Module 3 on CSI-0. Test the sensor before writing any inference code.
from picamera2 import Picamera2
import time

cam = Picamera2()
cam.configure(cam.create_still_configuration(main={"size": (2304, 1296)}))
cam.start(); time.sleep(2)
cam.capture_file("test.jpg")          # open it — focus and exposure are set here
cam.stop()

Mount it on silicone or foam, not hard to carbon. Vibration does not blur a single frame visibly — it makes every frame slightly different, which ruins the tracker and therefore the geolocation median.

C4 · Thermal

The Pi 5 throttles around 80–85 °C, and inside a shell with no airflow it gets there in six minutes. Active cooler, a 10 mm intake, and the temperature in your flight log. If the frame rate drops mid-flight, it is almost always this.

D1 · Which model, on which hardware

An accelerator is worth it only once the CPU path works. The Raspberry Pi AI HAT+ (Hailo-8L, 13 TOPS) uses the PCIe lane and turns 12 fps into 60+ on small models — but it adds a driver stack, 15 g and 2–3 W. Build the CPU version first; add the HAT when the model, not the frame rate, is your limit.

D2 · Fine-tune on your own 500 images

A generic COCO detector is bad at exactly the things you care about: a specific vehicle type, a container, an animal, equipment on a site. Five hundred labelled frames from your own camera beat a 500 000-image generic dataset, because the domain matches.

pip install ultralytics
yolo detect train data=dataset/data.yaml model=yolo11n.pt epochs=100 imgsz=640 batch=16
yolo detect val   model=runs/detect/train/weights/best.pt data=dataset/data.yaml

# Export twice: ONNX for CPU, int8 for the edge
yolo export model=best.pt format=onnx imgsz=640 simplify=True
yolo export model=best.pt format=onnx imgsz=640 int8=True data=dataset/data.yaml

D3 · The inference loop, complete

Three threads. The capture thread never blocks on inference; the inference thread never blocks on telemetry. Drop-oldest queues keep latency honest.

import queue, threading, time
from picamera2 import Picamera2
from ultralytics import YOLO

frames  = queue.Queue(maxsize=2)   # drop-oldest: latency beats completeness
results = queue.Queue(maxsize=2)

def capture_loop():
    cam = Picamera2()
    cam.configure(cam.create_video_configuration(
        main={"size": (1280, 720), "format": "RGB888"}, buffer_count=4))
    cam.start()
    while True:
        buf = cam.capture_array("main")
        if frames.full():
            try: frames.get_nowait()
            except queue.Empty: pass
        frames.put(buf)

def inference_loop(model):
    while True:
        frame = frames.get()
        r = model.predict(frame, imgsz=640, conf=0.35, verbose=False)[0]
        dets = [{"box": b.xyxy[0].tolist(), "cls": model.names[int(b.cls)],
                 "conf": float(b.conf)} for b in r.boxes]
        if results.full():
            try: results.get_nowait()
            except queue.Empty: pass
        results.put((time.time(), frame, dets))

threading.Thread(target=capture_loop, daemon=True).start()
model = YOLO("models/recon_int8.pt")
threading.Thread(target=inference_loop, args=(model,), daemon=True).start()

Tracking, so the output stops flickering

def iou(a, b):
    ax2, ay2 = a[0]+a[2], a[1]+a[3]
    bx2, by2 = b[0]+b[2], b[1]+b[3]
    ix = max(0, min(ax2,bx2) - max(a[0],b[0]))
    iy = max(0, min(ay2,by2) - max(a[1],b[1]))
    inter = ix*iy
    return inter / (a[2]*a[3] + b[2]*b[3] - inter + 1e-9)

class Tracker:
    def __init__(self, iou_thr=0.3, max_age=5):
        self.tracks, self.iou_thr, self.max_age, self._id = {}, iou_thr, max_age, 0

    def update(self, dets, t):
        for tr in self.tracks.values(): tr["age"] += 1
        for d in dets:
            w, h = d["box"][2]-d["box"][0], d["box"][3]-d["box"][1]
            box = (d["box"][0], d["box"][1], w, h)
            best, score = None, self.iou_thr
            for tid, tr in self.tracks.items():
                if tr["label"] != d["cls"]: continue
                s = iou(tr["box"], box)
                if s > score: best, score = tid, s
            if best is None:
                self._id += 1; best = self._id
                self.tracks[best] = {"label": d["cls"], "box": box, "age": 0, "first": t}
            self.tracks[best].update(box=box, age=0, last=t, conf=d["conf"])
        for tid in [k for k, v in self.tracks.items() if v["age"] > self.max_age]:
            del self.tracks[tid]
        return self.tracks

Pixel to coordinate

Bearing from the camera intrinsics, ray rotated into the world frame by attitude, intersected with the ground plane at altitude above ground.

import numpy as np

def pixel_to_world(u, v, intr, R_body, R_cam, alt_m):
    """u,v = bottom-centre of the box (the ground contact point).
       R_body = body->ENU rotation from the autopilot. alt_m = AGL, not MSL."""
    ray_c = np.array([(u - intr["cx"]) / intr["fx"],
                      (v - intr["cy"]) / intr["fy"], 1.0])
    ray_w = R_body @ (R_cam @ ray_c)
    ray_w /= np.linalg.norm(ray_w)
    if ray_w[2] >= -1e-6: return None      # horizon: no intersection
    t = -alt_m / ray_w[2]
    if t < 0 or t > 500: return None
    return (t * ray_w)[0], (t * ray_w)[1]   # east, north

def to_latlon(east, north, lat0, lon0):
    R = 6378137.0
    return (lat0 + np.degrees(north / R),
            lon0 + np.degrees(east / (R * np.cos(np.radians(lat0)))))

Four things decide whether this is accurate to 3 m or 30: use the bottom-centre of the box, use AGL rather than MSL altitude, calibrate the intrinsics with a checkerboard, and take the median of the last ten estimates weighted by confidence.

D4 · Run it as a service

# /etc/systemd/system/recon.service
[Unit]
Description=Recon perception service
After=network-online.target

[Service]
ExecStart=/home/pi/recon/bin/python /opt/recon/main.py
WorkingDirectory=/opt/recon
Restart=always
RestartSec=3
User=pi

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload && sudo systemctl enable --now recon
journalctl -u recon -f          # watch detections live over SSH

E1 · Seven flights, in this order

E2 · Legal and ethical constraints

• Fly on private land with permission, with a spotter.
• Do not run person detection on the public. Detect what you have a legitimate purpose for.
• Keep pixels on the aircraft, with a retention period you can defend.
• Log every flight — area, purpose, duration. An answer beats a shrug.

E3 · Bill of materials

Roughly €640 plus a charger and a radio. The best quality-of-life upgrade is a better charger; the second is a spare set of arms.

E4 · What broke on mine

• Thermal throttling at 6 minutes — closed canopy, no airflow, frame rate fell to 4 fps. Active cooler + intake hole.
• Compass interference — position hold wandered; GPS mast raised 40 mm and the NVMe cable rerouted.
• CSI ribbon cracked at the connector after a hard landing. Silicone the connector, strain-relieve the ribbon, carry a spare.
• Brownouts on throttle punch until the dedicated UBEC went in.
• One motor destroyed by a 10 mm screw. See A2. It cost €20 and an evening.