LED adressables WS2812B

En bref

Les WS2812B se pilotent avec très peu de fils, mais elles réclament une alimentation sérieuse. Une mauvaise alimentation est la cause de la grande majorité des pannes.

Câblage

• Branche toujours les masses en premier et garde une masse commune entre l’alimentation, l’ESP32 et le bandeau.
• Mets une résistance de 300 à 500 Ω en série sur le fil de données, au plus près du premier pixel : elle limite les pics à la mise sous tension.
• Utilise le connecteur DIN, pas DOUT : le signal circule dans un seul sens. Les flèches imprimées sur le bandeau indiquent le sens.
• Un condensateur de 1 000 µF (au moins 6,3 V) entre 5 V et GND, près de l’entrée du bandeau, absorbe les appels de courant.

Alimentation

Chaque LED peut tirer jusqu’à 60 mA. Trente LEDs allumées en blanc à pleine puissance font 1,8 A ; ce n’est pas l’affaire d’un port USB d’ordinateur (500 mA). Le calculateur de consommation vous donne l’alimentation à prévoir.

• Sur un long bandeau, la tension baisse le long du cuivre : les dernières LEDs deviennent rougeâtres. Injecte l’alimentation aux deux bouts (voire au milieu) pour un bandeau de plus d’une soixantaine de LEDs à forte luminosité.
• Niveau logique : la puce lit un état haut à partir d’environ 0,7 × VDD, soit 3,5 V sous 5 V. Le 3,3 V d’un ESP32 marche souvent sur un bandeau court, mais c’est limite. Un convertisseur de niveau (74AHCT125, 74HCT245) rend le montage fiable.
• Ne branche pas votre ESP32 sur le 5 V du bandeau sans y penser : alimente l’ESP32 par son USB ou une sortie 5 V régulée, et relie seulement les masses.

Protocole

Le fil de données transporte une suite de bits à 800 kbit/s. Chaque bit dure environ 1,25 µs et se distingue par la durée de l’état haut. Une LED lit 24 bits (vert, rouge, bleu, huit bits chacun, poids fort en premier), puis laisse passer les suivants vers la LED suivante. Une pause de plus de 50 µs (jusqu’à 280 µs sur les versions récentes) verrouille l’affichage.

Ces durées sont trop courtes pour un simple digitalWrite : les bibliothèques utilisent un périphérique matériel de l’ESP32 (RMT) ou du code cadencé très précisément. vous n’as rien à faire, mais vous ne devez pas bloquer les interruptions longtemps pendant l’envoi.

Le temps d’envoi est proportionnel au nombre de LEDs : 30 µs par LED. Pour 144 LEDs : 4,3 ms, soit environ 200 images par seconde au maximum.

RGB / GRB

Le bandeau attend les octets dans l’ordre G, R, B. Certains modèles (WS2811, clones) utilisent RGB ou BRG. Les bibliothèques vous laissent déclarer l’ordre pour que CRGB(255, 0, 0) reste du rouge. Si les couleurs sont fausses, c’est presque toujours cet ordre qu’il faut corriger.

Bibliothèques

Les deux s’installent depuis le gestionnaire de bibliothèques de l’IDE Arduino. N’en utilise qu’une par programme. Le générateur plus bas produit le code pour l’une ou l’autre.

Luminosité

La luminosité globale (0 à 255) se règle avec FastLED.setBrightness() ou strip.setBrightness(). Elle met à l’échelle toutes les couleurs, donc aussi le courant. À 50 % de luminosité, un bandeau tire à peu près moitié moins.

• Pendant les tests, commencez à 30 ou 40 : vous évitez de surcharger l’alimentation et de vous éblouir.
• Avec NeoPixel, setBrightness() modifie les couleurs déjà stockées : réécris les couleurs à chaque image plutôt que de l’appeler plusieurs fois.
• L’œil perçoit la lumière de façon non linéaire : une luminosité de 128 paraît nettement plus que « la moitié » de 255.

Animations

Le bandeau virtuel réagit comme un vrai : clique sur une LED pour la sélectionner, choisis sa couleur, règle la luminosité, puis passe en animation. Le nombre de LEDs, la vitesse et la couleur de base se règlent en direct.

Export du code

