µChipmunks — Eurobot 2026

Plateforme logicielle complète pour la compétition Eurobot 2026, développée par l'équipe µChipmunks de l'ECAM Brussels Engineering School.

L'affiche du projet (cliquer pour la version PDF haute résolution).

Le projet couvre l'intégralité de la chaîne : firmware ESP32 (7 robots PAMI + 1 gros robot multi-ESP + bridge multi-robot), dashboard web temps réel (télémétrie, PID tuning avec simulation, contrôle stratégique), et pipeline de vision (détection d'éléments de jeu par caméra).

Les robots : le gros robot Ratatoskr (identifiant Dave dans le code) et les 7 PAMIs Alvin, Simon, Theodore, Sandy, Spip, Scrat et Moignon.

Composant	Stack	Rôle
Firmware PAMI	C++ · Arduino · ESP-NOW	Navigation, stratégie, odométrie, PID
Firmware Main	C++ · Arduino · ESP-NOW · UART COBS	Gros robot — Master ESP (stratégie, coordination)
Firmware Motor	C++ · Arduino · UART COBS	Gros robot — Motor ESP (PID, moteurs, IMU, servo)
Firmware Sensor	C++ · Arduino · UART COBS	Gros robot — Sensor ESP (9 US, capteur couleur)
Firmware Bridge	C++ · Arduino · ESP-NOW	Passerelle ESP-NOW ↔ USB pour le PC
Dashboard	React 19 · Express 5 · Prisma 7 · PostgreSQL 16	Supervision, PID tuning, stratégie temps réel
Vision	Python 3.12 · OpenCV 4	Détection ArUco + QR markers sur le terrain

🇬🇧 In English — Software stack of team µChipmunks (ECAM) for the Eurobot 2026 robotics competition: ESP32 firmware for a differential-drive main robot split across 3 ESP32s (strategy / motor control / sensors, linked by UART COBS) and 7 small PAMI robots, an ESP-NOW ↔ USB bridge, a real-time web dashboard (React, Express, Socket.IO, PostgreSQL) for strategy editing, telemetry and PID auto-tuning, and an OpenCV vision pipeline for ArUco/QR marker detection. Documentation is in French; code and comments are in English.

---

📚 Table des matières

• Documentation détaillée
• Prérequis
• Setup rapide
• Structure du projet
• Commandes
• Dashboard — Pages & composants
• Architecture de communication
• Architecture 3-ESP du gros robot
• Stratégie
• PID Tuning
• IntelliSense C++ (clangd)
• Contribuer
• Équipe
• Licence

---

📂 Documentation détaillée

READMEs

Sous-projet	README	Description
Programs	programs/README.md	Vue d'ensemble, démarrage rapide, liens
Firmware	programs/firmware/README.md	Architecture, 11 libs, 6 sketches, pattern d'init, build
Dashboard	programs/dashboard/README.md	Monorepo, 4 packages, pages, composants, Socket.IO, DB
Vision	programs/vision/README.md	Pipeline ArUco/QR, modules, protocole série, config

Audits & architecture

Document	Fichier	Description
Audit général	programs/AUDIT.md	Audit technique : navigation, stratégie, vision, comm
Qualité du code	programs/CODE_QUALITY_AUDIT.md	Race conditions, bugs, sécurité mémoire
Audit logging	programs/LOG_AUDIT.md	LogQueue, Telemetry, bridge, dashboard
Audit PID	programs/firmware/PID_AUDIT.md	Système PID détaillé (industrie vs actuel)
Architecture 3-ESP	programs/firmware/MAIN_ROBOT_3ESP_ARCHITECTURE.md	Architecture Master + Motor + Sensor via UART COBS
Architecture multi-core	programs/firmware/MULTICORE_ARCHITECTURE.md	ESP32 dual-core, FreeRTOS, synchronisation
Audit navigation	programs/firmware/NAVIGATION_AUDIT.md	A*, costmap, GoToPose, évitement, docking
Audit logique match	programs/firmware/MATCH_LOGIC_AUDIT.md	FSMs, obstacle avoidance, coordination multi-robot
Legacy mission	programs/firmware/LEGACY_MISSION.md	Coexistence Mission (10 s) vs Strategy (100 s)
Checklist de test	programs/firmware/TEST_CHECKLIST.md	Template de test exhaustif (PAMI + Dashboard)

