AI Grand Prix — Race Pipeline Deep Dive

1. State Machine Overview

The race controller is a finite state machine with six discrete phases. Every frame, exactly one phase is active. Transitions are deterministic — no priority conflicts, no deferred transitions.

2. Phase Descriptions

INIT STARTUP

Establishes connection to the flight controller via MAVSDK. Verifies telemetry streams (position, attitude, battery), arms the drone, and confirms pre-arm checks pass.

TAKEOFF STARTUP

Executes a vertical climb to the race altitude of 5m AGL. Throttle is managed by the altitude controller. No lateral movement.

SEEK_GATE ACTIVE RACING

The drone enters a rapid yaw scan to locate the next gate. Vision pipeline processes every frame looking for gate detections.

APPROACH_GATE TRANSITION

Proportional pursuit toward the tracked gate. The controller outputs pitch, yaw, and roll commands to close distance while keeping the gate centered in the frame.

TRANSIT_GATE TRANSITION

A single-frame event marking successful gate passage. Not a sustained phase — it fires and immediately transitions.

EMERGENCY TERMINAL

Hover in place with zero velocity. The drone holds position and altitude. Triggered when SEEK_GATE times out after 30s without finding any gate.

FINISHED TERMINAL

Race complete. Triggered by one of two conditions:

• All expected gates have been passed (normal completion)
• No-gate-finish timeout: 30 seconds elapsed after the last transit with no new gate detected

3. Predictive Transit Detection

Transit through a gate is not triggered by a simple distance threshold. Raw distance measurements are noisy — a jittery reading could falsely trigger transit while the drone is still meters away. Instead, the system requires consistent closing behavior before accepting a transit.

Algorithm

1. Each frame with a gate detection, compute: dist_delta = prev_distance - current_distance
2. If dist_delta > 0 (closing): increment distance_closing_count
3. If dist_delta ≤ 0 (opening or jitter): reset distance_closing_count = 0
4. Transit triggers only when ALL conditions are met:
   • distance < 1.5m (transit distance threshold)
   • closing_count ≥ 3 (consistently getting closer)
   • Detection is fresh (current frame, not stale)
   • Phase is APPROACH_GATE
   • No active cooldown from previous transit

Timing Diagram

4. Gate Tracker (EMA Smoothing)

Raw gate detections are noisy. The tracker applies Exponential Moving Average (EMA) smoothing to produce stable bearing, distance, and position estimates that the controller can act on without oscillation.

TrackedGate Fields

EMA Formula

smoothed = alpha * new_measurement + (1 - alpha) * prev_smoothed

Staleness Lifecycle

Frame N:   detection arrives  →  stale = 0,  EMA update applied
Frame N+1: no detection       →  stale = 1,  use last smoothed values
Frame N+2: no detection       →  stale = 2,  use last smoothed values
...
Frame N+9: no detection       →  stale = 9,  use last smoothed values
Frame N+10: no detection      →  stale = 10, GATE DROPPED — tracker cleared

5. Controller Modes

Two control modes are available, selectable per-mission. Attitude mode is the default for aggressive racing; velocity body mode is available for smoother, more conservative approaches.

Attitude Mode AGGRESSIVE

Sends SET_ATTITUDE_TARGET MAVLink messages. Direct control over roll, pitch, yaw rate, and thrust. No position or velocity controller in the loop — the race code is the outer controller.

Velocity Body Mode SMOOTH

Sends SET_POSITION_TARGET_LOCAL_NED with velocity setpoints in the body frame. The flight controller's velocity PID handles the inner loop, giving smoother trajectories at the cost of peak speed.

6. Timing Budget

The race loop targets 120Hz (8.33ms per frame). Every millisecond matters — a frame overrun means stale commands and degraded tracking. Below is the per-frame budget breakdown.

7. Race Loop Pseudocode

The main async loop runs at 120Hz. Each iteration follows a strict pipeline: sense, decide, act. No deferred work, no background threads for control — everything is synchronous within the frame.

async def race_loop():
    # Initialize state machine
    phase = Phase.INIT
    gates_passed = 0
    tracked_gate = None
    prev_gate_distance = None
    distance_closing_count = 0
    no_detection_count = 0
    last_transit_time = 0
    transit_cooldown = 0.3  # seconds

    while phase not in (Phase.FINISHED, Phase.EMERGENCY):
        frame_start = time.monotonic()

        # ── SENSE ──────────────────────────────────────
        telemetry = await get_telemetry()       # attitude, position, velocity
        frame     = await get_frame()            # camera capture (~1ms)
        detection = detect_gates(frame)          # U-Net + RANSAC + PnP (~7ms)

        # ── TRACK ──────────────────────────────────────
        if detection:
            tracked_gate = ema_update(tracked_gate, detection, alpha=0.65)
            tracked_gate.stale = 0
            no_detection_count = 0
        else:
            if tracked_gate:
                tracked_gate.stale += 1
                if tracked_gate.stale >= 10:
                    tracked_gate = None          # drop stale gate
            no_detection_count += 1

        # ── DECIDE (state machine) ─────────────────────
        if phase == Phase.INIT:
            if telemetry.armed:
                phase = Phase.TAKEOFF

        elif phase == Phase.TAKEOFF:
            if telemetry.altitude >= 5.0:
                phase = Phase.SEEK_GATE

        elif phase == Phase.SEEK_GATE:
            if tracked_gate and tracked_gate.distance < 15.0:
                phase = Phase.APPROACH_GATE
                distance_closing_count = 0
            elif seek_timeout_exceeded(30):
                phase = Phase.EMERGENCY
            elif gates_passed > 0 and since_last_transit() > 30:
                phase = Phase.FINISHED

        elif phase == Phase.APPROACH_GATE:
            # Distance derivative for transit detection
            if tracked_gate and prev_gate_distance:
                dist_delta = prev_gate_distance - tracked_gate.distance
                if dist_delta > 0:
                    distance_closing_count += 1
                else:
                    distance_closing_count = 0
            if tracked_gate:
                prev_gate_distance = tracked_gate.distance

            # Check transit conditions
            if (tracked_gate
                and tracked_gate.distance < 1.5
                and distance_closing_count >= 3
                and tracked_gate.stale == 0
                and time.monotonic() - last_transit_time > transit_cooldown):
                phase = Phase.TRANSIT_GATE

            # Lost gate → back to SEEK (no recovery phase)
            elif no_detection_count >= 15:
                phase = Phase.SEEK_GATE
                tracked_gate = None
                prev_gate_distance = None

        elif phase == Phase.TRANSIT_GATE:
            gates_passed += 1
            last_transit_time = time.monotonic()
            log_split_time(gates_passed)
            tracked_gate = None               # reset tracker
            prev_gate_distance = None
            distance_closing_count = 0
            if gates_passed >= expected_gates:
                phase = Phase.FINISHED
            else:
                phase = Phase.SEEK_GATE

        # ── ACT ────────────────────────────────────────
        command = compute_command(phase, tracked_gate, telemetry)
        await send_command(command)              # MAVLink (~0.1ms)

        # ── RATE LIMIT ─────────────────────────────────
        elapsed = time.monotonic() - frame_start
        await asyncio.sleep(max(0, 1/120 - elapsed))  # 120Hz target

Quick Reference Card