Guides · 10 min de lecture

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.

LED de 5 mm
LED de 5 mm : pour l'effet bougie, choisis du jaune, de l'orange ou du blanc chaud ; les LED bleues ou blanc froid ne ressemblent pas à une flamme.

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 LEDTension directe (env.)Résistance (Uno, 5 V)Résistance (Pico, 3,3 V)Effet bougie
Jaune2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)Très bien, couleur de bougie classique
Orange / ambre2,0–2,1 V220 Ω (~13 mA)220 Ω (~6 mA)La teinte la plus chaude et la plus réaliste
Blanc chaud3,0–3,2 V150 Ω (~12 mA)Déconseillé (trop faible)Lumineux, comme une bougie LED moderne
Rouge1,8–2,0 V220 Ω (~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

C++ (Arduino IDE)
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ètrePar défautSi tu le baissesSi tu l'augmentes
FLAME_MIN90La flamme vacille plus profondément et semble près de s'éteindreLa flamme se calme et brûle presque fixe
FLAME_MAX255La bougie devient plus faible, comme une veilleuse255 est la limite ; pour plus de lumière, il faut plus de courant dans la LED
CHANGE_CHANCE8 (%)Une flamme tranquille dans une pièce sans courant d'airScintillement rapide et nerveux, fatigant à la longue
GUST_CHANCE3 (%)Presque jamais de courant d'airUne flamme qui se couche souvent, comme fenêtre ouverte
SMOOTH41–2 : sauts brusques, comme une ampoule défaillante8 et plus : variations lentes, en vagues
STEP_MS25 msUne flamme plus rapide et plus viveÀ partir de 50 ms, on dirait du ralenti
Pendant les réglages, change un seul paramètre à la fois et regarde la LED à travers du papier ou un verre dépoli plutôt qu'en direct ; sur une LED nue, le scintillement paraît toujours plus brutal qu'il ne l'est. Pour la plupart des gens, le rendu le plus naturel s'obtient avec FLAME_MIN entre 80 et 110, SMOOTH entre 3 et 5 et CHANGE_CHANCE entre 6 et 10.

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.

ConnexionArduino Uno / NanoRaspberry Pi Pico
Bougie 1 (résistance vers la patte longue de la LED)D3GP14
Bougie 2D5GP15
Bougie 3D6GP16
Bougie 4D9GP17
Pattes courtes des LEDGNDGND
Bouton (autre patte au GND)D2GP2
Branche les bougies uniquement sur des broches PWM : sur l'Uno et le Nano, ce sont les broches 3, 5, 6, 9, 10 et 11 (repérées par un ~ sur la carte). Sur une autre broche, la LED ne vacille pas avec analogWrite() ; elle reste éteinte en dessous de 128 et pleinement allumée au-dessus. Branche le bouton sur la broche 2, car le sketch se réveille de la veille grâce à l'interruption de cette broche (INT0). Pour le brochage du Nano, vois le guide brochage de l'Arduino Nano.
Arduino Nano
Arduino Nano : le même processeur ATmega328P et les mêmes broches PWM que l'Uno, mais assez petit pour tenir dans le socle d'une couronne.

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.

C++ (Arduino IDE)
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 codeRô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 1Une EEPROM jamais écrite renvoie 255 ; au tout premier démarrage, la couronne commence avec une bougie
ON_TIMEAu 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'alimentationCapacité utilisableSoiré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éesSe recharge en USB, tient dans une boîte
Batterie externe USB de 10 000 mAh~6 300 mAh (en 5 V)~16 soiréesPeut se couper en veille à cause du faible courant
Chargeur USB 5 V 1 AIllimitéeIllimitéesLa solution la plus simple pour une couronne sur la table
Ne branche pas quatre piles AA alcalines directement sur la broche 5V : des alcalines neuves atteignent jusqu'à 6,4 V au total, et sur la broche 5V, qui contourne le régulateur, cela dépasse la limite de 5,5 V du processeur. Une pile 9 V n'est pas un bon choix non plus : elle ne fait qu'environ 500 mAh et le régulateur sur VIN transforme l'excès de tension en chaleur. Pour une bougie qui tient longtemps sur piles, un Arduino Pro Mini dont on a retiré la LED d'alimentation ramène le courant de veille à quelques microampères.

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.

MicroPython
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ômeCause probableSolution
La LED ne vacille pas, elle est soit allumée soit éteinteLa LED est sur une broche sans PWMDéplace la LED sur la broche 3, 5, 6, 9, 10 ou 11
La flamme tressaute comme un néon défectueuxSMOOTH est trop petit ou la cible change à chaque pasMets SMOOTH entre 4 et 6 et baisse CHANGE_CHANCE sous 10
Toutes les bougies vacillent pareil en même tempsUne seule variable level est écrite sur toutes les brochesUtilise des tableaux level et target séparés pour chaque bougie
La carte ne sort pas de veilleLe bouton n'est pas sur D2 ou l'interruption n'est pas sur niveau LOWBranche le bouton sur D2 et utilise attachInterrupt(..., LOW)
Le même motif à chaque démarragerandomSeed n'a pas été appelé ou A0 est relié à quelque choseAppelle randomSeed(analogRead(A0)) avec une broche analogique en l'air
Les piles sont vides en quelques joursLa LED d'alimentation et la puce USB du Nano consomment même en veilleUtilise un chargeur ou passe à un Pro Mini sans LED d'alimentation
Observe une vraie bougie quelques minutes dans une pièce sombre et compte combien de fois la luminosité change, puis règle STEP_MS et CHANGE_CHANCE d'après ce que tu as vu. La plupart des flammes ondulent visiblement deux ou trois fois par seconde et ne se couchent vraiment que toutes les quelques minutes.

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.

Voir tous les projets
Clignotement d'une LED
AR-1Débutant

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.

4.6(200)
1246
Deux LED clignotant en alternance
AR-2Débutant

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.

4.6(110)
362
Allumer et éteindre une LED avec un bouton
AR-10Débutant

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.

4.7(103)
177
Utilisation d'une LED RVB
AR-39Débutant
Premium

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…

4.9(73)
100
Transition douce des couleurs avec une LED RVB
AR-40Débutant
Premium

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.

4.8(58)
78
ESP32 LED Fade avec PWM
ES-8Débutant

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.

4.8(36)
55
Luminosité d'une LED avec un Potentiomètre sur ESP32 (Analogique → PWM)
ES-13Intermédiaire
Premium

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.

4.5(19)
32
Raspberry Pi Pico PWM LED Fade (Effet Respiration)
PI-14Débutant

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.

4