Guides · 9 min de lecture

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.

Anneau LED RVB NeoPixel WS2812B de 24 LED
Anneau WS2812B de 24 LED : un seul fil de données contrôle la couleur de chaque LED, idéal pour un VU-mètre.

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éristiqueUno + KY-038ESP32 + INMP441
Type de microÉlectret analogique, sans amplificateurMEMS numérique, sortie I2S
RésolutionCAN 10 bits (pas de 4,9 mV)Données 24 bits
ÉchantillonnageEnviron 8,9 kHz (analogRead ~112 µs)16 kHz, en continu par DMA
Calcul du niveauCrête à crêteRMS + décibels
SensibilitéFaible, réagit aux sons forts et prochesÉlevée, capte facilement la musique d'ambiance
BruitSensible au bruit d'alimentationTrès faible, liaison numérique
DifficultéDébutantIntermé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.
Module capteur de son KY-038
Capteur de son KY-038 : la broche AO donne le signal brut du micro, la broche DO produit un signal numérique quand le seuil réglé par le trimmer est dépassé.

Câblage Uno + KY-038

Composant / brocheArduino UnoRemarque
KY-038 +5VAlimentation du module
KY-038 GGNDMasse commune
KY-038 AOA0Signal sonore analogique
KY-038 DONon connectéeInutile pour le VU-mètre
Potentiomètre, borne centraleA1Bornes extérieures au 5V et à la GND
WS2812B DIND6 (via 330 Ω)Côté entrée (DI) de l'anneau
WS2812B 5V5V ou 5 V externeCondensateur 1000 µF entre 5V et GND
WS2812B GNDGNDDoit être commune avec l'alimentation externe
À pleine luminosité blanche, 24 LED consomment environ 24 × 60 mA = 1,44 A, bien plus que ce que l'Uno peut fournir par l'USB. Dans le code, la luminosité est limitée à 60/255, mais si tu utilises un long ruban, alimente les LED avec un adaptateur 5 V externe et relie impérativement sa GND à la GND de l'Arduino. Sans GND commune, les LED affichent des couleurs aléatoires. Pour plus de détails, consulte l'article LED NeoPixel WS2812B.

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

  1. Dans l'IDE Arduino, ouvre le Gestionnaire de bibliothèques, cherche Adafruit NeoPixel et installe-la.
  2. Monte le circuit d'après le tableau ci-dessus ; relie la longue patte (+) du condensateur au 5V.
  3. 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à.
  4. 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.
  5. Lance de la musique et tourne le potentiomètre pour trouver le point où l'anneau est presque entièrement allumé au volume maximal.
  6. Place le micro à 20–50 cm de l'enceinte, loin de la lumière des LED et des vibrations de la table.
C++ (Arduino IDE)
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 codeRôle
readPeakToPeak()Échantillonne pendant 25 ms et renvoie la différence entre la plus grande et la plus petite valeur
noiseFloorMoyenne des 20 mesures au démarrage + 2 ; en dessous, c'est du silence
maxPPPleine échelle réglée de 10 à 300 avec le potentiomètre ; petite valeur = forte sensibilité
levelNiveau lissé, montée rapide et descente lente (évite le scintillement)
peakLedPoint 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.

Le trimmer bleu du KY-038 règle uniquement le seuil de la sortie DO ; il n'augmente pas l'amplitude du signal sur AO. Si la version Uno ne réagit qu'aux sons forts et proches, augmente la sensibilité avec le potentiomètre ou passe à un module micro avec amplificateur. Pour tous les détails sur le KY-038, lis l'article capteur de son KY-038.

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 / brocheESP32Remarque
INMP441 VDD3V3N'applique pas 5 V, le micro fonctionne en 3,3 V
INMP441 GNDGNDMasse commune
INMP441 L/RGNDSélectionne le canal gauche
INMP441 WSGPIO 25Sélection de mot (LRCLK)
INMP441 SCKGPIO 32Horloge de bit (BCLK)
INMP441 SDGPIO 33Données audio
WS2812B DINGPIO 18 (via 330 Ω)Le signal 3,3 V fonctionne avec un fil court
WS2812B 5VVIN (USB 5 V) ou 5 V externeAjoute un condensateur 1000 µF
WS2812B GNDGNDCommune avec l'alimentation externe
Ne laisse pas la broche L/R de l'INMP441 en l'air ; sinon le micro ne peut pas choisir de canal et tu lis en permanence des zéros ou des données absurdes. De plus, avec une alimentation WS2812B en 5 V, le signal de données 3,3 V de l'ESP32 peut être limite sur certains rubans. Si la première LED scintille ou affiche une mauvaise couleur, raccourcis le fil de données ou utilise un convertisseur de niveau logique.
C++ (Arduino IDE)
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ômeCause probableSolution
Les LED scintillent en silenceBruit de fond mesuré trop basGarde 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 faibleBaisse maxPP avec le potentiomètre, rapproche le micro de l'enceinte
L'anneau est toujours pleinPleine échelle trop petiteTourne le potentiomètre pour augmenter maxPP, ou augmente RANGE_DB
L'INMP441 lit toujours zéroL/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 couleurSignal de données faible ou pas de résistanceAjoute une résistance série de 330 Ω, raccourcis le fil de données
La carte redémarre sur un coup de basseLe courant des LED fait chuter l'alimentationBaisse la luminosité, utilise une alimentation 5 V externe et un condensateur 1000 µF
Les LED déclenchent le microLes ondulations d'alimentation parasitent la ligne analogiqueRelie le micro au 5V par un fil séparé, réunis les GND en un seul point
Le Traceur série (Serial Plotter) est très utile pour les réglages : ajoute Serial.println(pp) dans la boucle, ou Serial.println(db) sur l'ESP32, et regarde le graphique pendant la musique. La ligne en silence montre le bruit de fond, et le pic du moment le plus fort du morceau t'indique directement quelle pleine échelle utiliser.

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.

Voir tous les projets
Contrôle d'une bande NeoPixel WS2812B avec l'ESP32
ES-24Intermédiaire
Premium

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.

4.9(19)
30
Utilisation du ruban LED WS2812B
AR-69Intermédiaire
Premium

Utilisation du ruban LED WS2812B

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

4.8(54)
70
Gyrophare de police avec WS2812B
AR-70Intermédiaire
Premium

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…

4.8(67)
86
Chenillard WS2812B
AR-71Intermédiaire
Premium

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.

4.8(58)
75
Chenillard WS2812B (remplissage)
AR-72Intermédiaire
Premium

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…

4.7(50)
65
Chenillard K2000 avec WS2812B
AR-73Intermédiaire
Premium

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.

4.9(73)
94
WS2812B Animation 1
AR-75Intermédiaire
Premium

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.

4.9(69)
89
WS2812B Animation 2
AR-76Intermédiaire
Premium

WS2812B Animation 2

Installe dans ta chambre un spectacle lumineux qui change de couleurs tout seul.

4.8(65)
84