Règles & stratégie

Document	Fichier	Description
Dimensions terrain	rules/dimensions.md	Table 3000×2000, coordonnées zones
Analyse PID PAMI	rules/analyse_pid_pami.md	Contraintes PAMI (15 s, 1–2 m, ±5 cm)
Règles Eurobot	rules/rules.txt	Règlement complet de la compétition

---

📋 Prérequis

Outil	Usage
Nix (avec flakes)	Dev shell reproductible (fournit tout ci-dessous)
direnv	Activation automatique du shell Nix
VS Code	Éditeur recommandé — extensions auto-suggérées

Le flake.nix fournit : arduino-cli, clangd 18, node 24, pnpm, python 3.12 (+OpenCV, numpy), postgresql 16, prisma-engines 7.

---

🚀 Setup rapide

1. Cloner le dépôt

git clone https://git.msrl.be/42/uChipMunks.git
cd uChipMunks

2. Activer l'environnement Nix

direnv allow                     # active le shell Nix (une seule fois)

Sans direnv : lancer nix develop manuellement à la racine.

2b. Alternative sans Nix (Arch Linux, etc.)

Si vous n'utilisez pas Nix, installez les dépendances manuellement :

# Arch Linux (adapter pour votre distro)
sudo pacman -S arduino-cli nodejs npm
yay -S pnpm                           # ou: npm install -g pnpm

# ESP32 core
arduino-cli core update-index
arduino-cli core install esp32:esp32

# PostgreSQL — via Docker (rien à installer sur le système)
docker run -d --name eurobot-pg \
  -e POSTGRES_DB=eurobot \
  -e POSTGRES_HOST_AUTH_METHOD=trust \
  -p 5432:5432 \
  postgres:16-alpine
export DATABASE_URL="postgresql://postgres@localhost:5432/eurobot"

# Dashboard — générer le client Prisma avant de lancer
cd programs/dashboard
pnpm install
pnpm db:generate                      # indispensable avant le premier pnpm dev
pnpm db:push                          # créer les tables en base
pnpm dev                              # frontend :5173 + backend :3001

2c. Alternative sans Nix (Windows)

# Installer les outils (via winget ou les installeurs officiels)
winget install Arduino.ArduinoCLI
winget install OpenJS.NodeJS.LTS
npm install -g pnpm

# ESP32 core
arduino-cli core update-index
arduino-cli core install esp32:esp32

# PostgreSQL — via Docker Desktop
docker run -d --name eurobot-pg `
  -e POSTGRES_DB=eurobot `
  -e POSTGRES_HOST_AUTH_METHOD=trust `
  -p 5432:5432 `
  postgres:16-alpine
$env:DATABASE_URL = "postgresql://postgres@localhost:5432/eurobot"

# Dashboard — générer le client Prisma avant de lancer
cd programs\dashboard
pnpm install
pnpm db:generate                      # indispensable avant le premier pnpm dev
pnpm db:push                          # créer les tables en base
pnpm dev                              # frontend :5173 + backend :3001

Note

: sur Windows, le port série du bridge sera COM3, COM4, etc. (visible dans le Gestionnaire de périphériques). Utiliser pnpm dev:serial ne marchera pas directement — passer le port manuellement via la page Setup du dashboard.

3. Générer l'IntelliSense C++ pour le firmware

cd programs/firmware
./gen-compile-db.sh              # compile_commands.json → clangd

Puis dans VS Code : Ctrl+Shift+P → "clangd: Restart language server"

---

🗂️ Structure du projet