Le code suit exactement les réglages du bandeau virtuel ci-dessus : nombre de LEDs, luminosité, animation, vitesse et couleur.

// Le code apparaît ici.

/*
 * Test des couleurs WS2812B — Kaihatsu Lab
 * Affiche rouge, vert, bleu puis blanc, une seconde chacun. Bibliothèque : Adafruit NeoPixel.
 *
 * Si le bandeau montre du vert quand le code demande du rouge, l'ordre des couleurs est faux :
 * remplace NEO_GRB par NEO_RGB ou NEO_BRG jusqu'à ce que la séquence soit rouge, vert, bleu.
 */
#include <Adafruit_NeoPixel.h>

const uint8_t  PIN_LED  = 5;
const uint16_t NUM_LEDS = 30;

Adafruit_NeoPixel strip(NUM_LEDS, PIN_LED, NEO_GRB + NEO_KHZ800);

void showColor(uint8_t r, uint8_t g, uint8_t b) {
  strip.fill(strip.Color(r, g, b));
  strip.show();
  delay(1000);
}

void setup() {
  strip.begin();
  strip.setBrightness(40);        // luminosité basse : pas de risque pour l'alimentation pendant les essais
  strip.show();                   // éteint tout
}

void loop() {
  showColor(255, 0, 0);           // rouge
  showColor(0, 255, 0);           // vert
  showColor(0, 0, 255);           // bleu
  showColor(255, 255, 255);       // blanc
}

Ce petit sketch de test montre rouge, vert, bleu puis blanc : vous vérifiez l’ordre des couleurs avant de lancer une animation.

Matrices

Une matrice est un bandeau replié : les LEDs restent en une seule chaîne, mais on les repère par leurs coordonnées (x, y). Le plus souvent, la matrice est câblée en serpentin : une ligne de gauche à droite, la suivante de droite à gauche. Une fonction XY(x, y) fait la conversion.

/*
 * Matrice WS2812B : conversion (x, y) vers numéro de LED — Kaihatsu Lab
 * Fonctionne avec une matrice câblée en serpentin (le plus courant) ou en lignes parallèles.
 * Bibliothèque : FastLED.
 *
 * Origine (0, 0) : coin en haut à gauche, x vers la droite, y vers le bas.
 */
#include <FastLED.h>

#define LED_PIN     5
#define WIDTH       8
#define HEIGHT      8
#define NUM_LEDS    (WIDTH * HEIGHT)
#define SERPENTINE  true            // true : une ligne sur deux est parcourue à l'envers

CRGB leds[NUM_LEDS + 1];            // une LED de plus : « poubelle » pour les points hors matrice

uint16_t XY(int x, int y) {
  if (x < 0 || x >= WIDTH || y < 0 || y >= HEIGHT) return NUM_LEDS;   // hors matrice
  if (SERPENTINE && (y & 1)) x = WIDTH - 1 - x;                        // lignes impaires à l'envers
  return y * WIDTH + x;
}

void setup() {
  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
  FastLED.setBrightness(40);
}

void loop() {
  static uint8_t hue = 0;
  for (int y = 0; y < HEIGHT; y++) {
    for (int x = 0; x < WIDTH; x++) {
      leds[XY(x, y)] = CHSV(hue + (x + y) * 16, 255, 255);            // arc-en-ciel en diagonale
    }
  }
  FastLED.show();
  hue += 2;
  delay(30);
}

Consommation

Le courant maximal théorique est de 60 mA par LED (blanc pleine puissance). En pratique, une animation colorée reste bien en dessous. Prévoyez une alimentation dimensionnée pour le pire cas que vous acceptez, avec 20 % de marge.

Avec FastLED, FastLED.setMaxPowerInVoltsAndMilliamps(5, 1000) plafonne automatiquement la luminosité pour ne pas dépasser 1 A.

Dépannage

Projets

Idées à construire

• Lampe d’ambiance pilotée par un potentiomètre ou une page web.
• Horloge en anneau de LEDs.
• Indicateur de niveau : une barre qui monte avec une mesure (distance, température).
• Petit écran de pixels 8×8 avec la fonction XY de ce guide.
• Éclairage réactif au son avec un microphone.

Le PCB et les composants pour reproduire les projets arriveront avec la boutique. Être prévenu