AI Grand Prix — Complete Build & Deploy Guide

Virtual qualifier → 5" racer build → Neros Archer deploy • AIGP v4.0 • 2026-03-31 • Ctrl+P = PDF

Phase 1: Virtual Qualifier (May–July 2026)

No hardware needed. You download a DCL-built simulator, write Python AI code, and submit timed runs remotely.

1.1 How the sim works

1.2 Set up your dev environment (your laptop/PC)

# Install Python 3.12+ and create venv
python3 -m venv ~/aigp && source ~/aigp/bin/activate

# Install MAVSDK + dependencies
pip install mavsdk aioconsole numpy opencv-python torch torchvision

# Install PX4 SITL for local testing (before DCL sim releases)
git clone https://github.com/PX4/PX4-Autopilot.git --recursive
cd PX4-Autopilot && make px4_sitl jmavsim
# Sim opens. In another terminal:
python3 -c "
import asyncio
from mavsdk import System
async def t():
    d=System(); await d.connect(system_address='udp://:14540')
    async for s in d.core.connection_state():
        if s.is_connected: print('Connected to SITL!'); break
asyncio.run(t())
"

1.3 Virtual qualifier code structure

aigp/
├── config.py            # Platform switch: sim / diy / archer
├── main.py              # Entry: connect → arm → offboard → loop
├── perception/
│   ├── camera.py        # Camera abstraction (sim stream / GStreamer)
│   └── gate_detector.py # Your neural net (PyTorch → TensorRT)
├── planning/
│   ├── planner.py       # Pure pursuit / MPC / RL policy
│   └── state_est.py     # Fuse vision + IMU for gate-relative state
├── control/
│   └── commander.py     # MAVSDK wrapper: velocity/attitude cmds
└── utils/
    └── logger.py        # Save frames + detections for debugging

1.4 config.py — one file switches platforms

import os
PLATFORM = os.environ.get("AIGP_PLATFORM", "sim")

CONFIGS = {
    "sim":    {"addr": "udp://:14540",                    "cam": "sim"},
    "diy":    {"addr": "serial:///dev/ttyUSB0:921600",    "cam": "gst_csi"},
    "archer": {"addr": "serial:///dev/ttyTHS1:921600",    "cam": "gst_csi"},
}
CFG = CONFIGS[PLATFORM]

GST_CSI = ("nvarguscamerasrc sensor-id=0 ! "
    "video/x-raw(memory:NVMM),width=1920,height=1080,framerate=30/1 ! "
    "nvvidconv ! video/x-raw,format=BGRx,width=640,height=480 ! "
    "videoconvert ! video/x-raw,format=BGR ! appsink drop=1")

1.5 main.py — the core loop (works in sim and real)

import asyncio, cv2, numpy as np
from mavsdk import System
from mavsdk.offboard import VelocityBodyYawspeed
from config import CFG, GST_CSI, PLATFORM

# Camera setup per platform
if CFG["cam"] == "sim":
    cap = None  # sim provides frames via its own API
else:
    cap = cv2.VideoCapture(GST_CSI, cv2.CAP_GSTREAMER)

def detect_gate(frame):
    """Replace with your trained model. Returns (err_x, err_y, area) or None."""
    hsv = cv2.cvtColor(frame, cv2.COLOR_BGR2HSV)
    mask = cv2.inRange(hsv, (0,100,100), (15,255,255))
    cnts,_ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    if cnts:
        c = max(cnts, key=cv2.contourArea)
        if cv2.contourArea(c) > 500:
            M = cv2.moments(c)
            cx,cy = int(M["m10"]/M["m00"]), int(M["m01"]/M["m00"])
            return (cx-320)/320, (cy-240)/240, cv2.contourArea(c)
    return None

async def main():
    drone = System()
    await drone.connect(system_address=CFG["addr"])
    async for s in drone.core.connection_state():
        if s.is_connected: break
    async for h in drone.telemetry.health():
        if h.is_local_position_ok: break
    await drone.action.arm()
    await drone.offboard.set_velocity_body(VelocityBodyYawspeed(0,0,0,0))
    await drone.offboard.start()
    try:
        while True:
            ret, frame = cap.read() if cap else (True, get_sim_frame())
            if not ret: continue
            det = detect_gate(frame)
            if det:
                ex,ey,area = det
                fwd=float(np.clip(3.0-area/10000,0.5,4.0))
                yaw=float(-ex*40); vrt=float(ey*2.0)
            else:
                fwd,yaw,vrt = 0.0,15.0,0.0
            await drone.offboard.set_velocity_body(
                VelocityBodyYawspeed(fwd,0.0,vrt,yaw))
            await asyncio.sleep(0.01)
    except KeyboardInterrupt:
        await drone.offboard.stop(); await drone.action.land()
asyncio.run(main())

1.6 Submit to virtual qualifier

# 1. Download DCL sim package (released at qualification start)
#    Includes course, drone model, and submission instructions