.
├── flake.nix                         # Nix dev shell (tout-en-un)
├── .clangd                           # Config clangd (IntelliSense C++)
├── .vscode/                          # Settings & extensions recommandées
│
├── programs/
│   ├── firmware/
│   │   ├── pami/                     #   Sketch PAMI (5 fichiers)
│   │   │   ├── pami.ino             #     Point d'entrée
│   │   │   ├── Config.h             #     Pins, constantes physiques
│   │   │   ├── PamiStrategy.cpp     #     Machine d'états (7 états)
│   │   │   ├── Mission.h / .cpp     #     Logique mission + assignations
│   │   │
│   │   ├── main/                     #   Master ESP — orchestrateur (3 fichiers)
│   │   │   ├── main.ino             #     Point d'entrée (stratégie, ESP-NOW, UART dispatch)
│   │   │   ├── Config.h             #     Pins UART, heartbeat, calibration
│   │   │   └── MainStrategy.cpp     #     Machine d'états (9 états)
│   │   │
│   │   ├── motor/                    #   Motor ESP — contrôleur moteur (2 fichiers)
│   │   │   ├── motor.ino            #     PID 200 Hz, IMU, encodeurs, servo, GoToPose
│   │   │   └── Config.h             #     Pins moteurs/encodeurs/IMU/servo
│   │   │
│   │   ├── sensor/                   #   Sensor ESP — capteurs (4 fichiers)
│   │   │   ├── sensor.ino           #     9 ultrasons ISR, capteur couleur TCS3200
│   │   │   ├── Config.h             #     Pins capteurs
│   │   │   ├── TCS3200.h / .cpp     #     Driver capteur couleur
│   │   │
│   │   ├── bridge/                   #   Passerelle ESP-NOW ↔ USB (8 fichiers)
│   │   │   ├── bridge.ino           #     Point d'entrée
│   │   │   ├── PeerRegistry.*       #     Mapping MAC ↔ robotId
│   │   │   ├── EspNowBridge.*       #     Init/receive/send/chunk
│   │   │   ├── SerialProtocol.*     #     Parse/route @target cmds
│   │   │   └── NvsHelper.*          #     Persistence NVS
│   │   │
│   │   ├── lib/                      #   11 bibliothèques partagées
│   │   │   ├── CommDefs/            #     Protocole ESP-NOW (v2.0)
│   │   │   ├── CytronMD/           #     Driver moteur MDD3A / MDD10A
│   │   │   ├── EurobotConfig/      #     Constantes partagées
│   │   │   ├── EurobotControl/     #     PID (anti-windup, deadband)
│   │   │   ├── EurobotCore/        #     State, Telemetry, LED, Commands, Strategy
│   │   │   ├── EurobotIMU/         #     IMU, AngleFusion, CalibStore, CollisionDetector
│   │   │   ├── EurobotLog/         #     LOG() chunké via ESP-NOW
│   │   │   ├── EurobotMotion/      #     Moteurs, encodeurs, odométrie, motion
│   │   │   ├── EurobotNav/         #     A*, costmap, GoToPose, NavConfig
│   │   │   ├── EurobotSensor/      #     Ultrasons, évitement réactif
│   │   │   └── EurobotUART/        #     Protocole UART COBS (inter-ESP 921600 baud)
│   │   │
│   │   ├── tools/
│   │   │   ├── calibration/         #   Calibration moteurs/encodeurs
│   │   │   ├── encoder_test/        #   Test isolé des encodeurs
│   │   │   ├── servo_test/          #   Test servo SG90
│   │   │   ├── test_bod/            #   Test Brown-Out Detection
│   │   │   └── testCodeurs/         #   Test codeurs (variante)
│   │   │
│   │   ├── build.sh                  #   Build / upload / monitor
│   │   └── gen-compile-db.sh        #   Génère compile_commands.json
│   │
│   ├── dashboard/                    # ── WebUI monorepo (Turborepo) ─────
│   │   ├── apps/
│   │   │   ├── web/                 #   React 19 + Vite 6 + PixiJS + uPlot
│   │   │   │   └── src/
│   │   │   │       ├── pages/       #     9 pages (Live, Setup, Calibration, Diagnostics, ...)
│   │   │   │       └── components/  #     22 composants + 6 sous-composants setup
│   │   │   └── server/              #   Express 5 + Socket.IO 4
│   │   │
│   │   ├── packages/
│   │   │   ├── shared/              #   Types TS, protocole binaire,
│   │   │   │                        #   constantes table, simulation PID
│   │   │   └── db/                  #   Prisma 7 schema (PostgreSQL 16)
│   │   │
│   │   ├── turbo.json               #   Turborepo task pipeline
│   │   └── pnpm-workspace.yaml      #   pnpm workspace config
│   │
│   ├── vision/                       # ── Pipeline de vision ─────────────
│   │   ├── flake.nix                #   Dev shell Nix (Python + OpenCV + scrcpy)
│   │   ├── detect_markers.py        #   Détection ArUco + QR (4K @ 30fps)
│   │   ├── marker_detection/        #   Modules (config, aruco, qr, serial, grid)
│   │   ├── aruco/                   #   Générateur de marqueurs ArUco
│   │   └── requirements.txt
│   │
│   └── _archive/                     #   Code obsolète (référence)
│
├── rules/                            # Règles Eurobot + simulateurs stratégie
└── affiche/                          # Poster et visuels du projet

