MyLastNight FR
04 · project

Capteur Lego BrickHeadz

Domain: DIY Created: 2026-04-28 Updated: 2026-04-29

5 robots BrickHeadz customisés, chacun contenant un ESP32-S3-DevKitC N16R8 pour la détection de présence Wi-Fi CSI. Chaque robot dispose d'indicateurs LED intégrés qui reflètent le status du capteur r

Projet : Capteurs Radar dans figurines Lego BrickHeadz

Vision

5 robots BrickHeadz customisés, chacun contenant un ESP32-S3-DevKitC N16R8 pour la détection de présence Wi-Fi CSI. Chaque robot dispose d'indicateurs LED intégrés qui reflètent le status du capteur radar en temps réel.

Les 5 robots

# Pièce Idée de design Style LED
1 Salon R2-D2 style (droid trapu) Rampe Knight Rider frontale
2 Chambre Petit robot endormi / Wall-E Yeux LED (2x diffuseurs ronds)
3 Cuisine Robot cuisinier / Gonk droid Rampe Knight Rider sur le torse
4 Salle de bain Robot médecin / droïde médical Yeux LED + indicateur coeur
5 Entrée Robot gardien / droïde sonde Oeil unique central (cyclope)

Les designs sont des suggestions — à adapter selon l'inspiration dans BrickLink Studio.

Contraintes physiques

ESP32-S3-DevKitC N16R8

  • Dimensions : 69mm x 25.5mm x ~10mm (sans connecteurs)
  • Avec connecteurs USB-C : ajouter ~5mm de chaque côté en profondeur
  • Cavité minimum dans la figurine : 75mm x 30mm x 15mm

Format BrickHeadz

  • Taille standard : environ 55mm x 55mm x 70mm (7 x 7 x 9 briques)
  • Pour loger l'ESP32, prévoir un format légèrement plus grand : 8 x 8 x 10 briques minimum
  • La carte sera positionnée verticalement dans le torse du robot, le port USB-C vers le bas/arrière

Passage des câbles

  • 1 câble USB-C sort par l'arrière (alimentation)
  • 2 à 4 fils fins (AWG 28-30) montent vers la tête pour les LEDs
  • Prévoir un canal dans la construction Lego (1 brique de large suffit)

Types d'indicateurs LED

Type A : Yeux LED (pour robots à visage)

Deux LEDs 3mm ou 5mm montées derrière des briques Lego transparentes rondes 1x1.

    [O]  [O]     ← briques transparentes (diffuseurs)
     |    |
    LED  LED     ← 2x LED 3mm (ou 5mm)
     |    |
    GPIO  GPIO   ← 2 GPIOs + résistances

Comportements :
- Vert fixe → connecté, pièce vide
- Vert clignotant lent (1Hz) → présence détectée (immobile)
- Bleu pulsant → mouvement détecté
- Rouge fixe → erreur Wi-Fi / déconnecté
- Jaune clignotant rapide → calibration en cours
- Éteint → mode veille / économie d'énergie

Type B : Rampe Knight Rider (pour robots sans visage)

Barre de 5 à 8 LEDs rouges qui font un balayage gauche-droite façon K2000/KITT. Montée derrière une rangée de briques Lego transparentes rouges 1x1.

  [▪][▪][▪][▪][▪][▪][▪][▪]   ← 8 briques transparentes rouges 1x1
   |  |  |  |  |  |  |  |
  LED LED LED LED LED LED LED LED
   |  |  |  |  |  |  |  |
  ←——— Shift register 74HC595 ———→
        |     |     |
       DATA  CLK  LATCH
        |     |     |
      GPIO4  GPIO5  GPIO6

Comportements :
- Balayage lent → pièce vide, en veille
- Balayage rapide → présence détectée
- Balayage très rapide → mouvement actif
- Toutes allumées fixes → calibration
- Toutes éteintes sauf une qui clignote → erreur
- Pulsation (toutes en fondu) → connexion Wi-Fi en cours

Type C : Oeil unique (cyclope)

Une LED RGB (NeoPixel/WS2812) derrière une brique transparente ronde. Permet toutes les couleurs avec un seul GPIO.

    [O]          ← brique transparente ronde
     |
   WS2812       ← LED RGB adressable
     |
    GPIO         ← 1 seul GPIO (data)

Comportements : mêmes codes couleur que les yeux LED, mais avec des transitions de couleur fluides.

Type D : LED RGB intégrée (sur la carte)

L'ESP32-S3-DevKitC a déjà une LED RGB (WS2812) sur GPIO48. Visible à travers les interstices des briques Lego, ou via une brique transparente placée au-dessus de la carte.

Utile comme indicateur de debug même sans LEDs externes.

Pinout GPIO recommandé

GPIOs disponibles sur l'ESP32-S3-DevKitC N16R8

GPIOs à éviter absolument :

GPIO Raison
35, 36, 37 Flash/PSRAM Octal SPI interne
19, 20 USB natif (D-, D+)
43, 44 UART0 TX/RX (monitor série)

