Les Fabriques du Ponant - Contributions de l’utilisateur [fr]

ENIB 2026 : Enibel

2026-01-20T15:28:41Z

Mama : /* Élément de présentation */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 75; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro -> Ne pas toucher
unsigned long lastAudioRead = 0;
float dB_cached = 0;

/// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 40;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes -> 30 000 ms
const unsigned long TEMPS_EXTINCTION = 60000; // 1 minute -> 60 000 ms

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

/*~~~~~~~~~~Setup~~~~~~~~~~*/

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(10);
setupI2S();
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 500 ms ---
if (millis() - lastAudioRead > 500) {
dB_cached = readDecibels();
lastAudioRead = millis();
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red; // A modifier pour changer la couleur
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow; // A modifier pour changer la couleur
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green; // A modifier pour changer la couleur
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

'''Pour que ce dispositif fonctionne correctement, il doit être alimenté soit via l’ordinateur, soit sur secteur, mais pas sur batterie.'''

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, uniquement nos test dans la section ci-dessous. 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

Fichier STL du support test : https://wiki.lesfabriquesduponant.net/images/b/b1/Enibel_Piece_STL.stl

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

Deuxième présentation : https://wiki.lesfabriquesduponant.net/images/1/1d/POCL_ENIBEL.pdf

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

Fichier:POCL ENIBEL.pdf

2026-01-20T15:28:08Z

Mama :

ENIB 2026 : Enibel

2026-01-20T14:54:55Z

Mama : /* Code Arduino */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 75; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro -> Ne pas toucher
unsigned long lastAudioRead = 0;
float dB_cached = 0;

/// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 40;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes -> 30 000 ms
const unsigned long TEMPS_EXTINCTION = 60000; // 1 minute -> 60 000 ms

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

/*~~~~~~~~~~Setup~~~~~~~~~~*/

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(10);
setupI2S();
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 500 ms ---
if (millis() - lastAudioRead > 500) {
dB_cached = readDecibels();
lastAudioRead = millis();
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red; // A modifier pour changer la couleur
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow; // A modifier pour changer la couleur
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green; // A modifier pour changer la couleur
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

'''Pour que ce dispositif fonctionne correctement, il doit être alimenté soit via l’ordinateur, soit sur secteur, mais pas sur batterie.'''

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, uniquement nos test dans la section ci-dessous. 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

Fichier STL du support test : https://wiki.lesfabriquesduponant.net/images/b/b1/Enibel_Piece_STL.stl

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:52:30Z

Mama : /* Code Arduino */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 75; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro -> Ne pas toucher
unsigned long lastAudioRead = 0;
float dB_cached = 0;

/// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 40;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes -> 30 000 ms
const unsigned long TEMPS_EXTINCTION = 60000; // 1 minute -> 60 000 ms

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

/*~~~~~~~~~~Setup~~~~~~~~~~*/

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(10);
setupI2S();
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 500 ms ---
if (millis() - lastAudioRead > 500) {
dB_cached = readDecibels();
lastAudioRead = millis();
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

'''Pour que ce dispositif fonctionne correctement, il doit être alimenté soit via l’ordinateur, soit sur secteur, mais pas sur batterie.'''

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, uniquement nos test dans la section ci-dessous. 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

Fichier STL du support test : https://wiki.lesfabriquesduponant.net/images/b/b1/Enibel_Piece_STL.stl

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:51:33Z

Mama : /* Code Arduino */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 75; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro -> Ne pas toucher
unsigned long lastAudioRead = 0;
float dB_cached = 0;

/// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 40;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes -> 30 000 ms
const unsigned long TEMPS_EXTINCTION = 60000; // 1 minute -> 60 000 ms

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

/*~~~~~~~~~~Setup~~~~~~~~~~*/

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(10);
setupI2S();
//Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 500 ms ---
if (millis() - lastAudioRead > 500) {
dB_cached = readDecibels();
lastAudioRead = millis();
//Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

'''Pour que ce dispositif fonctionne correctement, il doit être alimenté soit via l’ordinateur, soit sur secteur, mais pas sur batterie.'''

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, uniquement nos test dans la section ci-dessous. 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

Fichier STL du support test : https://wiki.lesfabriquesduponant.net/images/b/b1/Enibel_Piece_STL.stl

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:49:06Z

Mama : /* Code Arduino */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 75; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro -> Ne pas toucher
unsigned long lastAudioRead = 0;
float dB_cached = 0;

/// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 40;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes -> 30 000 ms
const unsigned long TEMPS_EXTINCTION = 60000; // 1 minute -> 60 000 ms

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

/*~~~~~~~~~~Setup~~~~~~~~~~*/

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(10);
setupI2S();
//Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 500 ms ---
if (millis() - lastAudioRead > 500) {
dB_cached = readDecibels();
lastAudioRead = millis();
//Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

'''Pour que ce dispositif fonctionne correctement, il doit être alimenté soit via l’ordinateur, soit sur secteur, mais pas sur batterie.'''

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, uniquement nos test dans la section ci-dessous. 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

Fichier STL du support test : https://wiki.lesfabriquesduponant.net/images/b/b1/Enibel_Piece_STL.stl

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:47:24Z

Mama : /* Code Arduino */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration
///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds
///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes
///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine
///Seuils son
const int seuil_orange = 75; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;
///Variable micro -> Ne pas toucher
unsigned long lastAudioRead = 0;
float dB_cached = 0;
/// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 40;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes -> 30 000 ms
const unsigned long TEMPS_EXTINCTION = 60000; // 1 minute -> 60 000 ms

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;
///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};
const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};
const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011001111001101, // Yeux
0b1011001111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

/*~~~~~~~~~~Setup~~~~~~~~~~*/
void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(10);
setupI2S();
//Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 500 ms ---
if (millis() - lastAudioRead > 500) {
dB_cached = readDecibels();
lastAudioRead = millis();
//Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

'''Pour que ce dispositif fonctionne correctement, il doit être alimenté soit via l’ordinateur, soit sur secteur, mais pas sur batterie.'''

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, uniquement nos test dans la section ci-dessous. 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

Fichier STL du support test : https://wiki.lesfabriquesduponant.net/images/b/b1/Enibel_Piece_STL.stl

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:44:16Z

Mama : /* Sources et documentation complémentaire */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

'''Pour que ce dispositif fonctionne correctement, il doit être alimenté soit via l’ordinateur, soit sur secteur, mais pas sur batterie.'''

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, uniquement nos test dans la section ci-dessous. 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

Fichier STL du support test : https://wiki.lesfabriquesduponant.net/images/b/b1/Enibel_Piece_STL.stl

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:43:51Z

Mama : /* Sources et documentation complémentaire */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

'''Pour que ce dispositif fonctionne correctement, il doit être alimenté soit via l’ordinateur, soit sur secteur, mais pas sur batterie.'''

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, uniquement nos test dans la section ci-dessous. 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

Fichier STL du support test : Fichier:Enibel Piece STL.stl

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

Fichier:Enibel Piece STL.stl

2026-01-20T14:43:15Z

Mama :

ENIB 2026 : Enibel

2026-01-20T14:40:54Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

'''Pour que ce dispositif fonctionne correctement, il doit être alimenté soit via l’ordinateur, soit sur secteur, mais pas sur batterie.'''

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, uniquement nos test dans la section ci-dessous. 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

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:36:45Z

Mama : /* Outils et matériel */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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, uniquement nos test dans la section ci-dessous. 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

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:36:20Z

Mama :

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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
* 5 inserts
* 5 vis M3

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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, uniquement nos test dans la section ci-dessous. 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

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:33:41Z

Mama : /* Étape 4 */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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
* 5 inserts
* 5 vis M3

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

===Étape 4 (non finie donc facultative)===

Pour cette étape, nous n'avons pas eu le temps de la parfaire.

Téléchargez le fichier stl fournis pour imprimer le support. Une fois l'impression finie, ajoutez

==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

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:27:38Z

Mama : /* Équipe */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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
* 5 inserts
* 5 vis M3

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

===Étape 4===

'''Impression 3D'''

==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

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:27:22Z

Mama : /* Équipe */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

Devant : Alexis et Maël

Derriere : Arthur, Léïa et Mael

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

[[Fichier:Logo-enib.png|200px]]

==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
* 5 inserts
* 5 vis M3

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

===Étape 4===

'''Impression 3D'''

==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

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:26:23Z

Mama : /* Équipe */

==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 :

[[Fichier:Equipe Enibel.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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
* 5 inserts
* 5 vis M3

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

===Étape 4===

'''Impression 3D'''

==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

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

Fichier:Equipe Enibel.jpg

2026-01-20T14:24:50Z

Mama :

ENIB 2026 : Enibel

2026-01-20T14:06:57Z

Mama :

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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
* 5 inserts
* 5 vis M3

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

===Étape 4===

'''Impression 3D'''

==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

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T14:04:31Z

Mama : /* Sources et documentation complémentaire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

===Étape 4===

'''Impression 3D'''

==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

Voici le prompt que nous avons utilisé pour nous guider dans l’implémentation du code et des branchements :

"Pour ce projet, nous utilisons un microphone INMP441 associé à un NodeMCU-32S afin de mesurer la puissance sonore en décibels. Nous souhaitons également connaître les branchements à réaliser ainsi que le code à implémenter dans l’Arduino IDE pour effectuer cette tâche."

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:52:42Z

Mama : /* Étape 3 */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

===Étape 4===

'''Impression 3D'''

==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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:52:17Z

Mama : /* Étapes de fabrication */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

===Étape 3===

==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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:49:07Z

Mama : /* Équipe */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:48:15Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:45:23Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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.

X

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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:44:37Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 microphone é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.

X

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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:37:55Z

Mama : /* Sources et documentation complémentaire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:36:20Z

Mama : /* Sources et documentation complémentaire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:34:49Z

Mama : /* Étape 3 */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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==

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:33:17Z

Mama : /* Étape 1 */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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==

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:32:13Z

Mama : /* Outils et matériel */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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==

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:32:01Z

Mama : /* Outils et matériel */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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

==Fichiers à joindre==

===Code Arduino===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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==

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:30:34Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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==

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T13:26:07Z

Mama : /* Code Arduino */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line>//Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///LED
#define W2812_PIN 27 //Broche du Din du panneau LED
#define WS2812_PIXELS_NUM 256 // Nombres de LED

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

// Luminosité dynamique
uint8_t luminositeActuelle = 5;
const uint8_t LUMINOSITE_FORTE = 80;
const uint8_t LUMINOSITE_FAIBLE = 5;
const unsigned long TEMPS_ATTENUATION = 30000; // 30 secondes
const unsigned long TEMPS_EXTINCTION = 60000;

unsigned long dernierChangementCouleur = 0;
uint32_t couleurActuelle = 0;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {
uint32_t nouvelleCouleur;
const uint16_t* nouveauDessin;

// --- Lecture audio toutes les 200 ms ---
if (millis() - lastAudioRead > 200) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}
// Choix du dessin et de la couleur
if (dB_cached >= seuil_rouge) {
nouveauDessin = faceSad;
nouvelleCouleur = red;
}
else if (dB_cached >= seuil_orange) {
nouveauDessin = faceNeutral;
nouvelleCouleur = yellow;
}
else {
nouveauDessin = faceHappy;
nouvelleCouleur = green;
}

// Détection de changement de couleur
if (nouvelleCouleur != couleurActuelle) {
couleurActuelle = nouvelleCouleur;
luminositeActuelle = LUMINOSITE_FORTE;
ledStrip.setBrightness(luminositeActuelle);
dernierChangementCouleur = millis();
}

// Atténuation après 30 secondes
if (millis() - dernierChangementCouleur > TEMPS_ATTENUATION) {
if (luminositeActuelle != LUMINOSITE_FAIBLE) {
luminositeActuelle = LUMINOSITE_FAIBLE;
ledStrip.setBrightness(luminositeActuelle);
}
}
if (millis() - dernierChangementCouleur > TEMPS_EXTINCTION){
//Eteindre Après 1 minutes
ledStrip.setBrightness(0);
}

// Affichage
afficherDessin(nouveauDessin, couleurActuelle);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
/*if (couleur == green){
ledStrip.setBrightness(5);
}
else if (couleur == red){
ledStrip.setBrightness(200);
}
else{
ledStrip.setBrightness(50);
}*/
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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.

==Sources et documentation complémentaire==

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T11:25:22Z

Mama :

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///Led
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de led

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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.

==Sources et documentation complémentaire==

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T11:24:24Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

'''XXX'''

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.

==Sources et documentation complémentaire==

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T11:20:27Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 :

==Sources et documentation complémentaire==

==Élément de présentation==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T11:09:24Z

Mama : /* Sources et documentation complémentaire */

ENIB 2026 : Enibel

2026-01-20T11:07:01Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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.

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.

rstx0x8 (TG1WDT_SYS_RESET)

==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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T11:03:57Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 eu durant le premier jour est que deux personnes du groupe ne pouvait pas suivre le tuto de téléchargement pour l'ESP32S. La solution à ce problème était la lenteur de la connexion du local, il fallait une connexion assez rapide et surtout stable.

Lorsque nous avons voulu connecter la carte à notre ordinateur, la carte indiquée par le tuto n'était pas la bonne. Dans notre cas, c'était la : ESP32-WROOM-DA Module

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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T11:03:41Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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 eu durant le premier jour est que deux personnes du groupe ne pouvait pas suivre le tuto de téléchargement pour l'ESP32S. La solution à ce problème était la lenteur de la connexion du local, il fallait une connexion assez rapide et surtout stable.

Lorsque nous avons voulu connecter la carte à notre ordinateur, la carte indiquée par le tuto n'était pas la bonne. Dans notre cas, c'était la "ESP32-WROOM-DA Module"

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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T10:57:44Z

Mama : /* Notre histoire */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T10:46:18Z

Mama : /* Code Arduino */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration

///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds

///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes

///Luminosité
const int luminosite = 10;

///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine

///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;

///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;

///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T10:41:48Z

Mama : /* Élément de présentation */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration
///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds
///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes
///Luminosité
const int luminosite = 10;
///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine
///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;
///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;
///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};
const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};
const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}

</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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==

[[Fichier:ENIBEL Presentation.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

Fichier:ENIBEL Presentation.jpg

2026-01-20T10:41:29Z

Mama :

ENIB 2026 : Enibel

2026-01-20T10:38:58Z

Mama : /* Étapes de fabrication */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration
///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds
///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes
///Luminosité
const int luminosite = 10;
///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine
///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;
///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;
///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};
const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};
const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}

</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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.

==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==

[[Fichier:ENIBEL.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T10:37:53Z

Mama : /* Étapes de fabrication */

==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 :

[[Fichier:Enib.jpg|450px]]

À 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

[[Fichier:Logo-enib.png|200px]]

==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===

<syntaxhighlight lang="Arduino" line> //Librairie
#include <Adafruit_NeoPixel.h>
#include <driver/i2s.h>

//Configuration
///Leds
#define W2812_PIN 27 //Broche du Din du panneau led
#define WS2812_PIXELS_NUM 256 // Nombres de leds
///Micro
#define I2S_WS 25 //GPIO 25
#define I2S_SD 32 //GPIO 32
#define I2S_SCK 33 //GPIO 33

//Matrice
Adafruit_NeoPixel ledStrip(WS2812_PIXELS_NUM, W2812_PIN, NEO_GRB + NEO_KHZ800);
// 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

//Variable systèmes
///Luminosité
const int luminosite = 10;
///Couleurs codées en (red, green, blue)
uint32_t white = ledStrip.Color(255, 255, 255); // Blanc
uint32_t green = ledStrip.Color(0, 255, 0); // Vert
uint32_t red = ledStrip.Color(255, 0, 0); // Rouge
uint32_t yellow = ledStrip.Color(255, 255, 0); // Jaune
uint32_t marine_blue = ledStrip.Color(46, 62, 115); // Bleu marine
///Seuils son
const int seuil_orange = 70; //dB -> Jaune
const int seuil_rouge = 90; //dB -> Rouge
const int GAIN_CALIBRATION = 20;
///Variable micro
unsigned long lastAudioRead = 0;
float dB_cached = 0;
///Dessins
// On utilise uint16_t car il y a 16 bits (pixels) par ligne
const uint16_t faceHappy[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011011111101101, // Début sourire
0b1011101111011101,
0b1101110000111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};
const uint16_t faceNeutral[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011111111111101,
0b1011000000001101, // Bouche droite
0b1101111111111011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};
const uint16_t faceSad[16] = {
0b1111111111111111,
0b1111100000011111,
0b1111011111101111,
0b1110111111110111,
0b1101111111111011,
0b1011100111001101, // Yeux
0b1011100111001101, // Yeux
0b1011111111111101,
0b1011111111111101,
0b1011110000111101, // Bouche triste
0b1011101111011101,
0b1101011111101011,
0b1110111111110111,
0b1111011111101111,
0b1111100000011111,
0b1111111111111111
};

int i;

void setup() {
// put your setup code here, to run once:
Serial.begin(115200);
ledStrip.begin();
ledStrip.setBrightness(luminosite);
setupI2S();
Serial.println("BOOT OK");
}

void loop() {

// --- Lecture audio toutes les 100 ms ---
if (millis() - lastAudioRead > 100) {
dB_cached = readDecibels();
lastAudioRead = millis();
Serial.println(dB_cached);
}

// --- Affichage ---
if (dB_cached >= seuil_rouge) {
afficherDessin(faceSad, red);
}
else if (dB_cached >= seuil_orange) {
afficherDessin(faceNeutral, yellow);
}
else {
afficherDessin(faceHappy, green);
}

delay(10); // laisse respirer FreeRTOS
yield(); // nourrit le watchdog
Serial.println("RUNNING");
delay(1000);
}

//Fonction d'affichage en 16x16
void afficherDessin(const uint16_t dessin[], uint32_t couleur){
ledStrip.clear();
for (int y = 0; y<16; y++){
for (int x = 0; x<16; x++){
//On verif le bit x dans la ligne y ( en partant de la gauche)
if ((dessin[y]>>(15-x)) & 0x01){
int index;
// Logique serpentin pour largueur 16
if (y%2 ==0){
index = (y * 16) + x;
}else{
index = (y*16) + (15 - x);
}
ledStrip.setPixelColor(index, couleur);
}
}
}
ledStrip.show();
}

//Fonction MICRO (I2S)
void setupI2S() {
const i2s_config_t i2s_config = {
.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX),
.sample_rate = 44100,
.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT,
.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT,
.communication_format = (i2s_comm_format_t)(I2S_COMM_FORMAT_I2S | I2S_COMM_FORMAT_I2S_MSB),
.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
.dma_buf_count = 8,
.dma_buf_len = 64
};
i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL);
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};
i2s_set_pin(I2S_NUM_0, &pins);
i2s_zero_dma_buffer(I2S_NUM_0);
delay(10);
}

float readDecibels() {
static int32_t samples[128];
size_t bytesRead = 0;

esp_err_t result = i2s_read(
I2S_NUM_0,
samples,
sizeof(samples),
&bytesRead,
20 / portTICK_PERIOD_MS
);

if (result != ESP_OK || bytesRead < 16) {
return dB_cached; // garde l’ancienne valeur
}

long long sum = 0;
int count = bytesRead / 4;

for (int i = 0; i < count; i++) {
int32_t val = samples[i] >> 14;
sum += (int64_t)val * val;
}

float rms = sqrt((float)sum / count);
if (rms <= 0) return dB_cached;

return 20.0 * log10(rms) + GAIN_CALIBRATION;
}

</syntaxhighlight>

===Schéma de branchement===

[[Fichier:ENIBEL Schema.jpg|800px]]

==É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 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==

[[Fichier:ENIBEL.jpg|800px]]

==Ne pas modifier sous cette ligne==

[[Catégorie:Enib2026]]

ENIB 2026 : Enibel

2026-01-20T10:35:39Z

Mama : /* Code Arduino */

ENIB 2026 : Enibel

2026-01-20T10:35:06Z

Mama : /* Fichiers à joindre */

ENIB 2026 : Enibel

2026-01-20T10:35:00Z

Mama : /* Code Arduino */