---

⚡ Commandes

Firmware ESP32

cd programs/firmware

./build.sh pami               # Compiler le firmware PAMI
./build.sh main               # Compiler le Master ESP (gros robot)
./build.sh motor              # Compiler le Motor ESP (gros robot)
./build.sh sensor             # Compiler le Sensor ESP (gros robot)
./build.sh bridge             # Compiler le bridge
./build.sh calibration        # Compiler la calibration
./build.sh encoder_test       # Compiler le test encodeur
./build.sh all                # Tout compiler (pami + main + motor + sensor + bridge + calibration)

./build.sh upload pami        # Compiler + flasher sur /dev/ttyUSB0
./build.sh upload main        # Flasher le Master ESP
./build.sh upload motor       # Flasher le Motor ESP
./build.sh upload sensor      # Flasher le Sensor ESP
PORT=/dev/ttyUSB1 ./build.sh upload bridge   # Port custom
BAUD=115200 ./build.sh monitor               # Moniteur série

Le flag -DPAMI_ID=N peut être ajouté pour identifier chaque PAMI (0–6).

Dashboard

cd programs/dashboard

pnpm install                  # Installer les dépendances
pnpm db:generate              # Générer le client Prisma (première fois)
pnpm db:push                  # Appliquer le schema en base (première fois)
pnpm dev                      # Lancer en dev (frontend :5173 + backend :3001)
pnpm dev:serial               # Idem + auto-connect bridge sur /dev/ttyUSB0
pnpm turbo build              # Build production (4 packages)

En dev, ouvrir http://localhost:5173 (Vite dev server). Le port :3001 sert uniquement l'API et les WebSockets. PostgreSQL est démarré automatiquement par le shell Nix — pas de config manuelle nécessaire.

Vision

cd programs/vision
nix develop                   # Active le shell Nix (Python + OpenCV précompilé + scrcpy)
python detect_markers.py      # Lancer la détection (headless, flux MJPEG vers le dashboard)

Sans Nix : pip install -r requirements.txt && python detect_markers.py Le flake.nix racine inclut aussi les dépendances vision — direnv allow à la racine suffit. Fenêtres OpenCV (--gui, tools/calibrate_camera.py) : utiliser nix develop .#gui dans programs/vision. Ce shell compile OpenCV avec GTK3 (~1 h la première fois).

---

🎮 Dashboard — Pages & composants