GPIO48 : LED RGB intégrée (WS2812) — utilisable, déjà soudée sur la carte.

Attribution GPIO par type de LED

Pour les yeux LED (Type A) — 2 GPIOs

Fonction GPIO Couleur fil
Oeil gauche GPIO4 Blanc
Oeil droit GPIO5 Jaune

Pour la rampe Knight Rider (Type B) — 3 GPIOs

Fonction GPIO Couleur fil
DATA (shift register) GPIO4 Blanc
CLOCK GPIO5 Jaune
LATCH GPIO6 Vert

Pour l'oeil unique NeoPixel (Type C) — 1 GPIO

Fonction GPIO Couleur fil
Data NeoPixel GPIO4 Blanc

LED RGB intégrée (Type D) — aucun câblage

Fonction GPIO
LED RGB carte GPIO48 (déjà câblé)

Résumé par robot

Robot Pièce Type LED GPIOs utilisés
R2-D2 Salon B (rampe) GPIO4, 5, 6
Wall-E Chambre A (yeux) GPIO4, 5
Gonk Cuisine B (rampe) GPIO4, 5, 6
Médical SdB A (yeux) + C (coeur) GPIO4, 5, 7
Gardien Entrée C (oeil unique) GPIO4

Tous utilisent aussi GPIO48 (LED RGB intégrée) comme indicateur de debug.

Schéma de câblage

LEDs simples (Type A — yeux)

GPIO4 ——[220Ω]——|>|—— GND
                 LED 3mm (verte ou bicolore)

GPIO5 ——[220Ω]——|>|—— GND
                 LED 3mm (verte ou bicolore)

Tension : 3.3V (sortie GPIO ESP32-S3)
Courant par LED : ~10mA avec résistance 220Ω
Pour des LEDs bicolores (vert/rouge) : 2 GPIOs par LED

Rampe Knight Rider (Type B)

ESP32-S3                   74HC595              LEDs
                        ┌──────────┐
GPIO4 (DATA) ──────────→│ SER   Q0 │──[220Ω]──|>|── GND
GPIO5 (CLK)  ──────────→│ SRCLK Q1 │──[220Ω]──|>|── GND
GPIO6 (LATCH)──────────→│ RCLK  Q2 │──[220Ω]──|>|── GND
                    3.3V─│ VCC   Q3 │──[220Ω]──|>|── GND
                     GND─│ GND   Q4 │──[220Ω]──|>|── GND
                    3.3V─│ OE    Q5 │──[220Ω]──|>|── GND
                     GND─│ SRCLR Q6 │──[220Ω]──|>|── GND
                         │       Q7 │──[220Ω]──|>|── GND
                         └──────────┘

Le 74HC595 permet de piloter 8 LEDs avec seulement 3 GPIOs. Chaînable pour plus de LEDs.

NeoPixel unique (Type C)

         3.3V
          │
GPIO4 ───[330Ω]───→ DIN ┌─────────┐ VDD ── 3.3V
                         │ WS2812  │
                    GND  └─────────┘ GND ── GND

Un seul fil de données, couleurs illimitées.

Liste de courses

Composants électroniques

Composant Qté Usage Prix estimé
LED 3mm verte diffuse 10 Yeux (Type A) ~2€
LED 3mm rouge diffuse 20 Rampe K2000 (Type B) ~3€
LED RGB WS2812B 5mm 5 Oeil unique (Type C) + coeur ~3€
Résistance 220Ω 1/4W 30 Limitation courant LEDs ~2€
Résistance 330Ω 1/4W 5 Protection data NeoPixel ~1€
74HC595 (DIP-16) 2 Shift register rampe K2000 ~2€
Fil AWG 28 silicone (5 couleurs) 1 rouleau Câblage interne ~5€
Connecteurs Dupont femelle 20 Branchement GPIO sans soudure ~3€
Condensateur 100µF 10V 5 Découplage alim NeoPixel ~1€

Total composants : ~22€

Briques Lego (à commander sur BrickLink)

Brique Couleur Qté Usage
Round Plate 1x1 (6141) Trans-Clear 10 Diffuseur yeux
Round Plate 1x1 (6141) Trans-Red 20 Diffuseur rampe K2000
Round Plate 1x1 (6141) Trans-Neon Green 5 Diffuseur alternatif
Plate 1x1 (3024) Diverses couleurs ~200 Structure robots
Brick 1x2 (3004) Diverses couleurs ~150 Structure robots
Tile 1x1 (3070) Noir 30 Finitions
Slope 1x1 (54200) Diverses 20 Détails visuels

Les quantités exactes dépendront des designs finaux dans BrickLink Studio.

Outillage

Outil Nécessaire ? Usage
Fer à souder Oui Souder LEDs et résistances
Étain fin (0.5mm) Oui Soudure précise
Pince à dénuder Oui Fils fins
Multimètre Recommandé Vérifier connexions
Pistolet à colle chaude Optionnel Fixer LEDs dans les briques
Mini perceuse (Dremel) Optionnel Percer des briques pour passer les fils

