Ruban LED WS2812B NeoPixel avec Arduino : guide des LED RGB adressables

La WS2812B est une LED RGB qui intègre sa propre puce de commande. Alors qu'une LED RGB ordinaire demande une broche par couleur, avec la WS2812B tu pilotes des centaines de LED avec un seul fil de données et tu donnes à chacune sa propre couleur et sa propre luminosité. NeoPixel est le nom qu'Adafruit donne à cette famille de LED adressables. Vendues en rubans, anneaux, barrettes et matrices, elles se retrouvent dans d'innombrables projets, de l'éclairage d'ambiance aux horloges LED, en passant par les jeux et les lampes de notification.

Comment fonctionne la WS2812B ?

Dans le boîtier de 5x5 mm de chaque WS2812B se trouvent trois minuscules LED, rouge, verte et bleue, ainsi qu'une petite puce qui les pilote. L'Arduino envoie sur la ligne de données des paquets de couleur de 24 bits à la suite : 8 bits de vert, 8 de rouge et 8 de bleu (ordre GRB). La première LED garde les 24 premiers bits pour elle et transmet le reste à la LED suivante par sa broche DO ; chaque LED fait de même. Quand la ligne de données reste à LOW au moins 50 microsecondes (280 sur les versions récentes), toutes les LED affichent leur couleur au même instant. Avec 256 niveaux par couleur, une seule LED peut afficher 16,7 millions de couleurs.

Rubans, anneaux et matrices

Câblage de la WS2812B

La WS2812B a trois connexions : 5V, GND et DIN (entrée de données). Les flèches sur le ruban indiquent le sens des données ; branche toujours l'Arduino à l'extrémité où commencent les flèches, côté DIN. Une résistance de 330–470 Ω en série sur la ligne de données et un condensateur de 1000 µF entre 5V et GND à l'entrée d'alimentation du ruban protègent la première LED des pics de tension soudains.

Calcul de puissance : combien d'ampères faut-il ?

La formule du pire cas est simple : nombre de LED × 60 mA. Dans les animations, il est rare que toutes les LED soient en blanc plein en même temps ; en pratique, on observe en moyenne environ 20 mA par LED. Il faut néanmoins choisir l'alimentation pour le pire cas ou limiter la luminosité par logiciel. Pour calculer la puissance en watts, utilise l'outil Loi d'Ohm, et pour estimer la durée de fonctionnement d'un projet sur batterie, l'outil Autonomie batterie.

Premier code avec la bibliothèque Adafruit NeoPixel

Dans le gestionnaire de bibliothèques, cherche Adafruit NeoPixel et installe-la. Le code ci-dessous « balaie » le ruban d'une couleur en allumant les LED une par une en rouge, vert et bleu :

1#include <Adafruit_NeoPixel.h>
2
3#define PIN 6          // DIN pini / data pin
4#define NUM_LEDS 8     // LED sayısı / number of LEDs
5
6Adafruit_NeoPixel strip(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);
7
8void setup() {
9  strip.begin();
10  strip.setBrightness(50);   // 0–255, yalnız bir kez / only once
11  strip.show();              // hepsini söndür / all off
12}
13
14void colorWipe(uint32_t color, int wait) {
15  for (int i = 0; i < NUM_LEDS; i++) {
16    strip.setPixelColor(i, color);
17    strip.show();            // değişikliği gönder / send the change
18    delay(wait);
19  }
20}
21
22void loop() {
23  colorWipe(strip.Color(255, 0, 0), 80);   // kırmızı / red
24  colorWipe(strip.Color(0, 255, 0), 80);   // yeşil / green
25  colorWipe(strip.Color(0, 0, 255), 80);   // mavi / blue
26}

setPixelColor() ne change que la couleur en mémoire ; pour que les LED s'allument vraiment, il faut appeler show(). Tu peux ainsi régler la couleur de toutes les LED puis les afficher d'un coup. Comme setBrightness() modifie définitivement les données de couleur, mieux vaut l'appeler une fois dans setup() plutôt que de la changer sans cesse dans loop(). Chaque LED occupe 3 octets de la RAM de l'Arduino ; les 2 Ko de l'Uno se remplissent vite avec des centaines de LED.

Effet arc-en-ciel : les couleurs HSV

Plutôt que de régler les couleurs avec des valeurs de rouge, vert et bleu, utiliser HSV (teinte, saturation, luminosité) simplifie énormément les effets : tu parcours tout le cercle chromatique en changeant seulement la teinte. Dans la bibliothèque Adafruit, la teinte va de 0 à 65535. gamma32() corrige les couleurs selon la perception de l'œil pour que les transitions paraissent plus naturelles :

1#include <Adafruit_NeoPixel.h>
2
3#define PIN 6
4#define NUM_LEDS 24
5
6Adafruit_NeoPixel strip(NUM_LEDS, PIN, NEO_GRB + NEO_KHZ800);
7
8void setup() {
9  strip.begin();
10  strip.setBrightness(40);
11}
12
13void loop() {
14  for (long first = 0; first < 65536; first += 256) {
15    for (int i = 0; i < NUM_LEDS; i++) {
16      uint16_t hue = first + i * 65536L / NUM_LEDS;   // her LED'e farklı ton / a different hue per LED
17      strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(hue)));
18    }
19    strip.show();
20    delay(10);
21  }
22}