# 2. Run your code against the sim locally
export AIGP_PLATFORM=sim
python3 main.py
# Iterate: watch flight logs, tune gate detector, improve planner

# 3. When ready, submit via DCL platform
#    Teams can attempt runs any time within qualification window
#    Once all gates are passed, your run time is locked
#    You can re-submit for a faster time

# 4. Round 1 cutoff: ~end of June
#    Round 2 (harder course): ~end of July
#    Top teams advance to physical qualifier

Phase 2: Build 5" Archer-Match Racer (August 2026)

Only if you advance past the virtual qualifier. This drone matches the Neros Archer's flight dynamics for sim-to-real testing.

2.1 What you're matching

2.2 Parts list — $694

2.3 Build — 7 steps, ~2 hours

Phase 3: Software Setup & First Flight

sudo systemctl enable ssh && sudo systemctl start ssh

sudo apt update && sudo apt upgrade -y
sudo apt install -y python3-pip python3-venv python3-dev git cmake \
    build-essential libopencv-dev python3-opencv
sudo apt install -y gstreamer1.0-tools gstreamer1.0-plugins-base \
    gstreamer1.0-plugins-good gstreamer1.0-plugins-bad
sudo usermod -aG dialout $USER && sudo reboot

python3 -m venv ~/aigp && source ~/aigp/bin/activate
pip install mavsdk aioconsole numpy pymavlink mavproxy
pip install torch torchvision  # verify: python3 -c "import torch; print(torch.cuda.is_available())"

# Live test
gst-launch-1.0 nvarguscamerasrc sensor-id=0 ! \
    'video/x-raw(memory:NVMM),width=1920,height=1080,framerate=30/1' ! \
    nvvidconv ! 'video/x-raw,width=640,height=480' ! nvvidconv ! nveglglessink

# OpenCV in Python:
import cv2
GST = ("nvarguscamerasrc sensor-id=0 ! "
    "video/x-raw(memory:NVMM),width=1920,height=1080,framerate=30/1 ! "
    "nvvidconv ! video/x-raw,format=BGRx,width=640,height=480 ! "
    "videoconvert ! video/x-raw,format=BGR ! appsink drop=1")
cap = cv2.VideoCapture(GST, cv2.CAP_GSTREAMER)
ret, frame = cap.read(); print(frame.shape)  # (480, 640, 3)

# QGroundControl (USB to Pixhawk):
# Flash: Firmware → PX4 Pro Stable
# Airframe: Generic Quadrotor X → Reboot
# Calibrate: Sensors → Compass, Gyro, Accel, Level
# Parameters:
#   MAV_1_CONFIG=TELEM2  MAV_1_MODE=Onboard  SER_TEL2_BAUD=921600
# Reboot. Radio → Calibrate. Flight Modes:
#   SW A = Arm   SW B = Stabilized/Position/Offboard   SW C = Kill

# MAVProxy quick test
mavproxy.py --master=/dev/ttyUSB0 --baudrate=921600  # HEARTBEAT = success

# MAVSDK test
python3 -c "
import asyncio; from mavsdk import System
async def t():
    d=System(); await d.connect(system_address='serial:///dev/ttyUSB0:921600')
    async for s in d.core.connection_state():
        if s.is_connected: print('Connected!'); break
    async for a in d.telemetry.attitude_euler():
        print(f'Roll:{a.roll_deg:.1f} Pitch:{a.pitch_deg:.1f}'); break
asyncio.run(t())"

3.7 First flight procedure

Phase 4: Deploy to Neros Archer at Competition

4.1 What changes

Only config.py changes: connection string and camera device path. Gate detector, planner, control logic — all identical.

4.2 Expected deploy workflow at the event

# 1. Connect to Archer's onboard computer via WiFi
ssh team@archer-drone.local    # or IP from organizers

# 2. Upload your code and model weights
scp -r aigp/ team@archer-drone.local:~/

# 3. Set platform
export AIGP_PLATFORM=archer

# 4. Verify camera
python3 -c "import cv2; cap=cv2.VideoCapture(GST_CSI, cv2.CAP_GSTREAMER); print(cap.read()[0])"

# 5. Verify MAVSDK connection
python3 -c "from mavsdk import System; ..."

# 6. FLY
python3 main.py
# Drone takes off, races gates, lands. Fastest clean lap = your score.

4.3 Pre-event checklist

• Gate detector exported as TensorRT .engine (5-10x faster than PyTorch)
• Tested on DIY drone AND sim — confirmed portability
• Data augmentation covers lighting/exposure variation
• Onboard logging saves frames + detections + commands to SSD
• Code on USB drive AND in git repo (redundancy)
• Practiced SSH → upload → run workflow on DIY drone
• config.py archer section ready — just update 2 lines at event

Reference

Key links

Pre-flight checklist

AI Grand Prix — Complete Build & Deploy Guide • v4.0 • 2026-03-31