ENIB 2026 : Enibel

Introduction

Dans le cadre de notre intersemestre, nous participons au hackathon « Hack the POCL », organisé par Les Petits Débrouillards et Les Fabriques du Ponant.

L’objectif de ce hackathon est de rendre des données tangibles en inventant un POCL : un Petit Objet Connecté Ludique.

Notre projet doit également être documenté, c’est pourquoi ce wiki a été créé, afin de retracer la genèse et l’évolution de notre travail.

Nous avons choisi de concevoir un décibelmètre capable d’allumer différentes LED en fonction du niveau sonore capté par un micro.

Ce dispositif peut avoir plusieurs usages, le plus évident étant une utilisation en salle de classe.

Une fois le système installé, une limite de décibels sera définie dans le code que nous fournirons, afin de déclencher l’allumage des LED selon le niveau de bruit. 3 niveaux :

• Vert : le niveau sonore est faible
• Jaune : le niveau sonore est assez élevé
• Rouge : le niveau sonore est très élevé

Équipe

Voici notre équipe :

À gauche : Léïa et Maël

À droite : Arthur et Alexis

Ainsi que Mael, non présent lors de la photo

Nous sommes tous les cinq des étudiant·e·s de 3e année de l'ENIB

Outils et matériel

Pour réaliser ce projet, nous avons besoin :

• Un ESP32S (ou node MCU_32S)
• Un ESP32S 38P
• Un panneau LED 16x16
• Des câbles Dupont
• Un micro INMP441

Fichiers à joindre

Code Arduino

  1  
  2 
  3 //Librairie
  4 #include <Adafruit_NeoPixel.h>
  5 #include <driver/i2s.h>
  6 
  7 //Configuration
  8 ///Leds
  9 #define W2812_PIN 27 //Broche du Din du panneau led 
 10 #define WS2812_PIXELS_NUM 256 // Nombres de leds
 11 ///Micro
 12 #define I2S_WS 25 //GPIO 25
 13 #define I2S_SD 32 //GPIO 32
 14 #define I2S_SCK 33 //GPIO 33
 15 
 16 //Matrice
 17 Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800); 
 18 // Crée l'instance ledStrip avec 256 LED/pixels sur la sortie GPIO27->PIN27 du microcontrôleur. La communication se fera en GRB (Green, Red, Blue) à 800kHZ
 19 
 20 //Variable systèmes
 21 ///Luminosité
 22 const int luminosite = 5;
 23 ///Couleurs codées en (red, green, blue)
 24 uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
 25 uint32_t green = ledStrip.Color(0, 255, 0); // Vert
 26 uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
 27 uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
 28 uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine
 29 ///Seuils son
 30 const int seuil_orange = 70; //dB -> Jaune
 31 const int seuil_rouge = 90; //dB -> Rouge
 32 const int GAIN_CALIBRATION = 20;
 33 ///Variable micro
 34 unsigned long lastAudioRead = 0;
 35 float dB_cached = 0;
 36 ///Dessins
 37 // On utilise uint16_t car il y a 16 bits (pixels) par ligne
 38 const uint16_t faceHappy[16] = {
 39   0b0000000000000000,
 40   0b0000011111100000,
 41   0b0000100000010000,
 42   0b0001000000001000,
 43   0b0010000000000100,
 44   0b0100011000110010, // Yeux
 45   0b0100011000110010, // Yeux
 46   0b0100000000000010,
 47   0b0100000000000010,
 48   0b0100100000010010, // Début sourire
 49   0b0100010000100010,
 50   0b0010001111000100,
 51   0b0001000000001000,
 52   0b0000100000010000,
 53   0b0000011111100000,
 54   0b0000000000000000
 55   
 56 };
 57 
 58 const uint16_t faceNeutral[16] = {
 59   0b0000000000000000,
 60   0b0000011111100000,
 61   0b0000100000010000,
 62   0b0001000000001000,
 63   0b0010000000000100,
 64   0b0100011000110010, // Yeux
 65   0b0100011000110010, // Yeux
 66   0b0100000000000010,
 67   0b0100000000000010,
 68   0b0100000000000010,
 69   0b0100111111110010, // Bouche droite
 70   0b0010000000000100,
 71   0b0001000000001000,
 72   0b0000100000010000,
 73   0b0000011111100000,
 74   0b0000000000000000
 75 };
 76 
 77 const uint16_t faceSad[16] = {
 78   0b0000000000000000,
 79   0b0000011111100000,
 80   0b0000100000010000,
 81   0b0001000000001000,
 82   0b0010000000000100,
 83   0b0100011000110010, // Yeux
 84   0b0100011000110010, // Yeux
 85   0b0100000000000010,
 86   0b0100000000000010,
 87   0b0100001111000010, // Bouche triste
 88   0b0100010000100010,
 89   0b0010100000010100,
 90   0b0001000000001000,
 91   0b0000100000010000,
 92   0b0000011111100000,
 93   0b0000000000000000
 94 };
 95 int i;
 96 
 97 void setup() {
 98   // put your setup code here, to run once:
 99   Serial.begin(115200);
100   ledStrip.begin();
101   ledStrip.setBrightness(luminosite);
102   setupI2S();
103   Serial.println("BOOT OK");
104 }
105 
106 void loop() {
107 
108   // --- Lecture audio toutes les 100 ms ---
109   if (millis() - lastAudioRead > 100) {
110     dB_cached = readDecibels();
111     lastAudioRead = millis();
112     Serial.println(dB_cached);
113   }
114 
115   // --- Affichage ---
116   if (dB_cached >= seuil_rouge) {
117     afficherDessin(faceSad, red);
118   }
119   else if (dB_cached >= seuil_orange) {
120     afficherDessin(faceNeutral, yellow);
121   }
122   else {
123     afficherDessin(faceHappy, green);
124   }
125 
126   delay(10);   // laisse respirer FreeRTOS
127   yield();     // nourrit le watchdog
128   Serial.println("RUNNING");
129   delay(1000);
130 }
131 
132 //Fonction d'affichage en 16x16
133 void afficherDessin(const uint16_t dessin[], uint32_t couleur){
134   ledStrip.clear();
135   for (int y = 0; y<16; y++){
136     for (int x = 0; x<16; x++){
137       //On verif le bit x dans la ligne y ( en partant de la gauche)
138       if ((dessin[y]>>(15-x)) & 0x01){
139         int index;
140         // Logique serpentin pour largueur 16
141         if (y%2 ==0){
142           index = (y * 16) + x;
143         }else{
144           index = (y*16) + (15 - x);
145         }
146         ledStrip.setPixelColor(index, couleur);
147       }
148     }
149   }
150   ledStrip.show();
151 }
152 
153 //Fonction MICRO (I2S)
154 void setupI2S() {
155   const i2s_config_t i2s_config = {
156     .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
157     .sample_rate = 44100,
158     .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
159     .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
160     .communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
161     .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
162     .dma_buf_count = 8,
163     .dma_buf_len = 64
164   };
165   i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
166   const i2s_pin_config_t pins = {.bck_io_num = I2S_SCK, .ws_io_num = I2S_WS, .data_out_num = -1, .data_in_num = I2S_SD};
167   i2s_set_pin(I2S_NUM_0, &pins);
168   i2s_zero_dma_buffer(I2S_NUM_0);
169   delay(10);
170 }
171 
172 float readDecibels() {
173   static int32_t samples[128];
174   size_t bytesRead = 0;
175 
176   esp_err_t result = i2s_read(
177     I2S_NUM_0,
178     samples,
179     sizeof(samples),
180     &bytesRead,
181     20 / portTICK_PERIOD_MS
182   );
183 
184   if (result != ESP_OK || bytesRead < 16) {
185     return dB_cached;  // garde l’ancienne valeur
186   }
187 
188   long long sum = 0;
189   int count = bytesRead / 4;
190 
191   for (int i = 0; i < count; i++) {
192     int32_t val = samples[i] >> 14;
193     sum += (int64_t)val * val;
194   }
195 
196   float rms = sqrt((float)sum / count);
197   if (rms <= 0) return dB_cached;
198 
199   return 20.0 * log10(rms) + GAIN_CALIBRATION;
200 }

