Bougie LED Arduino : flamme qui vacille et couronne de l'Avent
Bougie LED Arduino qui vacille comme une vraie flamme : PWM et hasard lissé, couronne de l'Avent à 4 bougies, tableau de réglages, Nano sur piles et Pico.
Dans ce projet de bougie LED Arduino, tu fais vaciller une LED ordinaire comme une vraie flamme de bougie grâce au PWM et à un hasard maîtrisé. Le résultat : une bougie qui brûle en toute sécurité sur la table, au rebord de la fenêtre ou dans la chambre des enfants, sans feu, sans suie et sans risque de chute. La plupart des bougies LED du commerce répètent un seul motif de scintillement ; en écrivant ton propre code, tu décides exactement si la flamme est calme ou vive, dans quelle plage elle brille et faiblit, et à quelle fréquence elle se couche sous un "courant d'air".
Dans ce guide, tu trouveras d'abord la logique de l'effet de scintillement et un court sketch pour une bougie, puis un tableau qui montre comment chaque paramètre change la flamme. Ensuite, tu construiras une couronne de l'Avent à quatre bougies : chaque appui sur le bouton allume une bougie de plus, le choix est gardé en EEPROM et le circuit se met en veille au bout de 6 heures. Enfin, tu verras comment tout loger dans une petite boîte avec un Arduino Nano, le calcul d'autonomie et une version MicroPython pour la Raspberry Pi Pico.

