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
• Une plaque Labdec
• Une imprimante 3D
• 4 inserts
• Une vis

Fichiers à joindre

Code Arduino

  1 //Librairie
  2 #include <Adafruit_NeoPixel.h>
  3 #include <driver/i2s.h>
  4 
  5 //Configuration
  6 
  7 ///LED
  8 #define W2812_PIN 27 //Broche du Din du panneau LED 
  9 #define WS2812_PIXELS_NUM 256 // Nombres de LED
 10 
 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 
 22 ///Luminosité
 23 const int luminosite = 10;
 24 
 25 ///Couleurs codées en (red, green, blue)
 26 uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
 27 uint32_t green = ledStrip.Color(0, 255, 0); // Vert
 28 uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
 29 uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
 30 uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine
 31 
 32 ///Seuils son
 33 const int seuil_orange = 70; //dB -> Jaune
 34 const int seuil_rouge = 90; //dB -> Rouge
 35 const int GAIN_CALIBRATION = 20;
 36 
 37 ///Variable micro
 38 unsigned long lastAudioRead = 0;
 39 float dB_cached = 0;
 40 
 41 ///Dessins
 42 // On utilise uint16_t car il y a 16 bits (pixels) par ligne
 43 const uint16_t faceHappy[16] = {
 44   0b1111111111111111,
 45   0b1111100000011111,
 46   0b1111011111101111,
 47   0b1110111111110111,
 48   0b1101111111111011,
 49   0b1011100111001101, // Yeux
 50   0b1011100111001101, // Yeux
 51   0b1011111111111101,
 52   0b1011111111111101,
 53   0b1011011111101101, // Début sourire
 54   0b1011101111011101,
 55   0b1101110000111011,
 56   0b1110111111110111,
 57   0b1111011111101111,
 58   0b1111100000011111,
 59   0b1111111111111111
 60 };
 61 
 62 const uint16_t faceNeutral[16] = {
 63   0b1111111111111111,
 64   0b1111100000011111,
 65   0b1111011111101111,
 66   0b1110111111110111,
 67   0b1101111111111011,
 68   0b1011100111001101, // Yeux
 69   0b1011100111001101, // Yeux
 70   0b1011111111111101,
 71   0b1011111111111101,
 72   0b1011111111111101,
 73   0b1011000000001101, // Bouche droite
 74   0b1101111111111011,
 75   0b1110111111110111,
 76   0b1111011111101111,
 77   0b1111100000011111,
 78   0b1111111111111111
 79 };
 80 
 81 const uint16_t faceSad[16] = {
 82   0b1111111111111111,
 83   0b1111100000011111,
 84   0b1111011111101111,
 85   0b1110111111110111,
 86   0b1101111111111011,
 87   0b1011100111001101, // Yeux
 88   0b1011100111001101, // Yeux
 89   0b1011111111111101,
 90   0b1011111111111101,
 91   0b1011110000111101, // Bouche triste
 92   0b1011101111011101,
 93   0b1101011111101011,
 94   0b1110111111110111,
 95   0b1111011111101111,
 96   0b1111100000011111,
 97   0b1111111111111111
 98 };
 99 
