LED réactive à la musique Arduino : VU-mètre WS2812B
LED réactive à la musique : VU-mètre sur anneau WS2812B avec Arduino Uno + KY-038 ou ESP32 + INMP441. Câblage, code prêt à l'emploi, seuil et filtre de bruit.
Un projet de LED réactive à la musique avec Arduino écoute le son ambiant avec un micro et allume d'autant plus de LED que le son est fort, comme le VU-mètre des anciennes chaînes hi-fi. Dans ce guide, tu vas utiliser un anneau WS2812B de 24 LED (le même code marche sur un ruban) pour construire deux versions : une version économique et rapide avec Arduino Uno et un capteur de son KY-038, et une version bien plus propre avec ESP32 et un micro numérique I2S INMP441.
Le vrai défi du projet n'est pas d'allumer des LED, mais de bien mesurer le son. Le signal du micro est une onde qui change de sens des milliers de fois par seconde ; une seule valeur d'analogRead ne te dit rien. Tu vas donc apprendre pas à pas à mesurer l'amplitude sur une fenêtre de temps, à trouver automatiquement le bruit de fond en silence, à régler la sensibilité avec un potentiomètre et à lisser le signal pour supprimer le scintillement.

Comment fonctionne une LED réactive à la musique ?
La chaîne comporte quatre étapes : le micro convertit le son en signal électrique, le microcontrôleur échantillonne ce signal, un niveau sonore unique est calculé à partir des échantillons, puis ce nombre est converti en nombre de LED à allumer. Il y a deux méthodes courantes pour calculer ce niveau. Avec la méthode crête à crête (peak-to-peak), on prend la différence entre la plus grande et la plus petite valeur sur une courte durée ; c'est simple et suffisant pour l'Uno. Avec la méthode RMS, on calcule la racine carrée de la moyenne des carrés des échantillons, ce qui donne l'énergie réelle du son. Comme l'oreille humaine perçoit le son de façon logarithmique, convertir la valeur RMS en décibels (dB = 20 × log10(RMS)) donne un mouvement de VU-mètre bien plus naturel. On l'utilisera dans la version ESP32.
| Caractéristique | Uno + KY-038 | ESP32 + INMP441 |
|---|---|---|
| Type de micro | Électret analogique, sans amplificateur | MEMS numérique, sortie I2S |
| Résolution | CAN 10 bits (pas de 4,9 mV) | Données 24 bits |
| Échantillonnage | Environ 8,9 kHz (analogRead ~112 µs) | 16 kHz, en continu par DMA |
| Calcul du niveau | Crête à crête | RMS + décibels |
| Sensibilité | Faible, réagit aux sons forts et proches | Élevée, capte facilement la musique d'ambiance |
| Bruit | Sensible au bruit d'alimentation | Très faible, liaison numérique |
| Difficulté | Débutant | Intermédiaire |
Matériel nécessaire
- Microcontrôleur : Arduino Uno (ou Nano) ou carte de développement ESP32.
- Micro : module capteur de son KY-038 pour l'Uno, module micro I2S INMP441 pour l'ESP32.
- LED : anneau WS2812B de 24 LED ou ruban WS2812B de 30 à 60 LED.
- Résistance de 330 Ω : en série sur la ligne de données des LED, elle évite les réflexions du signal et protège la première LED.
- Condensateur 1000 µF / 10 V : entre le 5V et la GND de l'alimentation des LED, il lisse les appels de courant brusques.
- Potentiomètre 10 kΩ : pour régler la sensibilité (pleine échelle) dans la version Uno.
- Alimentation 5 V 2 A : indispensable si tu utilises plus de 24 LED ou si tu montes la luminosité.
- Breadboard et fils de connexion.