La bibliothèque FastLED

Pour des effets plus avancés, la bibliothèque FastLED est elle aussi très populaire. Elle stocke les LED dans un tableau CRGB, propose des commandes très lisibles comme leds[3] = CRGB::Red; et utilise une plage de teinte de 0 à 255. Ses fonctions toutes prêtes, comme fill_rainbow() et fadeToBlackBy(), permettent d'écrire des effets de feu, d'étoile filante ou de respiration en quelques lignes. L'une de ses fonctions les plus pratiques est FastLED.setMaxPowerInVoltsAndMilliamps(5, 2000); : la bibliothèque baisse automatiquement la luminosité pour garder le courant sous 2 A.

Utiliser une matrice NeoPixel 8x8

Une matrice n'est en fait qu'un long ruban : 64 LED chaînées les unes après les autres sur une seule ligne de données. Sur la plupart des matrices, les lignes sont disposées en zigzag (serpentin) : les lignes paires vont de gauche à droite, les impaires de droite à gauche. Pour convertir une coordonnée x, y en numéro de LED, on utilise donc y × 8 + x sur les lignes paires et y × 8 + (7 − x) sur les impaires. Comme 64 LED peuvent consommer 3,8 A en blanc plein, garder une luminosité faible est particulièrement important sur les matrices.

La WS2812B avec l'ESP32 et le Raspberry Pi Pico

Les bibliothèques Adafruit NeoPixel et FastLED fonctionnent aussi sur l'ESP32 ; grâce au Wi-Fi, il est très simple de piloter les LED depuis ton téléphone ou de créer une lampe qui change de couleur selon la météo. Le point à surveiller est le niveau de tension : une WS2812B alimentée en 5 V attend au moins 3,5 V sur son entrée de données, alors que l'ESP32 et le Pico fournissent 3,3 V. La plupart des rubans fonctionnent quand même, mais si la première LED scintille ou si des couleurs aléatoires apparaissent, ajoute un adaptateur de niveau comme le 74AHCT125 sur la ligne de données. Sur le Raspberry Pi Pico, MicroPython intègre déjà le module neopixel :

1from machine import Pin
2import neopixel
3import time
4
5NUM = 8
6np = neopixel.NeoPixel(Pin(0), NUM)      # GP0 → DIN
7
8def wheel(pos):                          # 0–255 → renk çemberi / colour wheel
9    if pos < 85:
10        return (255 - pos * 3, pos * 3, 0)
11    if pos < 170:
12        pos -= 85
13        return (0, 255 - pos * 3, pos * 3)
14    pos -= 170
15    return (pos * 3, 0, 255 - pos * 3)
16
17j = 0
18while True:
19    for i in range(NUM):
20        r, g, b = wheel((i * 256 // NUM + j) & 255)
21        np[i] = (r // 5, g // 5, b // 5)  # parlaklığı düşür / dim it
22    np.write()
23    j = (j + 2) & 255
24    time.sleep_ms(20)

Idées de projets avec la WS2812B

• Éclairage d'ambiance pour la TV : colle un ruban derrière le téléviseur pour baigner la pièce d'une lumière douce.
• Horloge NeoPixel : affiche heures, minutes et secondes de couleurs différentes sur un anneau de 60 LED.
• Vumètre : avec un module micro, crée une barre de LED qui monte avec le volume de la musique.
• Lampe de notification : change de couleur avec l'ESP32 selon la météo ou les e-mails reçus par internet.
• Gyrophare et K 2000 : programme des clignotements rouge-bleu ou un balayage lumineux aller-retour.
• Jeu du serpent : recrée le jeu du serpent classique avec une matrice 8x8 et un joystick.

Erreurs fréquentes et solutions

• Aucune LED ne s'allume : l'Arduino est branché à la mauvaise extrémité du ruban, côté DOUT ; regarde les flèches et utilise l'extrémité DIN.
• Les couleurs sont inversées (vert au lieu de rouge) : l'ordre des couleurs est faux ; utilise NEO_GRB dans le code, certains rubans demandent NEO_RGB.
• La première LED scintille ou affiche des couleurs aléatoires : il manque la résistance série, la masse n'est pas commune ou le signal de données en 3,3 V ne suffit pas.
• La fin du ruban paraît jaunâtre : il y a une chute de tension ; alimente le ruban en plusieurs points ou baisse la luminosité.
• L'Arduino redémarre quand les LED s'allument : trop de courant est tiré sur l'USB ; utilise une alimentation externe et un condensateur de 1000 µF.
• Seules les premières LED s'allument : la valeur NUM_LEDS du code est inférieure au nombre réel de LED, ou une connexion est coupée quelque part sur le ruban.

La WS2812B est un excellent point de départ pour comprendre comment les couleurs se mélangent ; tu trouveras la logique des couleurs dans Utiliser une LED RGB et le réglage de la luminosité dans Qu'est-ce que le PWM ? Dans l'application BlueGrays, tu trouveras des projets de prise en main de la WS2812B, de gyrophare, de chenillard, d'effet K 2000, d'animations et de pilotage de ruban NeoPixel avec l'ESP32, avec schémas et code.