100 // Luminosité dynamique
101 uint8_t luminositeActuelle = 5;
102 const uint8_t LUMINOSITE_FORTE = 80;
103 const uint8_t LUMINOSITE_FAIBLE = 5;
104 const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
105 const unsigned long TEMPS_EXTINCTION = 60000;
106 
107 unsigned long dernierChangementCouleur = 0;
108 uint32_t couleurActuelle = 0;
109 
110 void setup() {
111   // put your setup code here, to run once:
112   Serial.begin(115200);
113   ledStrip.begin();
114   ledStrip.setBrightness(luminosite);
115   setupI2S();
116   Serial.println("BOOT OK");
117 }
118 
119 void loop() {
120   uint32_t nouvelleCouleur;
121   const uint16_t* nouveauDessin;
122 
123     // --- Lecture audio toutes les 200 ms ---
124   if (millis() - lastAudioRead > 200) {
125     dB_cached = readDecibels();
126     lastAudioRead = millis();
127     Serial.println(dB_cached);
128   }
129   // Choix du dessin et de la couleur
130   if (dB_cached >= seuil_rouge) {
131     nouveauDessin = faceSad;
132     nouvelleCouleur = red;
133   }
134   else if (dB_cached >= seuil_orange) {
135     nouveauDessin = faceNeutral;
136     nouvelleCouleur = yellow;
137   }
138   else {
139     nouveauDessin = faceHappy;
140     nouvelleCouleur = green;
141   }
142 
143   // Détection de changement de couleur
144   if (nouvelleCouleur != couleurActuelle) {
145     couleurActuelle = nouvelleCouleur;
146     luminositeActuelle = LUMINOSITE_FORTE;
147     ledStrip.setBrightness(luminositeActuelle);
148     dernierChangementCouleur = millis();
149   }
150 
151   // Atténuation après 30 secondes
152   if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
153     if (luminositeActuelle != LUMINOSITE_FAIBLE) {
154       luminositeActuelle = LUMINOSITE_FAIBLE;
155       ledStrip.setBrightness(luminositeActuelle);
156     }
157   }
158   if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
159     //Eteindre Après 1 minutes
160     ledStrip.setBrightness(0);
161   }
162 
163   // Affichage
164   afficherDessin(nouveauDessin, couleurActuelle);
165 }
166 
167 //Fonction d'affichage en 16x16
168 void afficherDessin(const uint16_t dessin[], uint32_t couleur){
169   ledStrip.clear();
170   /*if (couleur == green){
171     ledStrip.setBrightness(5);
172   }
173   else if (couleur == red){
174     ledStrip.setBrightness(200);
175   }
176   else{
177     ledStrip.setBrightness(50);
178   }*/
179   for (int y = 0; y<16; y++){
180     for (int x = 0; x<16; x++){
181       //On verif le bit x dans la ligne y ( en partant de la gauche)
182       if ((dessin[y]>>(15-x)) & 0x01){
183         int index;
184         // Logique serpentin pour largueur 16
185         if (y%2 ==0){
186           index = (y * 16) + x;
187         }else{
188           index = (y*16) + (15 - x);
189         }
190         ledStrip.setPixelColor(index, couleur);
191       }
192     }
193   }
194   ledStrip.show();
195 }
196 
197 //Fonction MICRO (I2S)
198 void setupI2S() {
199   const i2s_config_t i2s_config = {
200     .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
201     .sample_rate = 44100,
202     .bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
203     .channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
204     .communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
205     .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
206     .dma_buf_count = 8,
207     .dma_buf_len = 64
208   };
209   i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
210   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};
211   i2s_set_pin(I2S_NUM_0, &pins);
212   i2s_zero_dma_buffer(I2S_NUM_0);
213   delay(10);
214 }
215 
216 float readDecibels() {
217   static int32_t samples[128];
218   size_t bytesRead = 0;
219 
220   esp_err_t result = i2s_read(
221     I2S_NUM_0,
222     samples,
223     sizeof(samples),
224     &bytesRead,
225     20 / portTICK_PERIOD_MS
226   );
227 
228   if (result != ESP_OK || bytesRead < 16) {
229     return dB_cached;  // garde l’ancienne valeur
230   }
231 
232   long long sum = 0;
233   int count = bytesRead / 4;
234 
235   for (int i = 0; i < count; i++) {
236     int32_t val = samples[i] >> 14;
237     sum += (int64_t)val * val;
238   }
239 
240   float rms = sqrt((float)sum / count);
241   if (rms <= 0) return dB_cached;
242 
243   return 20.0 * log10(rms) + GAIN_CALIBRATION;
244 }

Schéma de branchement

Étapes de fabrication

Ce projet est relativement simple et nécessite peu d’étapes :

Étape 1

Tout d’abord, vérifiez l’état du matériel : assurez-vous que les pins sont en bon état, qu’aucun câble n’est sectionné et qu’aucune LED n’est endommagée.

Concernant l’Arduino, il est nécessaire de connecter l’ESP32S à votre ordinateur et de disposer de l’application Arduino ainsi que des pilotes requis, notamment la bibliothèque Adafruit DMA Neopixel développée par Adafruit.