Câblage Uno + KY-038
| Composant / broche | Arduino Uno | Remarque |
|---|---|---|
| KY-038 + | 5V | Alimentation du module |
| KY-038 G | GND | Masse commune |
| KY-038 AO | A0 | Signal sonore analogique |
| KY-038 DO | Non connectée | Inutile pour le VU-mètre |
| Potentiomètre, borne centrale | A1 | Bornes extérieures au 5V et à la GND |
| WS2812B DIN | D6 (via 330 Ω) | Côté entrée (DI) de l'anneau |
| WS2812B 5V | 5V ou 5 V externe | Condensateur 1000 µF entre 5V et GND |
| WS2812B GND | GND | Doit être commune avec l'alimentation externe |
Mesurer l'amplitude du son : la méthode crête à crête
La sortie AO du KY-038 est un signal qui reste stable autour de 2,5 V en silence et oscille au-dessus et en dessous de cette valeur quand le son arrive. Sur l'Uno, analogRead lit ce point central autour de 500. Une seule lecture donne une valeur aléatoire selon le moment de l'onde. On lit donc pendant une fenêtre de 25 millisecondes en mémorisant les valeurs maximale et minimale. Comme un analogRead dure environ 112 microsecondes sur l'Uno, on obtient environ 220 échantillons en 25 ms, ce qui suffit pour capter au moins quelques ondes complètes des basses et des médiums. À la fin de la fenêtre, maximum moins minimum donne le niveau sonore du moment. Le KY-038 n'ayant pas d'amplificateur, cette différence est de 2 à 5 dans une pièce silencieuse, et de 50 à 200 avec de la musique forte à proximité.
Version Uno pas à pas
- Dans l'IDE Arduino, ouvre le Gestionnaire de bibliothèques, cherche Adafruit NeoPixel et installe-la.
- Monte le circuit d'après le tableau ci-dessus ; relie la longue patte (+) du condensateur au 5V.
- Téléverse le code ci-dessous et garde la pièce silencieuse pendant la première demi-seconde : le code mesure le bruit de fond à ce moment-là.
- Ouvre le moniteur série à 115200 bauds et regarde la valeur du bruit de fond affichée ; au-dessus de 10, il y a du bruit d'alimentation.
- Lance de la musique et tourne le potentiomètre pour trouver le point où l'anneau est presque entièrement allumé au volume maximal.
- Place le micro à 20–50 cm de l'enceinte, loin de la lumière des LED et des vibrations de la table.
1#include <Adafruit_NeoPixel.h>
2
3#define LED_PIN 6 // WS2812B DIN / WS2812B DIN
4#define NUM_LEDS 24 // halkadaki LED sayısı / number of LEDs in the ring
5#define MIC_PIN A0 // KY-038 AO / KY-038 AO
6#define POT_PIN A1 // hassasiyet potu / sensitivity pot
7#define WINDOW_MS 25 // ölçüm penceresi (ms) / measurement window (ms)
8
9Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
10
11int noiseFloor = 0; // sessizlikteki genlik / amplitude in silence
12float level = 0; // yumuşatılmış seviye / smoothed level
13int peakLed = 0; // tepe noktası / peak dot
14unsigned long peakTime = 0;
15
16int readPeakToPeak() {
17 int minV = 1023;
18 int maxV = 0;
19 unsigned long start = millis();
20 while (millis() - start < WINDOW_MS) {
21 int v = analogRead(MIC_PIN);
22 if (v < minV) minV = v;
23 if (v > maxV) maxV = v;
24 }
25 return maxV - minV; // tepeden tepeye genlik / peak-to-peak amplitude
26}
27
28uint32_t vuColor(int i) {
29 uint16_t hue = 21845 - (uint32_t)i * 21845 / (NUM_LEDS - 1); // yeşil -> kırmızı / green -> red
30 return strip.gamma32(strip.ColorHSV(hue, 255, 255));
31}
32
33void setup() {
34 Serial.begin(115200);
35 strip.begin();
36 strip.setBrightness(60); // akımı sınırla / limit current
37 strip.show();
38 delay(500);
39 long sum = 0;
40 for (int i = 0; i < 20; i++) sum += readPeakToPeak(); // sessiz ortamda kalibrasyon / calibrate in silence
41 noiseFloor = sum / 20 + 2; // küçük güvenlik payı / small safety margin
42 Serial.print(F("Gurultu tabani / Noise floor: "));
43 Serial.println(noiseFloor);
44}
45
46void loop() {
47 int maxPP = map(analogRead(POT_PIN), 0, 1023, 10, 300); // tam ölçek / full scale
48 int pp = readPeakToPeak() - noiseFloor;
49 if (pp < 0) pp = 0;
50 if (pp > maxPP) pp = maxPP;
51 float target = (float)pp * NUM_LEDS / maxPP;
52
53 if (target > level) level = 0.6 * target + 0.4 * level; // hızlı yüksel / fast attack
54 else level = 0.15 * target + 0.85 * level; // yavaş düş / slow release
55 int lit = (int)(level + 0.5);
56
57 if (lit >= peakLed) {
58 peakLed = lit;
59 peakTime = millis();
60 } else if (millis() - peakTime > 400 && peakLed > 0) { // 400 ms bekle, sonra düş / hold 400 ms, then fall
61 peakLed--;
62 peakTime = millis() - 340; // sonraki adım 60 ms sonra / next step in 60 ms
63 }
64
65 strip.clear();
66 for (int i = 0; i < lit; i++) strip.setPixelColor(i, vuColor(i));
67 if (peakLed > 0) strip.setPixelColor(peakLed - 1, strip.Color(255, 255, 255));
68 strip.show();
69}| Partie du code | Rôle |
|---|---|
| readPeakToPeak() | Échantillonne pendant 25 ms et renvoie la différence entre la plus grande et la plus petite valeur |
| noiseFloor | Moyenne des 20 mesures au démarrage + 2 ; en dessous, c'est du silence |
| maxPP | Pleine échelle réglée de 10 à 300 avec le potentiomètre ; petite valeur = forte sensibilité |
| level | Niveau lissé, montée rapide et descente lente (évite le scintillement) |
| peakLed | Point blanc de crête ; il attend 400 ms, puis descend d'une LED toutes les 60 ms |
| vuColor() | Produit un dégradé du vert au jaune puis au rouge selon la position de la LED |
Réglage du seuil et filtrage du bruit
Si tu envoies le niveau sonore brut directement aux LED, tu rencontres deux problèmes. Le premier : même dans le silence, les premières LED clignotent en permanence, car le micro, les fils et l'alimentation USB produisent toujours un peu de bruit. La solution consiste à mesurer ce bruit et à le soustraire de chaque lecture. Notre code mesure le silence pendant une demi-seconde au démarrage et ajoute une marge de 2 unités à la moyenne. Cette valeur agit comme un seuil : tout ce qui est en dessous est considéré comme zéro. Dans un environnement bruyant, tu peux monter cette marge à 4–5. Le second réglage est la pleine échelle : elle détermine quelle amplitude remplit tout l'anneau. Comme le volume de la musique varie d'un endroit à l'autre, nous l'avons reliée à un potentiomètre au lieu de l'écrire en dur dans le code.
Le second problème est le scintillement : les fenêtres de 25 ms étant très courtes, le niveau saute brusquement d'une mesure à l'autre. On le règle avec une moyenne mobile exponentielle (EMA) : nouveau niveau = a × cible + (1 − a) × ancien niveau. Quand le son monte, on utilise a = 0,6, donc les LED captent les coups de batterie instantanément ; quand il descend, a = 0,15 et les LED retombent lentement, comme une vraie aiguille. En ingénierie du son, on parle d'attack et de release. Comme la boucle dure environ 26 ms, avec un coefficient de release de 0,15 le niveau baisse de 90 % en environ 15 boucles, soit 0,4 seconde. Tu peux comparer d'autres types de filtres dans l'article filtrage des données de capteur.
Version ESP32 + INMP441 : une mesure propre avec un micro numérique
L'INMP441 est un micro MEMS qui convertit le son en numérique en 24 bits et envoie les données par le protocole I2S. Sans fil analogique, le bruit d'alimentation ne se mêle pas à la mesure, et le rapport signal/bruit est d'environ 61 dB. L'ESP32 collecte les données I2S en arrière-plan par DMA sans solliciter le processeur ; on prend des blocs de 512 échantillons et on calcule la valeur RMS. À 16 kHz, un bloc dure 32 ms, donc le VU-mètre se met à jour environ 30 fois par seconde. Tu trouveras le fonctionnement du micro en détail dans l'article micro I2S INMP441.
| Composant / broche | ESP32 | Remarque |
|---|---|---|
| INMP441 VDD | 3V3 | N'applique pas 5 V, le micro fonctionne en 3,3 V |
| INMP441 GND | GND | Masse commune |
| INMP441 L/R | GND | Sélectionne le canal gauche |
| INMP441 WS | GPIO 25 | Sélection de mot (LRCLK) |
| INMP441 SCK | GPIO 32 | Horloge de bit (BCLK) |
| INMP441 SD | GPIO 33 | Données audio |
| WS2812B DIN | GPIO 18 (via 330 Ω) | Le signal 3,3 V fonctionne avec un fil court |
| WS2812B 5V | VIN (USB 5 V) ou 5 V externe | Ajoute un condensateur 1000 µF |
| WS2812B GND | GND | Commune avec l'alimentation externe |
1#include <Arduino.h>
2#include <Adafruit_NeoPixel.h>
3#include <math.h>
4
5#if ESP_ARDUINO_VERSION_MAJOR >= 3
6 #include <ESP_I2S.h> // core 3.x yeni I2S sürücüsü / core 3.x new I2S driver
7 I2SClass i2s;
8#else
9 #include <driver/i2s.h> // core 2.x eski I2S sürücüsü / core 2.x legacy I2S driver
10 #include <esp_idf_version.h>
11#endif
12
13#define I2S_SCK 32
14#define I2S_WS 25
15#define I2S_SD 33
16#define LED_PIN 18
17#define NUM_LEDS 24
18#define SAMPLE_RATE 16000
19#define BLOCK 512 // 512 örnek = 32 ms / 512 samples = 32 ms
20
21const float RANGE_DB = 35.0; // halkanın kapsadığı dB aralığı / dB range of the ring
22
23Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
24int32_t samples[BLOCK];
25float noiseDb = 0;
26float level = 0;
27int peakLed = 0;
28unsigned long peakTime = 0;
29
30void micBegin() {
31#if ESP_ARDUINO_VERSION_MAJOR >= 3
32 i2s.setPins(I2S_SCK, I2S_WS, -1, I2S_SD);
33 if (!i2s.begin(I2S_MODE_STD, SAMPLE_RATE, I2S_DATA_BIT_WIDTH_32BIT, I2S_SLOT_MODE_MONO, I2S_STD_SLOT_LEFT)) {
34 Serial.println("I2S baslatilamadi / I2S init failed");
35 while (true) delay(1000);
36 }
37#else
38 i2s_config_t cfg = {};
39 cfg.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX);
40 cfg.sample_rate = SAMPLE_RATE;
41 cfg.bits_per_sample = I2S_BITS_PER_SAMPLE_32BIT;
42 cfg.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT;
43 cfg.communication_format = I2S_COMM_FORMAT_STAND_I2S;
44 cfg.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1;
45 cfg.dma_buf_count = 4;
46 cfg.dma_buf_len = 256;
47 cfg.use_apll = false;
48
49 i2s_pin_config_t pins = {};
50#if ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(4, 4, 0)
51 pins.mck_io_num = I2S_PIN_NO_CHANGE;
52#endif
53 pins.bck_io_num = I2S_SCK;
54 pins.ws_io_num = I2S_WS;
55 pins.data_out_num = I2S_PIN_NO_CHANGE;
56 pins.data_in_num = I2S_SD;
57
58 i2s_driver_install(I2S_NUM_0, &cfg, 0, NULL);
59 i2s_set_pin(I2S_NUM_0, &pins);
60#endif
61}
62
63size_t micRead() {
64#if ESP_ARDUINO_VERSION_MAJOR >= 3
65 return i2s.readBytes((char *)samples, sizeof(samples)) / sizeof(int32_t);
66#else
67 size_t bytesRead = 0;
68 i2s_read(I2S_NUM_0, samples, sizeof(samples), &bytesRead, portMAX_DELAY);
69 return bytesRead / sizeof(int32_t);
70#endif
71}
72
73float readDb() {
74 size_t n = micRead();
75 if (n == 0) return 0;
76 double mean = 0;
77 for (size_t i = 0; i < n; i++) {
78 samples[i] >>= 8; // 24 bit veriyi hizala / align 24-bit data
79 mean += samples[i];
80 }
81 mean /= n; // DC kaymasını bul / find DC offset
82 double sum = 0;
83 for (size_t i = 0; i < n; i++) {
84 double d = samples[i] - mean;
85 sum += d * d;
86 }
87 double rms = sqrt(sum / n);
88 return 20.0 * log10(rms + 1.0); // desibel / decibels
89}
90
91uint32_t vuColor(int i) {
92 uint16_t hue = 21845 - (uint32_t)i * 21845 / (NUM_LEDS - 1); // yeşil -> kırmızı / green -> red
93 return strip.gamma32(strip.ColorHSV(hue, 255, 255));
94}
95
96void setup() {
97 Serial.begin(115200);
98 strip.begin();
99 strip.setBrightness(60);
100 strip.show();
101 micBegin();
102 for (int i = 0; i < 10; i++) readDb(); // açılış verisini at / discard startup data
103 float sum = 0;
104 for (int i = 0; i < 20; i++) sum += readDb(); // sessizlik kalibrasyonu / silence calibration
105 noiseDb = sum / 20 + 3.0; // 3 dB eşik payı / 3 dB threshold margin
106 Serial.printf("Gurultu tabani / Noise floor: %.1f dB\n", noiseDb);
107}
108
109void loop() {
110 float db = readDb();
111 float target = (db - noiseDb) / RANGE_DB * NUM_LEDS;
112 if (target < 0) target = 0;
113 if (target > NUM_LEDS) target = NUM_LEDS;
114
115 if (target > level) level = 0.6 * target + 0.4 * level; // hızlı yüksel / fast attack
116 else level = 0.15 * target + 0.85 * level; // yavaş düş / slow release
117 int lit = (int)(level + 0.5);
118
119 if (lit >= peakLed) {
120 peakLed = lit;
121 peakTime = millis();
122 } else if (millis() - peakTime > 400 && peakLed > 0) {
123 peakLed--;
124 peakTime = millis() - 340;
125 }
126
127 strip.clear();
128 for (int i = 0; i < lit; i++) strip.setPixelColor(i, vuColor(i));
129 if (peakLed > 0) strip.setPixelColor(peakLed - 1, strip.Color(255, 255, 255));
130 strip.show();
131}Le code choisit automatiquement la nouvelle bibliothèque ESP_I2S si tu utilises l'ESP32 Arduino core 3.x, ou l'ancien pilote driver/i2s.h avec le core 2.x. L'INMP441 place chaque échantillon dans les 24 bits de poids fort d'une trame de 32 bits ; un décalage de 8 bits vers la droite donne la vraie valeur. Ensuite, on soustrait la moyenne pour supprimer le petit décalage DC du micro, puis on calcule le RMS. Sur l'échelle des décibels, chaque tranche de 6 dB correspond à un doublement de l'amplitude. Avec RANGE_DB = 35, l'anneau est entièrement allumé à 35 dB au-dessus du bruit de fond. Si tu écoutes la musique doucement dans une pièce silencieuse, descends cette valeur à 25 ; dans une fête bruyante, monte-la à 45.
Si tu veux utiliser une Raspberry Pi Pico, la classe machine.I2S de MicroPython est aussi prise en charge sur le RP2040 ; tu peux brancher le même INMP441 avec les broches SCK, WS et SD et transposer la logique RMS en Python. MicroPython dispose aussi d'un module neopixel intégré pour le WS2812B. Pour bien démarrer avec la Pico, l'article Qu'est-ce que la Raspberry Pi Pico est un bon début.
Améliorer l'effet : idées de projets
- VU-mètre depuis le centre : crée un effet symétrique qui part des LED 0 et 12 de l'anneau et se remplit dans les deux sens.
- VU-mètre stéréo : relie la broche L/R d'un INMP441 à la GND et celle de l'autre à 3V3, puis affiche les canaux gauche et droit sur deux rubans séparés.
- Spectre sur matrice LED : avec une FFT sur l'ESP32, sépare le son en bandes de fréquences et dessine des barres d'égaliseur sur une matrice LED WS2812B.
- Lumière d'ambiance musicale : si tu veux une interface toute prête, transforme l'ESP32 en contrôleur de ruban réactif au son avec l'installation de WLED.
- Alerte de niveau sonore : fabrique un sonomètre pour la classe ou la bibliothèque qui allume l'anneau en rouge et fait sonner un buzzer quand le son dépasse un certain nombre de dB.
- Décoration de Noël : combine le projet avec un sapin de Noël à LED pour un arbre qui change de couleur en fonction de la musique.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Les LED scintillent en silence | Bruit de fond mesuré trop bas | Garde la pièce silencieuse au démarrage, passe la marge du seuil de 2 à 4–5 |
| Aucune réaction à la musique (Uno) | Signal du KY-038 trop faible | Baisse maxPP avec le potentiomètre, rapproche le micro de l'enceinte |
| L'anneau est toujours plein | Pleine échelle trop petite | Tourne le potentiomètre pour augmenter maxPP, ou augmente RANGE_DB |
| L'INMP441 lit toujours zéro | L/R en l'air ou canal inversé | Relie L/R à la GND ; sinon, passe-le à 3V3 et choisis le canal droit dans le code |
| La première LED a une mauvaise couleur | Signal de données faible ou pas de résistance | Ajoute une résistance série de 330 Ω, raccourcis le fil de données |
| La carte redémarre sur un coup de basse | Le courant des LED fait chuter l'alimentation | Baisse la luminosité, utilise une alimentation 5 V externe et un condensateur 1000 µF |
| Les LED déclenchent le micro | Les ondulations d'alimentation parasitent la ligne analogique | Relie le micro au 5V par un fil séparé, réunis les GND en un seul point |
Un projet de LED réactive à la musique réunit mesure de signal analogique, filtrage et contrôle de LED adressables dans un seul circuit amusant. Tu peux démarrer en quelques minutes avec l'Uno et le KY-038, puis passer à un véritable indicateur sonore avec l'ESP32 et l'INMP441. Dans l'application BlueGrays, tu trouveras pas à pas, avec schéma et code prêt à l'emploi, les projets WS2812B de chenillard, Knight Rider, gyrophare de police et animations, ainsi que le contrôle d'un ruban NeoPixel avec l'ESP32.
Questions fréquentes
Quel capteur de son choisir pour une LED réactive à la musique ?
Pour débuter avec un petit budget, le KY-038 fait l'affaire, mais comme il n'a pas d'amplificateur, il ne réagit bien qu'aux sons forts et proches. Pour un résultat plus sensible et sans bruit, utilise un micro numérique I2S comme l'INMP441 avec un ESP32, ou un module micro analogique avec amplificateur.
Pourquoi mon capteur de son KY-038 ne réagit pas à la musique ?
Le signal sur la sortie AO du KY-038 n'oscille généralement que de quelques unités du CAN, et le trimmer ne l'amplifie pas, il change seulement le seuil DO. Rapproche le micro de l'enceinte, baisse la pleine échelle dans le code et assure-toi de faire une mesure crête à crête plutôt qu'une lecture unique.
Comment allumer des LED WS2812B en fonction de la musique avec Arduino ?
Tu prélèves des échantillons du micro sur une courte fenêtre de temps, tu calcules le niveau sonore, puis tu le convertis en nombre de LED avec une règle de proportionnalité de type map. Ensuite, avec la bibliothèque Adafruit NeoPixel, tu allumes ce nombre de LED et tu mets à jour avec strip.show() ; un filtre de lissage évite que l'effet ne scintille.
Le micro INMP441 fonctionne-t-il avec un Arduino Uno ?
Non, l'Arduino Uno n'a pas de matériel I2S et ne peut donc pas lire les données de l'INMP441. Il te faut une carte compatible I2S comme l'ESP32, l'ESP32-S3 ou la Raspberry Pi Pico ; pour l'Uno, les modules micro à sortie analogique conviennent.
Quel courant consomme un anneau WS2812B de 24 LED ?
Chaque LED consomme environ 60 mA en blanc pur, donc 24 LED tirent 1,44 A dans le pire des cas. Dans un VU-mètre, toutes les LED sont rarement à pleine luminosité, donc la consommation réelle est bien plus faible ; limiter la luminosité et utiliser une alimentation 5 V externe reste le plus sûr.
Est-il possible de changer la couleur des LED selon la fréquence ?
Oui, il faut pour cela séparer le son en bandes de fréquences (basses, médiums, aigus) avec une FFT. La puissance de calcul et la mémoire de l'ESP32 suffisent pour une FFT en temps réel ; sur l'Uno, on ne peut faire qu'une analyse limitée et à faible résolution.
Projets à réaliser après cet article
Voir tous les projets
Contrôle d'une bande NeoPixel WS2812B avec l'ESP32
Les LED adressables WS2812B (NeoPixel) sont des LED RGB intelligentes chaînées et pilotées par une seule broche de données. On pilote un ruban WS2812B de 8 LED avec la bibliothèque Adafruit_NeoPixel pour créer un arc-en-ciel fluide. La logique 3,3 V de l'ESP32 convient à la plupart des WS2812B ; en cas d'instabilité, on montre la solution : résistance série de 470Ω et condensateur de 1000µF. L'animation fait glisser la teinte dans l'espace HSV.