Page	Route	Description
Live Game	/	Carte PixiJS, cartes robot, score, stratégie en direct
Setup	/setup	Checklist pré-match, connexion série, couleur équipe
Calibration	/calibration	PID tuning avec simulation FOPDT, calibration moteurs
Monitoring	/monitoring	Graphes uPlot temps réel (vitesse, angle, PWM, position)
Diagnostics	/diagnostics	Diagnostic encodeurs et état des ESPs
Replay	/replay	Replay de matchs enregistrés
History	/history	Historique des matchs (base de données)
Robot Config	/robots	Configuration persistée des robots (PID, ports, MAC)
Strategy Editor	/strategy	Éditeur de stratégies et circuits

Composants clés

Composant	Rôle
MapCanvas	Carte 2D PixiJS (table 300×200 cm, robots, GMs, zones)
TrajectoryCanvas	Visualisation de trajectoire robot sur la carte
PidTuningPanel	Réglage Kp/Ki/Kd + simulation FOPDT + graphe step response + métriques (overshoot, rise/settling time, SSE) + auto-tune IMC
TelemetryCharts	Graphes uPlot synchronisés : setpoint vs actual (vitesse + angle), erreurs PID, PWM, position, distance
StrategyPanel	Assignation PAMI → garde-manger, actions (occupy/push/clear), patterns rapides
ActiveStrategyPanel	Affichage de la stratégie active en temps réel
PamiAssignmentPanel	Assignation individuelle des PAMIs aux garde-mangers
ScoreDisplay	Score estimé temps réel (PAMIs dans GMs + robot dans nid)
ScoreBreakdownPanel	Décomposition détaillée du score par source
ScoreProjection	Projection du score futur
CalibrationPanel	Interface de calibration moteurs/encodeurs
AutoCalibPanel	Calibration automatique (spin, ratio, etc.)
EdDiagTable	Tableau diagnostic encodeurs
MamanCircuitEditor	Éditeur visuel de circuit pour le gros robot
MatchTimeline	Timeline des événements du match
CameraFeed	Liste des détections caméra (type, position, âge)
RobotCard	État d'un robot (pose, vitesse, état stratégie, connexion)
CommandPanel	Envoi de commandes ESP-NOW (start, stop, goal)
EventLog	Journal d'événements temps réel
LogTerminal	Terminal de logs série/ESP-NOW
ErrorBoundary	Gestion d'erreurs React (fallback gracieux)

---

📡 Architecture de communication

┌─────────────────────────────────────────────────────────────────────────┐
│                           Terrain Eurobot                              │
│                                                                         │
│  ┌────────┐  ┌────────┐        ┌────────┐                               │
│  │ PAMI 1 │  │ PAMI 2 │  ...   │ PAMI 7 │     ┌── Gros Robot ────────┐  │
│  │ ESP32  │  │ ESP32  │        │ ESP32  │     │  ┌──────────────┐    │  │
│  └───┬────┘  └───┬────┘        └───┬────┘     │  │ Master ESP32 │    │  │
│      │           │                 │          │  │ (stratégie,  │    │  │
│      │           │                 │          │  │  ESP-NOW,    │    │  │
│      │           │                 │          │  │  A*, costmap)│    │  │
│      │           │                 │          │  └──┬───────┬───┘    │  │
│      │           │                 │          │  UART│COBS  │UART   │  │
│      │           │                 │          │  921600     │COBS   │  │
│      │           │                 │          │  ┌──┴───┐ ┌─┴────┐  │  │
│      │           │                 │          │  │Motor │ │Sensor│  │  │
│      │           │                 │          │  │ESP32 │ │ESP32 │  │  │
│      │           │                 │          │  │PID,  │ │9 US, │  │  │
│      │           │                 │          │  │IMU,  │ │color │  │  │
│      │           │                 │          │  │servo │ │TCS   │  │  │
│      │           │                 │          │  └──────┘ └──────┘  │  │
│      │           │                 │          └─────────┬───────────┘  │
└──────┼───────────┼─────────────────┼───────────────────┼──────────────┘
       │           │  ESP-NOW (ch 1) │                   │
       └─────┬─────┘─────────────────┘───────────────────┘
             │
       ┌─────┴──────────┐
       │   Bridge ESP32 │
       │  PeerRegistry  │  ← auto-register unknown MACs
       │  EspNowBridge  │  ← reassembly (16 buffers, 8 chunks)
       │  SerialProtocol│  ← parse @target commands
       └───────┬────────┘
               │ USB Série (115200 baud)
               │ TX: <robotId>JSON\n
               │ RX: @robotId command\n
       ┌───────┴────────┐
       │  Node.js Server│
       │  SerialManager │  ← multi-port, echo filtering
       │  RobotStore    │  ← état robots, match, score
       │  CameraManager │  ← subprocess vision Python
       │  RecordingMgr  │  ← télémétrie → PostgreSQL
       └───────┬────────┘
               │ Socket.IO / WebSocket
       ┌───────┴────────┐          ┌──────────────────┐
       │ React Frontend │          │  Caméra USB      │
       │  TanStack Router│         │  (4K @ 30fps)   │
       │  TelemetryBuf  │          └────────┬─────────┘
       └────────────────┘                   │ Serial direct
                                   ┌────────┴─────────┐
                                   │detect_markers.py │
                                   │ ArUco + QR       │
                                   └──────────────────┘