Pour plus de détails sur l’installation et la configuration, vous pouvez vous référer au lien suivant : https://www.wikidebrouillard.org/wiki/Utiliser_l%27ESP32_avec_le_logiciel_Arduino

Étape 2

Ouvrez l’application Arduino et copiez-y le code fourni.

Réalisez ensuite le branchement en suivant le schéma fourni.

Étape 3

Vous pouvez modifier dans le code les différents paramètres définis par défaut afin d’ajuster les niveaux de décibels auxquels les LED s’activent.

Il est également possible d’adapter le programme à un panneau LED plus petit ou plus grand.

De la même manière, l’affichage ainsi que les couleurs déclenchées peuvent être personnalisés selon vos besoins.

Il est également possible de modifier la durée de la mise en veille des LED.

Notre histoire

Après avoir réfléchi à plusieurs idées, nous avons finalement choisi de concevoir un décibelmètre capable d’allumer différentes LED en fonction du niveau sonore capté par un micro.

Au départ, nous envisagions d’utiliser des LED polarisées. Cependant, après une demande au magasin des Petits Débrouillards, nous avons obtenu un panneau LED, ce qui s’est avéré plus adapté au rendu final. Notre objectif est notamment de créer un smiley, particulièrement pertinent pour une utilisation en salle de classe.

Lors du premier jour, nous avons rencontré un problème : deux membres du groupe ne parvenaient pas à suivre le tutoriel de téléchargement pour l’ESP32S. La cause était la lenteur et l’instabilité de la connexion internet du local, alors qu’une connexion rapide et stable est nécessaire pour cette étape.

Par ailleurs, lors de la connexion de la carte à l’ordinateur, le modèle indiqué dans le tutoriel ne correspondait pas à notre matériel. Dans notre cas, il s’agissait de la ESP32-WROOM-DA Module.

Pour créer nos schémas, nous souhaitions initialement utiliser Fritzing, mais celui-ci n’était plus utilisable gratuitement. Nous avons donc choisi d’utiliser LibreOffice Draw comme alternative.

Les branchements représentés sur le schéma fourni ont dû être refaits à plusieurs reprises, car lors des premiers essais, un membre du groupe avait effectué un mauvais branchement sur les pins correspondantes, ce qui nous a grandement retardé.

Enfin, nous avons rencontré des difficultés avec le branchement du panneau LED, qui ne fonctionnait sur aucun des appareils de l’équipe, ainsi qu’avec le téléversement du code sur l’ESP32S, qui générait une erreur.

Chez lui, Alexis a corrigé plusieurs problèmes liés à la connexion et a développé le code :

Il a réussi à téléverser le code en mettant la carte en mode téléchargement : pour ce faire, il a fallu débrancher puis rebrancher le câble reliant la carte à l’ordinateur. La fonction utilisée pour lire les informations du micro était bloquante, ce qui arrêtait le processeur. Par conséquent, le programme Watchdog Timer — qui définit le temps maximal pendant lequel le processeur peut rester inactif — forçait automatiquement le redémarrage de la carte. Il faut également faire attention aux broches utilisées, car de nombreuses petites erreurs provenaient de mauvais branchements.

Durant le temps restant, nous souhaitions améliorer le dispositif en ajoutant un support ainsi qu’un système de bouton permettant d’éteindre les LED. Nous avons modélisé le support, mais par manque de temps, nous n’avons pas pu l’imprimer ni tester le système de bouton. C’est pour cette raison que ces éléments n’ont pas été partagés sur ce wiki. Nous avons néanmoins mis en place un système de mise en veille : lorsque le niveau sonore reste identique pendant une minute, le dispositif se met en veille et se réactive automatiquement dès que le son ambiant change.

Sources et documentation complémentaire

Bus I2S pour le micro : https://docs.espressif.com/projects/arduino-esp32/en/latest/api/i2s.html

Bibliothèque pour gérer les LED : https://github.com/adafruit/Adafruit_NeoPixel

Documentation technique du micro : https://docs.cirkitdesigner.com/component/ad344a2a-950b-4700-8fb3-8d6f269dcf55/inmp441

Élément de présentation