Utilisation du ruban LED WS2812B
Tu découvres un ruban LED intelligent dont chaque lumière peut prendre sa propre couleur.

Gyrophare de police avec WS2812B
Tu ramènes sur ton bureau le gyrophare rouge et bleu d'une voiture de police. Une moitié d'un ruban WS2812B de dix LED clignote trois fois très vite en rouge, l'autre moitié trois fois en bleu, et le…

Chenillard WS2812B
Sur un ruban de dix LED, un point de lumière verte avance du début à la fin, une LED après l'autre, puis revient au départ ; il reste un tiers de seconde sur chaque LED.

Chenillard WS2812B (remplissage)
Un ruban lumineux qui se remplit et se vide comme un verre d'eau. L'Arduino allume une à une dix LED de couleur en orange et les laisse allumées ; une fois le ruban plein, il les éteint une à une…

Chenillard K2000 avec WS2812B
Un point de lumière rouge glisse d'un bout à l'autre d'un ruban LED intelligent, puis revient, dans un va-et-vient qui ne s'arrête jamais.

WS2812B Animation 1
Sur un ruban de 56 LED, toutes les couleurs de l'arc-en-ciel s'alignent côte à côte et défilent sans jamais s'arrêter, comme une rivière de lumière qui glisserait le long du ruban.

WS2812B Animation 2
Installe dans ta chambre un spectacle lumineux qui change de couleurs tout seul.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