Code firmware — ajouts à app_main.c

Initialisation des GPIOs pour LEDs simples (Type A)

#include "driver/gpio.h"

#define LED_EYE_LEFT  GPIO_NUM_4
#define LED_EYE_RIGHT GPIO_NUM_5

void init_leds(void) {
    gpio_config_t io_conf = {
        .pin_bit_mask = (1ULL << LED_EYE_LEFT) | (1ULL << LED_EYE_RIGHT),
        .mode = GPIO_MODE_OUTPUT,
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = GPIO_INTR_DISABLE,
    };
    gpio_config(&io_conf);
}

void set_eyes(bool left, bool right) {
    gpio_set_level(LED_EYE_LEFT, left);
    gpio_set_level(LED_EYE_RIGHT, right);
}

Pilotage LED RGB intégrée (GPIO48 — WS2812)

#include "led_strip.h"

static led_strip_handle_t led_strip;

void init_rgb_led(void) {
    led_strip_config_t strip_config = {
        .strip_gpio_num = 48,
        .max_leds = 1,
    };
    led_strip_rmt_config_t rmt_config = {
        .resolution_hz = 10 * 1000 * 1000, // 10MHz
    };
    led_strip_new_rmt_device(&strip_config, &rmt_config, &led_strip);
    led_strip_clear(led_strip);
}

void set_rgb(uint8_t r, uint8_t g, uint8_t b) {
    led_strip_set_pixel(led_strip, 0, r, g, b);
    led_strip_refresh(led_strip);
}

// Exemples d'usage :
// set_rgb(0, 30, 0);    // Vert = pièce vide
// set_rgb(0, 0, 30);    // Bleu = mouvement
// set_rgb(30, 0, 0);    // Rouge = erreur
// set_rgb(30, 20, 0);   // Jaune = calibration

Animation Knight Rider (74HC595)

#define SHIFT_DATA  GPIO_NUM_4
#define SHIFT_CLK   GPIO_NUM_5
#define SHIFT_LATCH GPIO_NUM_6

void init_shift_register(void) {
    gpio_config_t io_conf = {
        .pin_bit_mask = (1ULL << SHIFT_DATA) | (1ULL << SHIFT_CLK) | (1ULL << SHIFT_LATCH),
        .mode = GPIO_MODE_OUTPUT,
    };
    gpio_config(&io_conf);
}

void shift_out(uint8_t data) {
    gpio_set_level(SHIFT_LATCH, 0);
    for (int i = 7; i >= 0; i--) {
        gpio_set_level(SHIFT_DATA, (data >> i) & 1);
        gpio_set_level(SHIFT_CLK, 1);
        gpio_set_level(SHIFT_CLK, 0);
    }
    gpio_set_level(SHIFT_LATCH, 1);
}

// Animation K2000 : une LED se déplace gauche-droite
void knight_rider_step(int *pos, int *direction) {
    uint8_t pattern = 1 << (*pos);
    shift_out(pattern);

    *pos += *direction;
    if (*pos >= 7 || *pos <= 0) {
        *direction = -(*direction);
    }
}

Intégration avec le radar

// Dans le callback radar, mettre à jour les LEDs selon le status
void update_leds_from_radar(bool someone, bool moving) {
    if (!wifi_connected) {
        set_rgb(30, 0, 0);           // Rouge = erreur
    } else if (calibrating) {
        set_rgb(30, 20, 0);          // Jaune = calibration
    } else if (moving) {
        set_rgb(0, 0, 30);           // Bleu = mouvement
    } else if (someone) {
        set_rgb(0, 30, 0);           // Vert clignotant = présence
    } else {
        set_rgb(0, 10, 0);           // Vert faible = vide
    }
}

Logiciel de conception

BrickLink Studio 2.0 (gratuit, Mac + Windows)
- Téléchargement : https://www.bricklink.com/v3/studio/download.page
- Conception 3D avec toutes les briques Lego existantes
- Génération d'instructions pas-à-pas
- Commande des pièces directement sur BrickLink

Ressources d'inspiration :
- BrickHeadz MOCs sur Rebrickable : https://rebrickable.com/mocs/?theme=610
- Pack robots Mazinger/Goldorak : https://rebrickable.com/mocs/MOC-77462/

Prochaines étapes

  1. Designer les 5 robots dans BrickLink Studio (prévoir cavité ESP32 + passage câbles)
  2. Commander les briques sur BrickLink
  3. Commander les composants électroniques
  4. Flasher les 4 ESP32 restants
  5. Souder les LEDs + résistances pour chaque robot
  6. Assembler les robots avec les ESP32 dedans
  7. Placer chaque robot à son emplacement définitif
  8. Calibrer chaque capteur sur place (train_start / train_stop)
  9. Modifier le firmware pour intégrer le pilotage LED
  10. Connecter les ESP32 au Pi Radar Station via USB (ou envisager Wi-Fi direct)

Resources

← All projects