AI Grand Prix — System Architecture

End-to-end autonomous drone racing pipeline • Vision-only navigation • Ctrl+P to save as PDF

1. Overview

This system pilots a racing drone autonomously through a sequence of gates at high speed. The architecture is based on MonoRace (2025 A2RL Autonomous Racing League champion): a U-Net segmentation network identifies gate pixels, RANSAC fits edge lines to extract sub-pixel corners, Perspective-n-Point (PnP) solves for 3D gate pose relative to the drone, and a state machine sequences approach, transit, and re-acquisition phases. A controller converts desired trajectories into attitude commands sent over MAVLink to the PX4 autopilot.

The pipeline runs as a single async Python process. Every frame triggers the full chain — detect, estimate, decide, command — with no queuing or frame drops. Latency from camera capture to motor command is under 8 ms on target hardware.

2. End-to-End Pipeline

The pipeline is fully synchronous within each frame. No thread pools, no message queues. The async event loop in race_pipeline.py awaits each stage sequentially, ensuring deterministic ordering. The only concurrent path is the telemetry listener, which runs in a background coroutine and updates shared state atomically.

3. Component File Map

4. Three Detection Modes

The vision pipeline supports three interchangeable detector backends, selected via race_config.py. Each trades off between speed, robustness, and accuracy.

5. Platform Configurations

The same codebase runs on three distinct platforms. All platform-specific differences are isolated in race_config.py — no conditional logic in the pipeline code.

6. Communication Architecture

# Offboard control flow
1. Connect to PX4 via UDP/serial
2. Start heartbeat at 4 Hz
3. Stream SET_ATTITUDE_TARGET at frame rate
4. PX4 enters offboard mode after ~0.5s of valid commands
5. Arm → takeoff → race loop → land

7. Key Design Decisions

Vision-only depth

No GPS, LiDAR, or depth sensor. All distance estimation comes from PnP with 4 known gate corner positions in world coordinates. Gate dimensions (1.5 m x 1.5 m) are the only world-scale reference. This makes corner accuracy the single most important factor in the system.

U-Net as primary detector

Pixel-level segmentation mask enables RANSAC edge fitting along each gate side, then line-line intersection for corner extraction. This yields sub-pixel corner accuracy, which directly improves PnP reprojection error and therefore depth estimation. YOLO's bounding box corners are not precise enough for reliable PnP.

No RECOVERY phase

If the gate is lost (no detection for N frames), the state machine does not attempt to fly to a remembered position. Instead, it immediately enters SEEK and spins at 180 deg/s to re-acquire the gate visually. This is faster and more reliable than dead-reckoning to an estimated position without GPS.

Config-driven architecture

Every gain, threshold, and timeout lives in race_config.py as a YAML-serializable dataclass. No magic numbers in pipeline code. Config can be swapped at runtime for different platforms, gate layouts, or tuning experiments. Every race log includes the full config snapshot for reproducibility.

Aggressive tuning parameters

Predictive transit detection

Gate pass-through is not determined by a simple distance threshold (which can false-trigger on approach). Instead, the system computes distance derivative over 3+ consecutive frames. Only when the distance is decreasing, below threshold, and the derivative confirms closing velocity does it trigger TRANSIT. This eliminates false transitions from PnP noise at close range.