Couches de communication

Couche	Protocole	Baud / Fréq	Description
Inter-ESP (gros robot)	UART COBS + CRC-8	921600 baud	Master ↔ Motor, Master ↔ Sensor. Frames: [type|seq|len|payload|CRC8], max 32 B payload. Voir MAIN_ROBOT_3ESP_ARCHITECTURE.md.
ESP-NOW	CommDefs v2.0	Ch 1, plaintext	Robots ↔ Bridge. Header 8 B + payload 50 B max. Types: telemetry, commands, ACK, opponent pos, goal, status, match start, PID tune. Chunking pour les gros messages.
Série USB	Texte ligne par ligne	115200 baud	Bridge ↔ Serveur Node.js. TX: <robotId>JSON\n, RX: @robotId command\n.
Socket.IO	WebSocket	—	Serveur ↔ Frontend React. 14 événements serveur → client, 13 client → serveur.
Vision	Serial direct + subprocess	—	Caméra → detect_markers.py → Bridge ESP32 / Node.js.

---

🔧 Architecture 3-ESP du gros robot

Le gros robot utilise 3 ESP32 interconnectés par UART COBS à 921600 baud (bibliothèque EurobotUART) :

ESP	Sketch	Core 0	Core 1	Responsabilités
Master	main/	uartDispatchTask (parse UART Motor + Sensor)	loop() (stratégie, ESP-NOW, télémétrie, A*)	Orchestration, pathfinding, communication externe
Motor	motor/	uartTxTask (odométrie → Master)	motionTask (PID 200 Hz) + uartRxTask	PID cascade, encodeurs, IMU MPU6050, GoToPose, servos (herse, bras éjection), moteur éjection
Sensor	sensor/	uartCommsTask (COBS RX/TX)	sensorTask (US) + colorTask (TCS3200)	9 capteurs ultrason (ISR), capteur couleur (classification bleu/jaune)

Protocole UART COBS (EurobotUART) :

• Frame : [msgType (1B) | seqNum (1B) | len (1B) | payload (≤32 B) | CRC8 (1B)]
• COBS encoding + délimiteur 0x00 sur le fil
• Messages organisés par direction : 0x10–0x1F Master→Motor, 0x20–0x2F Master→Sensor, 0x80–0x8F Motor→Master, 0x90–0x9F Sensor→Master, 0xF0+ bidirectionnel (heartbeat)

Documentation complète : MAIN_ROBOT_3ESP_ARCHITECTURE.md et MULTICORE_ARCHITECTURE.md.

---

🧠 Stratégie

PAMI (7 états)

IDLE → WAIT_RELEASE → GOTO_TARGET → PUSH_NUTS → OCCUPY_ZONE → ACTIVATE_EATING → DONE
                                   └─────────────────────────┘
                                   (si goalAction == push)

