Guirlande LED Sapin de Noël Arduino : WS2812B, Neige et Arc-en-ciel

Utiliser Arduino et un ruban LED WS2812B pour ton sapin de Noël est le moyen le plus amusant d'aller bien au-delà des quelques modes fixes des guirlandes toutes faites. Comme tu peux contrôler la couleur et la luminosité de chaque LED une par une, tu peux faire tomber des flocons du haut en bas, faire tourner un arc-en-ciel autour des branches ou faire scintiller des étoiles rouges, vertes et dorées au hasard. Il te suffit d'un seul fil de données, d'un bouton et d'une alimentation 5 V bien choisie.

Dans ce guide, nous partons de la liste du matériel, puis nous calculons l'alimentation selon la longueur du ruban, nous câblons correctement l'alimentation, la carte et le ruban, et nous montons pas à pas un programme complet pour Arduino Uno (FastLED) avec changement d'effet par bouton, ainsi que les versions ESP32 (Adafruit NeoPixel) et Raspberry Pi Pico (MicroPython) du même projet. À la fin, tu sauras aussi comment enrouler le ruban autour du sapin, quelles précautions de sécurité prendre et comment résoudre les problèmes les plus fréquents.

Pourquoi un ruban LED WS2812B pour un sapin de Noël ?

Dans les guirlandes classiques, toutes les ampoules s'allument en même temps ou fonctionnent par quelques groupes en séquence. Dans un WS2812B, chaque LED contient une petite puce de pilotage. Arduino envoie les infos de couleur à la suite sur la ligne de données ; la première LED prend ses 24 bits et fait passer le reste à la suivante. Tu peux ainsi gérer un ruban de 100 ou 300 LED avec une seule broche et donner une couleur différente à chaque LED. Grâce à cela, les effets animés comme la neige prennent une vivacité impossible avec des lumières fixes. Pour comprendre plus en détail le fonctionnement des LED adressables, jette un oeil à l'article LED NeoPixel WS2812B.

Liste du matériel

• Ruban LED WS2812B : pour un sapin de 1,5 à 1,8 m, un ruban de 2,5 m à 60 LED/m ou de 5 m à 30 LED/m est un bon départ. Les modèles IP65 sous silicone résistent mieux aux branches et à la poussière.
• Carte de contrôle : Arduino Uno, Nano, ESP32 ou Raspberry Pi Pico.
• Alimentation 5 V : choisis le courant d'après le tableau ci-dessous ; pour 100 LED, une 5 V 4 A est un choix confortable.
• Prise DC femelle (à bornier à vis) : pour raccorder la fiche de l'alimentation aux fils sans soudure.
• Condensateur électrolytique 1000 µF / 10 V : il lisse les appels de courant brusques à l'entrée du ruban.
• Résistance de 330 Ω : en série sur la ligne de données ; elle limite les réflexions du signal et le courant d'entrée de la première LED.
• Bouton poussoir : pour passer d'un effet à l'autre.
• Câble épais : câble d'au moins 0,75 à 1,5 mm² de section pour les lignes 5V et GND.
• 74AHCT125 ou 74HCT245 (facultatif) : pour remonter le signal de données 3,3 V de l'ESP32 et du Pico à 5 V.

Calcul de l'alimentation : quel courant faut-il ?

Chacune des puces rouge, verte et bleue d'un WS2812B consomme environ 20 mA à pleine luminosité ; une LED en blanc complet consomme donc environ 60 mA. Tu trouves le courant dans le pire cas avec la formule I = nombre de LED × 60 mA. Un ruban de 100 LED tire 6 A quand toutes les LED sont en blanc pur à pleine luminosité, soit P = 5 V × 6 A = 30 W. Dans les effets arc-en-ciel, neige et étoiles, la plupart des LED sont d'une seule couleur ou atténuées, donc en pratique le courant reste autour du tiers du pire cas. Pour un choix sûr, multiplie ce courant typique par 2 et arrondis à la valeur d'alimentation la plus proche, puis règle la limite de courant du logiciel à environ 80 % de l'alimentation. Tu peux vérifier facilement la relation entre courant, tension et puissance avec le calculateur de loi d'Ohm.