Comment fonctionne l'effet bougie LED ?
Les broches de l'Arduino ne délivrent que 0 V ou 5 V ; pour allumer une LED à mi-intensité, la broche est allumée et éteinte des centaines de fois par seconde. C'est le PWM (modulation de largeur d'impulsion). La valeur de 0 à 255 de analogWrite(broche, valeur) fixe la part de chaque période où la broche reste allumée : 64 correspond à environ 25 pour cent de luminosité, 191 à environ 75 pour cent. Sur l'Uno et le Nano, la fréquence PWM est d'environ 980 Hz sur les broches 5 et 6 et d'environ 490 Hz sur les broches 3, 9, 10 et 11 ; l'œil ne perçoit pas cette vitesse et voit la LED stable mais atténuée. Les détails sont dans le guide qu'est-ce que le PWM.
Le secret d'une flamme réaliste, c'est de lisser le hasard. Si tu écris analogWrite(broche, random(0, 256)) toutes les 20 millisecondes, la LED tressaute comme un néon défectueux, car une vraie flamme ne passe jamais de zéro à pleine luminosité d'un coup. Mieux vaut choisir une luminosité cible au hasard et rapprocher un peu la luminosité actuelle de cette cible à chaque pas : niveau = niveau + (cible − niveau) / 4. La cible change de temps en temps et le niveau la suit en douceur. Ajoute de rares chutes profondes, la flamme qui se couche sous un courant d'air, et l'œil y voit une vraie bougie.
Matériel et choix des LED
| Couleur de LED | Tension directe (env.) | Résistance (Uno, 5 V) | Résistance (Pico, 3,3 V) | Effet bougie |
|---|---|---|---|---|
| Jaune | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | Très bien, couleur de bougie classique |
| Orange / ambre | 2,0–2,1 V | 220 Ω (~13 mA) | 220 Ω (~6 mA) | La teinte la plus chaude et la plus réaliste |
| Blanc chaud | 3,0–3,2 V | 150 Ω (~12 mA) | Déconseillé (trop faible) | Lumineux, comme une bougie LED moderne |
| Rouge | 1,8–2,0 V | 220 Ω (~14 mA) | 220 Ω (~6 mA) | Trop sombre seul ; bien associé au jaune |
- Arduino Uno ou Nano : L'Uno pour tester sur le bureau, le Nano pour le loger dans une boîte. Les deux cartes ont les mêmes broches et le même code.
- 4 LED jaunes ou orange et la résistance du tableau pour chacune. Pour d'autres LED, trouve la valeur avec le calculateur de résistance pour LED.
- 1 bouton-poussoir : Pour changer le nombre de bougies et éteindre. La résistance de tirage interne est utilisée, aucune résistance supplémentaire n'est nécessaire.
- Breadboard et câbles de connexion, plus une plaque à trous et de la soudure pour une couronne définitive.
- Alimentation : Un chargeur USB, une batterie externe ou un boîtier de piles. Nous choisirons les piles avec le calcul plus bas.
- Corps de bougie : Un morceau de tube PVC blanc, une vieille bougie évidée ou un verre dépoli ; tout ce qui diffuse la lumière de la LED convient.
Une bougie : un premier sketch de scintillement
1const byte LED_PIN = 9; // PWM pini, 220 ohm ile LED / PWM pin, LED through 220 ohm
2
3int level = 180; // şu anki parlaklık / current brightness
4int target = 180; // hedef parlaklık / target brightness
5
6void setup() {
7 pinMode(LED_PIN, OUTPUT);
8 randomSeed(analogRead(A0)); // her açılışta farklı titreme / different flicker on every start
9}
10
11void loop() {
12 if (random(100) < 8) { // %8 ihtimalle yeni hedef / 8% chance of a new target
13 target = random(90, 256);
14 if (random(100) < 5) target = 40; // nadir esinti: alev eğilir / rare gust: the flame dips
15 }
16 level += (target - level) / 4; // hedefe yumuşak yaklaş / ease toward the target
17 analogWrite(LED_PIN, level);
18 delay(random(15, 40)); // düzensiz adım / irregular step
19}Relie la LED à la broche 9 via une résistance de 220 Ω, sa patte courte au GND, puis téléverse le sketch. À chaque tour, il y a 8 pour cent de chances de choisir une nouvelle cible entre 90 et 255 ; avec 5 pour cent de chances, la cible tombe à 40 pour une chute profonde. La ligne level += (target − level) / 4 ajoute un quart de l'écart pour une transition douce, et la pause aléatoire de 15–40 ms rend le motif encore plus irrégulier. La ligne randomSeed(analogRead(A0)) utilise le bruit de la broche A0 en l'air pour lancer une suite aléatoire différente à chaque démarrage ; sans elle, la bougie scintille de la même façon à chaque fois.
Tableau des paramètres de scintillement
| Paramètre | Par défaut | Si tu le baisses | Si tu l'augmentes |
|---|---|---|---|
| FLAME_MIN | 90 | La flamme vacille plus profondément et semble près de s'éteindre | La flamme se calme et brûle presque fixe |
| FLAME_MAX | 255 | La bougie devient plus faible, comme une veilleuse | 255 est la limite ; pour plus de lumière, il faut plus de courant dans la LED |
| CHANGE_CHANCE | 8 (%) | Une flamme tranquille dans une pièce sans courant d'air | Scintillement rapide et nerveux, fatigant à la longue |
| GUST_CHANCE | 3 (%) | Presque jamais de courant d'air | Une flamme qui se couche souvent, comme fenêtre ouverte |
| SMOOTH | 4 | 1–2 : sauts brusques, comme une ampoule défaillante | 8 et plus : variations lentes, en vagues |
| STEP_MS | 25 ms | Une flamme plus rapide et plus vive | À partir de 50 ms, on dirait du ralenti |
Couronne de l'Avent à quatre bougies : câblage
La couronne de l'Avent est une tradition, très aimée notamment en Allemagne, en Autriche et en Suisse, où l'on allume une bougie de plus chacun des quatre dimanches avant Noël. En 2026, les dimanches de l'Avent tombent le 29 novembre, le 6 décembre, le 13 décembre et le 20 décembre. Dans notre couronne, quatre LED représentent les quatre bougies ; un appui court ajoute une bougie allumée (0, 1, 2, 3, 4 puis de nouveau 0) et un appui long éteint le circuit. Chaque bougie a son propre état de scintillement, les quatre flammes paraissent donc indépendantes et naturelles.
| Connexion | Arduino Uno / Nano | Raspberry Pi Pico |
|---|---|---|
| Bougie 1 (résistance vers la patte longue de la LED) | D3 | GP14 |
| Bougie 2 | D5 | GP15 |
| Bougie 3 | D6 | GP16 |
| Bougie 4 | D9 | GP17 |
| Pattes courtes des LED | GND | GND |
| Bouton (autre patte au GND) | D2 | GP2 |

Code de la couronne de l'Avent : une bougie de plus chaque dimanche
Le sketch fonctionne avec millis() au lieu de delay(), pour que le scintillement ne s'arrête jamais pendant qu'il surveille le bouton et compte la minuterie. Cette approche est expliquée dans le guide millis ou delay. Toutes les 25 ms, l'état des quatre bougies est mis à jour, et les bougies non allumées restent à une valeur PWM de zéro. Le nombre de bougies choisi est écrit à l'adresse 0 de l'EEPROM ; même si tu débranches et rebranches, la couronne redémarre avec le même nombre de bougies.
1#include <EEPROM.h>
2#include <avr/sleep.h>
3
4const byte CANDLES = 4;
5const byte CANDLE_PINS[CANDLES] = {3, 5, 6, 9}; // PWM pinleri / PWM pins
6const byte BUTTON_PIN = 2; // buton -> GND, INT0 / button -> GND, INT0
7
8// Titreme ayarları / flicker settings
9const int FLAME_MIN = 90; // en kısık alev / dimmest flame
10const int FLAME_MAX = 255; // en parlak alev / brightest flame
11const byte CHANGE_CHANCE = 8; // her adımda yeni hedef olasılığı (%) / chance of a new target per step (%)
12const byte GUST_CHANCE = 3; // esinti olasılığı (%) / chance of a gust (%)
13const byte SMOOTH = 4; // büyüdükçe alev yavaşlar / higher = calmer flame
14const unsigned long STEP_MS = 25; // adım süresi / step time
15const unsigned long ON_TIME = 6UL * 60 * 60 * 1000; // 6 saat sonra uyku / sleep after 6 hours
16
17int level[CANDLES];
18int target[CANDLES];
19byte litCount = 1; // yanan mum sayısı (0-4) / number of lit candles (0-4)
20unsigned long onSince = 0;
21unsigned long lastStep = 0;
22
23void wakeUp() {} // yalnız uyandırmak için / only used to wake the chip
24
25void goToSleep() {
26 for (byte i = 0; i < CANDLES; i++) analogWrite(CANDLE_PINS[i], 0);
27 while (digitalRead(BUTTON_PIN) == LOW) {} // butonun bırakılmasını bekle / wait for release
28 delay(50);
29 set_sleep_mode(SLEEP_MODE_PWR_DOWN);
30 sleep_enable();
31 noInterrupts();
32 attachInterrupt(digitalPinToInterrupt(BUTTON_PIN), wakeUp, LOW);
33 interrupts();
34 sleep_cpu(); // burada uyur / sleeps here
35 sleep_disable(); // butona basınca buradan devam / resumes here on press
36 detachInterrupt(digitalPinToInterrupt(BUTTON_PIN));
37 while (digitalRead(BUTTON_PIN) == LOW) {} // uyandıran basış sayılmasın / ignore the wake-up press
38 delay(50);
39 onSince = millis();
40}
41
42void flicker() {
43 for (byte i = 0; i < CANDLES; i++) {
44 if (i >= litCount) { // bu mum henüz yakılmadı / not lit yet
45 analogWrite(CANDLE_PINS[i], 0);
46 continue;
47 }
48 if (random(100) < CHANGE_CHANCE) {
49 target[i] = random(FLAME_MIN, FLAME_MAX + 1);
50 if (random(100) < GUST_CHANCE) target[i] = FLAME_MIN / 2; // alev eğilir / the flame bends
51 }
52 level[i] += (target[i] - level[i]) / SMOOTH;
53 analogWrite(CANDLE_PINS[i], level[i]);
54 }
55}
56
57void setup() {
58 pinMode(BUTTON_PIN, INPUT_PULLUP);
59 for (byte i = 0; i < CANDLES; i++) {
60 pinMode(CANDLE_PINS[i], OUTPUT);
61 level[i] = target[i] = 200;
62 }
63 randomSeed(analogRead(A0));
64 litCount = EEPROM.read(0); // son seçimi hatırla / remember the last choice
65 if (litCount > CANDLES) litCount = 1; // boş EEPROM 255 okur / empty EEPROM reads 255
66 onSince = millis();
67}
68
69void loop() {
70 if (digitalRead(BUTTON_PIN) == LOW) {
71 unsigned long pressStart = millis();
72 while (digitalRead(BUTTON_PIN) == LOW) {
73 if (millis() - pressStart > 1500) { // uzun basış: kapat / long press: switch off
74 goToSleep();
75 return;
76 }
77 }
78 if (millis() - pressStart > 50) { // kısa basış: bir mum daha / short press: one more candle
79 litCount = (litCount + 1) % (CANDLES + 1);
80 EEPROM.update(0, litCount);
81 onSince = millis();
82 }
83 }
84
85 if (millis() - onSince > ON_TIME) goToSleep(); // zamanlayıcı / auto-off timer
86
87 if (millis() - lastStep >= STEP_MS) {
88 lastStep = millis();
89 flicker();
90 }
91}| Partie du code | Rôle |
|---|---|
| level[i], target[i] | Luminosité et cible propres à chaque bougie ; les quatre flammes vacillent indépendamment |
| i >= litCount | Éteint les bougies dont le tour n'est pas encore venu ; au 2e dimanche, litCount = 2 |
| EEPROM.update(0, litCount) | N'écrit pas si la valeur n'a pas changé, ce qui préserve la cellule EEPROM |
| si litCount > CANDLES, alors 1 | Une EEPROM jamais écrite renvoie 255 ; au tout premier démarrage, la couronne commence avec une bougie |
| ON_TIME | Au bout de 6 heures, éteint les bougies et passe en veille ; une couronne oubliée la nuit ne vide pas les piles |
| goToSleep() | Arrête le processeur avec SLEEP_MODE_PWR_DOWN ; un appui sur le bouton réveille la carte via l'interruption INT0 |
En veille, l'horloge de l'ATmega328P s'arrête et le processeur descend à quelques microampères. Pour le réveiller, on attache à la broche 2 une interruption sur niveau LOW ; en mode power-down, seule une interruption sur niveau peut réveiller le processeur, CHANGE ou FALLING ne fonctionnent donc pas ici. Au réveil, le code attend que le bouton soit relâché, pour que l'appui qui réveille ne compte pas aussi comme une bougie de plus. millis() s'arrête aussi pendant la veille, c'est pourquoi la minuterie est remise à zéro au réveil.
Format réduit avec un Nano et calcul d'autonomie
La durée d'une pile se calcule avec durée (heures) = capacité utilisable (mAh) / courant moyen (mA). Calculons le courant de la couronne : une LED qui vacille consomme en moyenne environ 70 pour cent de son courant maximal, soit environ 8–9 mA pour une LED à 12 mA. Quatre bougies font environ 35 mA ; avec les 15–20 mA que consomme un clone de Nano lui-même, le total atteint environ 50 mA. Une soirée de 6 heures consomme 300 mAh. En veille, le processeur ne consomme presque rien, mais à cause de la LED d'alimentation, de la puce USB et du régulateur de la carte, la plupart des clones de Nano consomment encore quelques mA (souvent autour de 5 mA) ; 18 heures de veille ajoutent environ 90 mAh. Tu peux tester d'autres scénarios avec le calculateur d'autonomie de batterie.
| Source d'alimentation | Capacité utilisable | Soirées de 6 heures (≈50 mA) | Remarque |
|---|---|---|---|
| 3 × AA alcalines (≈4,5 V, sur la broche 5V) | ~2 000 mAh | ~5 soirées (pertes en veille comprises) | Les LED faiblissent à mesure que les piles s'usent |
| 4 × AA NiMH rechargeables (≈4,8 V, sur la broche 5V) | ~1 900 mAh | ~5 soirées | À recharger 4–5 fois pendant l'Avent |
| 18650 + TP4056 + convertisseur élévateur 5 V | ~1 600 mAh (en 5 V) | ~4 soirées | Se recharge en USB, tient dans une boîte |
| Batterie externe USB de 10 000 mAh | ~6 300 mAh (en 5 V) | ~16 soirées | Peut se couper en veille à cause du faible courant |
| Chargeur USB 5 V 1 A | Illimitée | Illimitées | La solution la plus simple pour une couronne sur la table |
Version Raspberry Pi Pico en MicroPython
Sur la Pico, toutes les broches GPIO peuvent sortir du PWM : les bougies vont donc sur GP14–GP17 et le bouton sur GP2. En MicroPython, la luminosité se règle avec duty_u16() de 0 à 65535 ; le code garde les valeurs de 0 à 255 de la version Arduino et les multiplie par 257 pour obtenir la même échelle (255 × 257 = 65535). Au lieu de l'EEPROM, le nombre de bougies est gardé dans le fichier mum.txt du système de fichiers de la Pico. Enregistre le code sous le nom main.py et la couronne s'allume dès que la Pico est alimentée.
1from machine import Pin, PWM
2import time, random
3
4PINS = (14, 15, 16, 17) # 4 mum: GP14-GP17, 220 ohm / 4 candles, 220 ohm each
5button = Pin(2, Pin.IN, Pin.PULL_UP) # buton -> GND / button -> GND
6
7FLAME_MIN = 90 # 0-255 ölçeğinde / on a 0-255 scale
8FLAME_MAX = 255
9CHANGE_CHANCE = 8 # yeni hedef olasılığı (%) / chance of a new target (%)
10GUST_CHANCE = 3 # esinti olasılığı (%) / chance of a gust (%)
11SMOOTH = 4
12STEP_MS = 25
13
14leds = []
15for p in PINS:
16 pwm = PWM(Pin(p))
17 pwm.freq(1000) # 1 kHz, göz titreşimi görmez / 1 kHz, no visible strobing
18 leds.append(pwm)
19
20level = [200] * len(PINS)
21target = [200] * len(PINS)
22
23try:
24 with open("mum.txt") as f: # son seçimi oku / read the last choice
25 lit = int(f.read())
26except (OSError, ValueError):
27 lit = 1
28
29
30def save(n):
31 with open("mum.txt", "w") as f:
32 f.write(str(n))
33
34
35last_button = 1
36while True:
37 b = button.value()
38 if b == 0 and last_button == 1: # basıldığı an / the moment it is pressed
39 lit = (lit + 1) % (len(PINS) + 1)
40 save(lit)
41 time.sleep_ms(30) # basit debounce / simple debounce
42 last_button = b
43
44 for i, led in enumerate(leds):
45 if i >= lit:
46 led.duty_u16(0)
47 continue
48 if random.randint(0, 99) < CHANGE_CHANCE:
49 target[i] = random.randint(FLAME_MIN, FLAME_MAX)
50 if random.randint(0, 99) < GUST_CHANCE:
51 target[i] = FLAME_MIN // 2
52 level[i] += (target[i] - level[i]) // SMOOTH
53 led.duty_u16(level[i] * 257) # 0-255 -> 0-65535
54 time.sleep_ms(STEP_MS)Comme la Pico fonctionne en 3,3 V, les LED blanc chaud (environ 3 V de tension directe) s'allument à peine ; utilise des LED jaunes ou orange avec des résistances de 220 Ω. Cette version n'a ni minuterie ni veille ; si tu veux, compte 6 heures avec time.ticks_ms() puis mets toutes les valeurs de duty à zéro. Nous avons réglé la fréquence PWM de la Pico à 1 kHz ; à plus basse fréquence, des bandes peuvent apparaître sur les vidéos filmées au téléphone.
Pour un rendu réaliste
- Diffuse la lumière : Dépolis le sommet de la LED au papier de verre fin ou glisse un peu de coton dans le corps de la bougie ; tout le corps brille au lieu d'un seul point.
- Flamme à deux LED : Place une LED jaune et une orange dans la même bougie sur des broches PWM séparées et fais-les vaciller à des vitesses différentes : la couleur de la flamme bouge aussi. Les six broches PWM de l'Uno suffisent pour trois bougies de ce type.
- Corps de bougie : Utilise du tube PVC blanc de 2–3 cm de diamètre, une vraie bougie évidée ou un verre dépoli. Un vrai corps de bougie diffuse la lumière de la façon la plus naturelle.
- Socle de la couronne : Décore les quatre bougies avec des branches de sapin artificiel et des pommes de pin, cache le Nano et les piles sous le socle et place le bouton dans un coin facile d'accès.
- Température de couleur : Si tu utilises des LED blanc chaud, un film transparent orange devant elles rapproche la lumière de la couleur d'une vraie flamme.
Erreurs fréquentes et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| La LED ne vacille pas, elle est soit allumée soit éteinte | La LED est sur une broche sans PWM | Déplace la LED sur la broche 3, 5, 6, 9, 10 ou 11 |
| La flamme tressaute comme un néon défectueux | SMOOTH est trop petit ou la cible change à chaque pas | Mets SMOOTH entre 4 et 6 et baisse CHANGE_CHANCE sous 10 |
| Toutes les bougies vacillent pareil en même temps | Une seule variable level est écrite sur toutes les broches | Utilise des tableaux level et target séparés pour chaque bougie |
| La carte ne sort pas de veille | Le bouton n'est pas sur D2 ou l'interruption n'est pas sur niveau LOW | Branche le bouton sur D2 et utilise attachInterrupt(..., LOW) |
| Le même motif à chaque démarrage | randomSeed n'a pas été appelé ou A0 est relié à quelque chose | Appelle randomSeed(analogRead(A0)) avec une broche analogique en l'air |
| Les piles sont vides en quelques jours | La LED d'alimentation et la puce USB du Nano consomment même en veille | Utilise un chargeur ou passe à un Pro Mini sans LED d'alimentation |
Cette bougie LED, faite de quelques LED, de quelques résistances et d'un bouton, réunit le PWM, la temporisation avec millis(), l'EEPROM, la veille et le calcul d'autonomie dans un projet chaleureux. Tu peux reprendre l'effet bougie dans tes propres projets en consultant, dans l'application BlueGrays, les schémas pas à pas et le code de projets lumineux de base, comme allumer une LED, allumer et éteindre une LED avec un bouton, un fondu de couleurs avec une LED RVB et la variation PWM avec un ESP32 ou une Pico.
Questions fréquentes
Comment faire une bougie LED qui vacille avec Arduino ?
Relie la LED à une broche PWM de l'Arduino via une résistance de 220 Ω et fais varier sa luminosité au hasard, mais en douceur, avec analogWrite(). Le meilleur rendu s'obtient en choisissant une luminosité cible aléatoire et en rapprochant lentement la luminosité actuelle de cette cible à chaque pas. De rares chutes profondes imitent la flamme qui se couche sous un courant d'air.
Quelle couleur de LED choisir pour une bougie LED ?
Les LED jaunes ou orange (ambre) sont les plus proches de la couleur d'une vraie flamme. Les LED blanc chaud sont plus lumineuses et rappellent les bougies LED modernes, mais restent faibles sur les cartes en 3,3 V. Les LED bleues et blanc froid ne ressemblent pas à une flamme.
Quelle résistance utiliser pour brancher une LED sur Arduino ?
En 5 V, une résistance de 220 Ω pour une LED jaune ou rouge et de 150 Ω pour une LED blanc chaud donnent environ 12–14 mA, ce qui est sûr. La valeur se calcule avec (tension d'alimentation − tension de la LED) / courant souhaité. Sans résistance, tu risques d'abîmer la LED et la broche de l'Arduino.
Quelles broches de l'Arduino gèrent le PWM ?
Sur l'Arduino Uno et le Nano, les broches PWM sont les 3, 5, 6, 9, 10 et 11, repérées par un ~ sur la carte. Les broches 5 et 6 tournent à environ 980 Hz, les autres à environ 490 Hz. Sur la Raspberry Pi Pico, toutes les broches GPIO peuvent sortir du PWM.
Combien de temps tient une bougie LED Arduino sur piles ?
Une couronne à quatre bougies avec un Nano consomme environ 50 mA ; avec trois piles AA de 2 000 mAh, pertes en veille comprises, cela fait environ cinq soirées de 6 heures. Une batterie externe de 10 000 mAh tient environ 16 soirées. Pour une longue autonomie, on utilise un Pro Mini sans LED d'alimentation et la mise en veille.
Quels jours allume-t-on les bougies de la couronne de l'Avent ?
Sur la couronne de l'Avent, on allume une bougie de plus chacun des quatre dimanches avant Noël. En 2026, ce sont le 29 novembre, le 6 décembre, le 13 décembre et le 20 décembre. Appuie une fois sur le bouton de ce projet chaque dimanche pour augmenter le nombre de bougies allumées.
Projets à réaliser après cet article
Voir tous les projets
Clignotement d'une LED
Le tout premier bonjour de l'électronique : allumer et éteindre une seule LED. L'Arduino allume et éteint la LED à intervalles très courts, la lumière clignote donc rapidement.

Deux LED clignotant en alternance
Deux LED clignotent vite à tour de rôle : quand l'une s'allume, l'autre s'éteint, comme si elles se renvoyaient une balle.

Allumer et éteindre une LED avec un bouton
Un appui et la lumière s'allume, un deuxième et elle s'éteint, exactement comme l'interrupteur de ta chambre.

Utilisation d'une LED RVB
Trois couleurs se cachent dans une seule LED : la LED RGB s'allume en rouge, puis en vert, puis en bleu, chaque couleur allumée une demi-seconde puis éteinte une demi-seconde, avant que tout…

Transition douce des couleurs avec une LED RVB
Une seule LED RGB glisse doucement du rouge au vert, du vert au bleu, puis revient au rouge, dans une boucle arc-en-ciel qui ne s'arrête jamais.

ESP32 LED Fade avec PWM
Modifiez la luminosité de la LED en douceur de 0 à max, de max à 0. Nous contrôlons le PWM avec analogWrite() comme dans Arduino - la même syntaxe avec ESP32 Arduino Core 3.0+ fonctionne sans problème. La définition du pin + pinMode + analogWrite est suffisante.

Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
Dans ce projet, nous contrôlons la luminosité d'une LED de manière analogique à l'aide d'un potentiomètre. La broche ADC de l'ESP32 lit la tension entre 0 et 3,3 V provenant du potentiomètre, puis cette valeur est convertie en signal PWM (modulation de largeur d'impulsion) envoyé à la LED. Ainsi, la LED s'allume et s'éteint progressivement. Avec Arduino Core 3.0+, analogWrite() est utilisable directement; sur ESP32-S2/S3, la résolution de l'ADC est fixée à 12 bits.

Raspberry Pi Pico PWM LED Fade (Effet Respiration)
La LED ne clignote plus — elle respire ! Grâce au PWM (modulation de largeur d'impulsion) du Raspberry Pi Pico, la luminosité monte puis descend lentement. Apprends la classe machine.PWM, duty_u16() (luminosité 16 bits 0–65535), la fréquence PWM, les boucles range() et la sortie quasi analogique. Base du mélange de couleurs RGB, du contrôle moteur, des servos et du buzzer.
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