• Chaque PAMI a un PAMI_ID (0–6) et un fallbackGM par défaut
• Le dashboard peut réassigner les PAMIs via MSG_GOAL (GM cible + action)
• PUSH_NUTS pousse les noisettes en ligne droite vers le garde-manger le plus proche

Gros robot (9 états — architecture 3-ESP)

IDLE → GOTO_RAMASSAGE → POSITION_ABOVE → EJECT_BAD_NUTS → LOWER_HERSE
     → PUSH_TO_GM → LIFT_HERSE → RETURN_TO_NID → DONE

• Master ESP (main/main.ino) : exécute la stratégie, envoie les commandes de mouvement au Motor ESP via UART COBS
• Motor ESP (motor/motor.ino) : PID cascade 200 Hz, encodeurs + IMU MPU6050, GoToPose, servos (herse + bras éjection)
• Sensor ESP (sensor/sensor.ino) : 9 ultrasons ISR + capteur couleur TCS3200 (classification bleu/jaune)
• Sélectionne les zones de ramassage optimales (score × proximité)
• Fine-positioning au-dessus de la zone avec goToPose() (tolérance serrée)

---

📊 PID Tuning

Le système PID offre une chaîne complète du modèle à la validation :

Étape	Outil	Description
Simulation	pid-sim.ts	Simulation FOPDT boucle fermée (567 lignes, port de package_LAB.py)
Auto-tune	IMC	Calcul automatique des gains depuis le modèle process (FOPDT/SOPDT)
Envoi gains	PidTuningPanel	Kp/Ki/Kd → binaire MSG_PID_TUNE → robot, avec sauvegarde NVS
Graphe simulation	uPlot	Step response (SP/PV/MV) + métriques (overshoot, settling, rise time, SSE)
Graphes temps réel	TelemetryCharts	Setpoint vs actual (vitesse + angle), erreurs PID, PWM, position

---

🔧 IntelliSense C++ (clangd)

Le projet utilise clangd 18 pour l'IntelliSense C++ dans VS Code. La configuration gère le cross-compilation ESP32 (xtensa) → x86_64 (host) automatiquement :

• gen-compile-db.sh — génère compile_commands.json depuis un build verbose arduino-cli, résout les ~290 include paths ESP-IDF et les 6 chemins implicites GCC
• .clangd — injecte les defines xtensa (__XTENSA__, ABI 32-bit) et supprime les flags GCC incompatibles clang
• .vscode/settings.json — configure --query-driver pour le toolchain xtensa

En cas d'erreurs #include :

cd programs/firmware
./gen-compile-db.sh
# Puis dans VS Code : Ctrl+Shift+P → "clangd: Restart language server"

---

🏗️ Contribuer

1. S'assurer que le shell Nix est actif (direnv allow ou nix develop)
2. Générer le compile_commands.json avant de toucher au firmware
3. Utiliser ./build.sh all pour vérifier que le firmware compile (6 sketches)
4. Le dashboard utilise pnpm — ne pas utiliser npm/yarn
5. pnpm turbo build pour vérifier le dashboard (4 packages)

La CI Forgejo Actions (.forgejo/workflows/ci.yml) rejoue ces vérifications à chaque push et pull request : build du dashboard, tests pytest de la vision et compilation de tous les sketches firmware.

---

👥 Équipe

Projet réalisé par l'équipe µChipmunks (ECAM Brussels Engineering School, MA1) pour Eurobot 2026 :

Pôle	Membres
Électronique	Baptiste Guilluy
Software	Issakha Yaya Libis · Bruno Masureel · Arifcan Yildirim
Mécanique	Hugo Perdaens · Louis Pierre

Encadrement : Cédric Marchand et Clémence Flémal.

---

📄 Licence

Le code de ce dépôt est distribué sous licence MIT.

Les documents du règlement Eurobot présents dans rules/ restent la propriété de leurs auteurs (Planète Sciences / Eurobot) et ne sont pas couverts par cette licence.