Sur les longs rubans, le second problème est la chute de tension. Comme les fines pistes de cuivre du ruban ont une résistance, la tension peut descendre sous 4 V au bout d'un ruban de 5 m ; les puces bleue et verte faiblissent et le blanc paraît jaunâtre et terne. La solution consiste à réalimenter le 5V et le GND non seulement au début, mais tous les 1 à 1,5 mètre (ou toutes les 100 à 150 LED) avec des fils séparés venant de l'alimentation. On appelle cela l'injection d'alimentation. Pour ces fils, utilise au moins 0,75 mm² pour 5 ampères et 1,5 mm² pour 10 ampères ; relie la ligne de données uniquement au début du ruban.

Schéma de branchement : alimentation 5 V, ruban et carte

1. Repère les flèches sur le ruban et soude un câble à l'extrémité où la flèche commence (DIN). Si tu envoies les données dans le sens inverse de la flèche, c'est-à-dire par l'extrémité DOUT, aucune LED ne s'allume.
2. Relie la sortie +5 V de l'alimentation à l'extrémité 5V du ruban (indiquée +5V ou VCC sur certains rubans) et le GND de l'alimentation à l'extrémité GND du ruban.
3. Branche le condensateur de 1000 µF entre 5V et GND à l'entrée du ruban ; la patte longue (plus) doit aller au 5V et la patte marquée d'une bande sur le boîtier (moins) au GND.
4. Relie la broche GND de la carte au GND de l'alimentation. Sans masse commune, le signal de données n'a pas de référence.
5. Relie la broche de données de la carte (D6 sur l'Uno) à l'entrée DIN du ruban via la résistance de 330 Ω ; elle donne de meilleurs résultats placée du côté du ruban.
6. Relie une patte du bouton à D2 et l'autre au GND ; la résistance de pull-up interne sera activée dans le code.
7. Si tu utilises plus de 150 LED, tire aussi des câbles 5V et GND séparés depuis l'alimentation vers le milieu et la fin du ruban.
8. Pendant le développement, alimente la carte par USB et le ruban par l'alimentation. Une fois le projet terminé, tu peux envoyer le 5 V de l'alimentation à la broche 5V de l'Uno ; dans ce cas, ne branche pas le câble USB en même temps.

Code Arduino Uno (FastLED) : trois effets et changement de mode par bouton

Dans l'IDE Arduino, ouvre le Gestionnaire de bibliothèques et cherche FastLED pour l'installer ; pour une explication détaillée, consulte l'article Ajouter une bibliothèque à Arduino. Le programme ci-dessous contient les effets arc-en-ciel, chute de neige et scintillement d'étoiles ; à chaque appui sur le bouton, il passe à l'effet suivant. Comme le code utilise millis() au lieu de delay(), le bouton est détecté à tout moment pendant l'effet. Tu trouveras la logique de cette méthode dans l'article Différence entre millis et delay.

1#include <FastLED.h>
2
3#define LED_PIN     6      // şeridin DIN girişi (330 ohm üzerinden) / strip DIN input (via 330 ohm)
4#define BUTTON_PIN  2      // buton, diğer bacak GND / button, other leg to GND
5#define NUM_LEDS    100    // şeritteki LED sayısı / number of LEDs on the strip
6#define BRIGHTNESS  120    // genel parlaklık 0-255 / global brightness 0-255
7#define MAX_MA      3200   // 4 A adaptörün %80'i / 80% of a 4 A supply
8
9CRGB leds[NUM_LEDS];
10
11const uint8_t MODE_COUNT = 3;                          // 0 gökkuşağı, 1 kar, 2 yıldız / 0 rainbow, 1 snow, 2 twinkle
12const uint16_t FRAME_MS[MODE_COUNT] = {20, 60, 30};    // kare süreleri (ms) / frame times (ms)
13const CRGB XMAS[4] = {CRGB::Red, CRGB::Green, CRGB::Gold, CRGB::White};
14
15uint8_t mode = 0;
16uint8_t hue = 0;
17
18void setup() {
19  pinMode(BUTTON_PIN, INPUT_PULLUP);
20  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
21  FastLED.setMaxPowerInVoltsAndMilliamps(5, MAX_MA);  // akım sınırı / current limit
22  FastLED.setBrightness(BRIGHTNESS);
23  FastLED.clear(true);                                // açılışta hepsini söndür / all off at start
24}
25
26void checkButton() {
27  static bool lastState = HIGH;
28  static unsigned long lastChange = 0;
29  bool state = digitalRead(BUTTON_PIN);
30  if (state != lastState && millis() - lastChange > 50) {  // 50 ms zıplama filtresi / 50 ms debounce
31    lastChange = millis();
32    lastState = state;
33    if (state == LOW) {                                     // basıldı / pressed
34      mode = (mode + 1) % MODE_COUNT;
35      FastLED.clear();
36    }
37  }
38}
39
40void rainbow() {
41  fill_rainbow(leds, NUM_LEDS, hue, 3);   // her LED'de ton 3 artar / hue +3 per LED
42  hue += 2;                               // renkler döner / colours rotate
43}
44
45void snowfall() {
46  for (int i = 0; i < NUM_LEDS - 1; i++) {
47    leds[i] = leds[i + 1];                // bir LED aşağı kaydır / shift one LED down
48  }
49  if (random8() < 38) {
50    leds[NUM_LEDS - 1] = CRGB::White;     // tepede yeni kar tanesi / new flake at the top
51  } else {
52    leds[NUM_LEDS - 1] = CRGB(0, 0, 24);  // koyu mavi gece / dark blue night
53  }
54}
55
56void twinkle() {
57  fadeToBlackBy(leds, NUM_LEDS, 20);      // hepsini biraz kıs / dim everything a little
58  if (random8() < 80) {
59    leds[random16(NUM_LEDS)] = XMAS[random8(4)];  // rastgele yıldız / random star
60  }
61}
62
63void loop() {
64  checkButton();
65  static unsigned long lastFrame = 0;
66  if (millis() - lastFrame >= FRAME_MS[mode]) {
67    lastFrame = millis();
68    if (mode == 0) rainbow();
69    else if (mode == 1) snowfall();
70    else twinkle();
71    FastLED.show();                       // renkleri şeride gönder / push colours to the strip
72  }
73}

Comment fonctionnent les effets ?

Arc-en-ciel : la fonction fill_rainbow part de la teinte (hue) donnée à la première LED et augmente la teinte de 3 pas à chaque LED. Dans FastLED, la teinte va de 0 à 255 ; avec 100 LED, la teinte avance de 300 pas au total, donc on voit un peu plus qu'un cercle chromatique complet sur le ruban. Comme on augmente la variable hue de 2 à chaque image, les couleurs tournent lentement autour du sapin. Pour des bandes de couleur plus larges, utilise 1 ou 2 à la place de 3.

Chute de neige : quand le ruban est enroulé de bas en haut autour du sapin, la première LED est tout en bas et la dernière au sommet. À chaque image, on décale toutes les couleurs d'une LED vers le bas et on ajoute au sommet soit un flocon blanc, soit un pixel de nuit bleu foncé. Comme random8() produit un nombre entre 0 et 255, la probabilité d'obtenir moins de 38 est d'environ 15 % ; si tu augmentes ce nombre, la neige devient plus dense. Avec une durée d'image de 60 ms, un flocon descend les 100 LED en 6 secondes. Scintillement (étoiles) : fadeToBlackBy atténue toutes les LED d'environ 8 % à chaque image ; en même temps, une LED choisie au hasard s'allume à pleine luminosité en rouge, vert, doré ou blanc. Le résultat rappelle les guirlandes de Noël à l'ancienne, mais en beaucoup plus vivant.

Sapin de Noël avec l'ESP32 (Adafruit NeoPixel)

FastLED fonctionne aussi sur l'ESP32, mais ici nous écrivons le même projet avec la bibliothèque Adafruit NeoPixel ; tu connaîtras ainsi les deux bibliothèques populaires. La version actuelle de la bibliothèque se compile avec le même code sur les versions 2.x et 3.x du noyau Arduino ESP32 et génère le signal avec l'unité matérielle RMT. Comme avec Adafruit NeoPixel les couleurs atténuées par setBrightness peuvent se dégrader à la relecture, nous calculons les effets dans notre propre tableau de luminosité (level) et réécrivons tout le ruban à chaque image. La broche de données est GPIO 13 et le bouton GPIO 4. Si tu veux plus tard piloter le sapin depuis ton téléphone, l'article Installation de WLED propose une interface toute prête.

1#include <Adafruit_NeoPixel.h>
2
3#define LED_PIN     13     // şeridin DIN girişi (330 ohm üzerinden) / strip DIN input (via 330 ohm)
4#define BUTTON_PIN  4      // buton, diğer bacak GND / button, other leg to GND
5#define NUM_LEDS    100    // şeritteki LED sayısı / number of LEDs on the strip
6
7Adafruit_NeoPixel strip(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
8
9const uint8_t MODE_COUNT = 3;                          // 0 gökkuşağı, 1 kar, 2 yıldız / 0 rainbow, 1 snow, 2 twinkle
10const uint16_t FRAME_MS[MODE_COUNT] = {20, 60, 30};    // kare süreleri (ms) / frame times (ms)
11const uint8_t PALETTE[4][3] = {{255, 0, 0}, {0, 255, 0}, {255, 160, 0}, {255, 255, 255}};
12
13uint8_t level[NUM_LEDS];      // LED başına parlaklık / per-LED level
14uint8_t colorIdx[NUM_LEDS];   // yıldız rengi / star colour index
15uint8_t mode = 0;
16uint16_t hue = 0;
17
18void setup() {
19  pinMode(BUTTON_PIN, INPUT_PULLUP);
20  strip.begin();
21  strip.setBrightness(110);   // genel parlaklık / global brightness
22  strip.clear();
23  strip.show();
24}
25
26void checkButton() {
27  static bool lastState = HIGH;
28  static unsigned long lastChange = 0;
29  bool state = digitalRead(BUTTON_PIN);
30  if (state != lastState && millis() - lastChange > 50) {  // 50 ms zıplama filtresi / 50 ms debounce
31    lastChange = millis();
32    lastState = state;
33    if (state == LOW) {                                     // basıldı / pressed
34      mode = (mode + 1) % MODE_COUNT;
35      memset(level, 0, sizeof(level));                      // efekt belleğini sıfırla / reset effect buffer
36      strip.clear();
37    }
38  }
39}
40
41void rainbow() {
42  for (int i = 0; i < NUM_LEDS; i++) {
43    uint16_t h = hue + (uint32_t)i * 65536UL / NUM_LEDS;   // LED'e göre ton / hue per LED
44    strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(h)));
45  }
46  hue += 256;                                              // renkler döner / colours rotate
47}
48
49void snowfall() {
50  for (int i = 0; i < NUM_LEDS - 1; i++) level[i] = level[i + 1];   // bir LED aşağı kaydır / shift one LED down
51  level[NUM_LEDS - 1] = (random(100) < 15) ? 255 : 0;               // tepede yeni kar / new flake on top
52  for (int i = 0; i < NUM_LEDS; i++) {
53    if (level[i]) strip.setPixelColor(i, 255, 255, 255);            // kar tanesi / snowflake
54    else strip.setPixelColor(i, 0, 0, 24);                          // koyu mavi gece / dark blue night
55  }
56}
57
58void twinkle() {
59  for (int i = 0; i < NUM_LEDS; i++) {
60    level[i] = (level[i] > 12) ? level[i] - 12 : 0;                 // yavaşça sön / fade out
61  }
62  if (random(100) < 30) {
63    int p = random(NUM_LEDS);
64    level[p] = 255;                                                 // yeni yıldız / new star
65    colorIdx[p] = random(4);
66  }
67  for (int i = 0; i < NUM_LEDS; i++) {
68    const uint8_t *c = PALETTE[colorIdx[i]];
69    strip.setPixelColor(i, c[0] * level[i] / 255, c[1] * level[i] / 255, c[2] * level[i] / 255);
70  }
71}
72
73void loop() {
74  checkButton();
75  static unsigned long lastFrame = 0;
76  if (millis() - lastFrame >= FRAME_MS[mode]) {
77    lastFrame = millis();
78    if (mode == 0) rainbow();
79    else if (mode == 1) snowfall();
80    else twinkle();
81    strip.show();                                                   // renkleri şeride gönder / push colours to the strip
82  }
83}