Schéma de branchement

Étapes de fabrication

Ce projet est assez simple et nécessite peu d'étapes :

Étape 1

Tout d'abord, vérifiez le matériel : que les pins soient en bon état, qu'il n'y ait pas de câble sectionné, pas de LED cassé…

Pour l'Arduino, il faut connecter l'ESP32S à votre ordinateur et également avoir l'application Arduino et leurs pilotes (Adafruit DMA neopixel library par Adafruit). Pour plus de détails, référez vous vers ce lien : https://www.wikidebrouillard.org/wiki/Utiliser_l%27ESP32_avec_le_logiciel_Arduino

Étape 2

Ouvrez l'application Arduino et copiez le code fourni.

Faites le branchement également fourni.

Étape 3

Vous pouvez modifiez dans le code les différents paramètres mis en valeur par défaut pour changer les niveaux de décibels où les LEDs s'activent.

Vous pouvez également changer pour adapter à un panneau LED plus petit ou plus grand.

De même pour l'affichage ainsi que les couleurs qui s'activeront.

Notre histoire

Après avoir réfléchis a plusieurs idées, nous sommes partis sur un décibelmètre capable d’allumer différentes LED en fonction du niveau sonore capté par un micro.

Pour cela, nous étions parti sur des LEDs polarisées mais après une demande au magasin des petits débrouillards, nous avons eu un panneau LED ce qui nous arrange pour le résultat final. Nous voulons faire un smiley pour le cas d'une salle de classe.

Un problème que nous avons rencontré est le branchement du panneau LED qui ne marchait sur aucun des appareils de l'équipe et le téléversement du code sur l'ESP32S avec l'erreur

Problème

rstx0x8 (TG1WDT_SYS_RESET)

Solution

Sources et documentation complémentaire

• Rédаctiоn et illustratiоn :
  

Pоur tоus vоs trаvauх, qu'ils sоient écrits оu visuels, l'utilisatiоn de l'intеlligеnce artificiеllе générativе, que сe sоit pоur le teхte оu les images, n'еst pas conseillé.

• Prоgrammаtiоn :
  

En сe qui cоncernе la prоgrаmmatiоn, il est еssentiеl de ne pаs faire dе l'IA vоtrе prеmier rеcоurs. Cоncеntrеz-vоus d'abоrd sur vоtre prоpre lоgiquе, votre experience еt lеs ressоurcеs disponibles.

• Transpаrence et dосumеntatiоn :
  

Si vоus utilisеz l'IA pоur déblоquer оu améliоrеr une pаrtiе de vоtre cоdе, il est cruciаl de l'indiquеr сlairеmеnt dans vоtre dосumentatiоn tеchniquе.

• Traçabilité :
  

Chаque ехtrait de cоde généré avес l'аidе de l'IA dоit êtrе accоmpagné de la sоurce, ainsi que du prоmpt eхact qui a été utilisé pоur sа créatiоn, afin d'аssurеr une évaluatiоn clаire dе vоtre prоcessus.

Élément de présentation