Sapin de Noël avec Raspberry Pi Pico et MicroPython

Dans le firmware MicroPython du Raspberry Pi Pico, le module neopixel est fourni d'origine ; tu n'as rien d'autre à installer. Comme le module gère lui-même le timing précis du WS2812B, tu peux utiliser n'importe quelle broche GP ; ci-dessous, les données sont sur GP0 et le bouton sur GP15. Comme MicroPython n'a pas de réglage de luminosité global, nous atténuons nous-mêmes les couleurs avec le coefficient BRIGHT. Python étant plus lent que le C++, les effets restent fluides avec 100 LED ; au-delà de 300 LED, les durées d'image peuvent s'allonger. Si tu débutes avec MicroPython, tu peux commencer par l'article Bases de MicroPython.

1from machine import Pin
2import neopixel, time, random
3
4NUM_LEDS = 100
5BRIGHT = 0.4                                   # 0-1 parlaklık / brightness
6np = neopixel.NeoPixel(Pin(0), NUM_LEDS)       # veri GP0 / data on GP0
7button = Pin(15, Pin.IN, Pin.PULL_UP)          # buton GP15-GND / button GP15-GND
8
9mode = 0
10MODE_COUNT = 3                                 # 0 gökkuşağı, 1 kar, 2 yıldız / 0 rainbow, 1 snow, 2 twinkle
11FRAME_MS = (20, 60, 30)                        # kare süreleri / frame times
12level = [0] * NUM_LEDS                         # LED başına parlaklık / per-LED level
13color_idx = [0] * NUM_LEDS                     # yıldız rengi / star colour index
14PALETTE = ((255, 0, 0), (0, 255, 0), (255, 160, 0), (255, 255, 255))
15hue = 0
16
17def scale(r, g, b):
18    return (int(r * BRIGHT), int(g * BRIGHT), int(b * BRIGHT))
19
20def wheel(pos):
21    # 0-255 -> gökkuşağı rengi / rainbow colour
22    pos = pos & 255
23    if pos < 85:
24        return (255 - pos * 3, pos * 3, 0)
25    if pos < 170:
26        pos -= 85
27        return (0, 255 - pos * 3, pos * 3)
28    pos -= 170
29    return (pos * 3, 0, 255 - pos * 3)
30
31def rainbow():
32    global hue
33    for i in range(NUM_LEDS):
34        np[i] = scale(*wheel(hue + i * 256 // NUM_LEDS))
35    hue = (hue + 2) & 255                      # renkler döner / colours rotate
36
37def snowfall():
38    for i in range(NUM_LEDS - 1):
39        level[i] = level[i + 1]                # bir LED aşağı kaydır / shift one LED down
40    level[-1] = 255 if random.randint(0, 99) < 15 else 0
41    for i in range(NUM_LEDS):
42        np[i] = scale(255, 255, 255) if level[i] else scale(0, 0, 24)
43
44def twinkle():
45    for i in range(NUM_LEDS):
46        level[i] = level[i] - 12 if level[i] > 12 else 0   # yavaşça sön / fade out
47    if random.randint(0, 99) < 30:
48        p = random.randint(0, NUM_LEDS - 1)
49        level[p] = 255                         # yeni yıldız / new star
50        color_idx[p] = random.randint(0, 3)
51    for i in range(NUM_LEDS):
52        r, g, b = PALETTE[color_idx[i]]
53        k = level[i] * BRIGHT / 255
54        np[i] = (int(r * k), int(g * k), int(b * k))
55
56effects = (rainbow, snowfall, twinkle)
57last_btn = 1
58last_change = time.ticks_ms()
59last_frame = time.ticks_ms()
60
61while True:
62    now = time.ticks_ms()
63    state = button.value()
64    if state != last_btn and time.ticks_diff(now, last_change) > 50:   # zıplama filtresi / debounce
65        last_change = now
66        last_btn = state
67        if state == 0:                         # basıldı / pressed
68            mode = (mode + 1) % MODE_COUNT
69            for i in range(NUM_LEDS):
70                level[i] = 0
71    if time.ticks_diff(now, last_frame) >= FRAME_MS[mode]:
72        last_frame = now
73        effects[mode]()
74        np.write()                             # şeride gönder / push to the strip

Installer le ruban sur le sapin et sécurité

• Commence par le bas : place l'extrémité DIN du ruban au pied du sapin, près du boîtier de contrôle, et enroule le ruban en spirale vers le haut. Ainsi l'effet de neige coule du haut vers le bas et le câble de données reste court.
• Espacement de la spirale : sur un sapin de 1,8 m, un enroulement espacé de 20 à 25 cm répartit équitablement un ruban de 5 m sur les branches ; comme le diamètre des tours diminue vers le sommet, tu peux resserrer un peu l'espacement.
• Bandes verticales : tu peux aussi poser le ruban en zigzag, du haut vers le bas puis du bas vers le haut. Avec cette disposition, le sens de l'effet de neige s'inverse une bande sur deux ; il faut donc faire un petit ajustement qui calcule l'ordre des LED selon le numéro de bande.
• Chaleur : le ruban WS2812B chauffe à forte luminosité ; ne le presse pas fermement contre des décorations en papier ou des branches sèches. Garder la luminosité autour de 100 à 150 réduit à la fois la chaleur et le courant.
• Sécurité de l'alimentation : ne construis pas ton propre circuit côté 220 V ; utilise une alimentation 5 V toute faite, marquée CE et sous boîtier fermé. Garde le boîtier de contrôle à l'écart de l'eau et de l'arrosage du pot, et éteins le sapin quand tu quittes la maison.
• Fusible : sur les systèmes de plus de 5 A, ajouter un fusible lame de valeur adaptée à la sortie de l'alimentation est une bonne protection contre un éventuel court-circuit.

Idées de projets pour le sapin de Noël

• Sapin sensible à la musique : allume les lumières au rythme de la chanson avec un microphone ; les détails sont dans l'article LED sensible à la musique.
• Compte à rebours du Nouvel An : affiche le temps restant jusqu'à minuit sur un écran et lance un effet de feu d'artifice sur le sapin à 00:00 ; jette un oeil à l'article compteur de compte à rebours du Nouvel An.
• Sapin qui s'allume tout seul : allume automatiquement les lumières à la tombée de la nuit avec une photorésistance LDR.
• Sapin qui brille quand on approche : augmente la luminosité quand quelqu'un entre dans la pièce avec un capteur de mouvement PIR et baisse-la quand la pièce est vide.
• Contrôle depuis le téléphone : ouvre une page web avec l'ESP32 et choisis les effets et les couleurs depuis ton téléphone ; l'article serveur web ESP32 est un bon point de départ.
• Écran de l'étoile du sommet : place une petite matrice LED WS2812B au sommet du sapin et joue une animation d'étoile ou de flocon.

Erreurs fréquentes et solutions

Avec quelques mètres de ruban LED, un seul bouton et une alimentation 5 V bien dimensionnée, ton sapin de Noël devient un spectacle lumineux programmable que tu peux renouveler chaque année avec de nouveaux effets. Tu peux concevoir tes propres effets en jouant avec les palettes de couleurs et les durées d'image, et pour tes questions sur l'alimentation et le câblage, tu peux retourner au guide alimentation Arduino. Dans l'application BlueGrays, tu trouveras pas à pas, avec schémas et codes, des projets de LED chenillard, de scanner Knight Rider, de gyrophare de police et d'animations avec WS2812B, ainsi que le contrôle d'un ruban NeoPixel avec l'ESP32.