Matrice LED NeoPixel Arduino : guide panneau WS2812B 8x8 et 16x16

La matrice NeoPixel est l'un des affichages les plus spectaculaires que tu puisses monter avec Arduino : 8x8 (64 LED) ou 16x16 (256 LED) LED RGB adressables WS2812B disposées sur un panneau, avec la couleur de chaque pixel réglée séparément par un seul fil de données. Elle est idéale pour les textes défilants, les icônes, les petits jeux, les spectres audio et les animations décoratives. Dans ce guide, tu vas découvrir pas à pas l'ordre en zigzag du panneau, la fonction qui convertit les coordonnées x-y en numéro de LED, le texte défilant et les animations.

Travailler avec une matrice demande un peu plus d'attention qu'avec un simple ruban NeoPixel. 256 LED à pleine luminosité peuvent consommer plus de 15 ampères, les 2 Ko de RAM de l'Arduino Uno se remplissent vite avec les grands panneaux, et la sortie 3,3 V de l'ESP32 et du Pico peut poser problème sur certains panneaux. Nous verrons donc aussi le calcul du courant, la limitation de luminosité et la gestion de la mémoire. Si tu ne connais pas encore les bases du WS2812B, commence par l'article LED NeoPixel WS2812B.

Qu'est-ce qu'une matrice LED NeoPixel et comment fonctionne-t-elle ?

Chaque LED WS2812B contient des puces rouge, verte et bleue, ainsi qu'un petit circuit de commande intégré. Le microcontrôleur envoie sur la ligne de données, à 800 kHz, 24 bits de couleur par LED, dans l'ordre vert, rouge, bleu (GRB). La première LED prend les 24 premiers bits et transmet le reste par sa sortie DOUT à la suivante, et ainsi de suite. Sur un panneau, c'est pareil : les 64 ou 256 LED forment en fait un long ruban replié en carré. Envoyer les données d'une LED prend environ 30 microsecondes ; mettre à jour un panneau de 256 LED prend donc environ 7,7 ms, soit plus de 100 images par seconde pour des animations fluides.

Disposition des pixels en zigzag et fonction de coordonnées XY

Dans le code, tu veux penser à un pixel avec ses coordonnées (x, y), mais les LED sont adressées par un seul numéro d'ordre à partir de 0. Sur presque tous les panneaux flexibles et sur les modèles 16x16, les LED sont disposées en zigzag (serpentin) : la première ligne va de gauche à droite, la deuxième revient de droite à gauche, la troisième repart de gauche à droite. Cette disposition simplifie la fabrication, car la fin de chaque ligne se relie au début de la suivante par le chemin le plus court. Le tableau ci-dessous montre les numéros de LED des quatre premières lignes d'un panneau 8x8 en zigzag :

La formule en découle d'elle-même : pour les lignes paires, indice = y × W + x ; pour les lignes impaires, indice = y × W + (W − 1 − x), où W est la largeur du panneau. Par exemple, sur un panneau 8x8, le point (2, 1) correspond à la LED 1 × 8 + (7 − 2) = 13. Attention : sur certaines cartes 8x8 à PCB rigide, toutes les lignes vont dans le même sens (disposition progressive) ; la formule devient alors simplement y × W + x. Sur d'autres panneaux, les LED serpentent le long des colonnes au lieu des lignes, donc x et y doivent être échangés. Le moyen le plus sûr de connaître ton type de panneau est d'exécuter un code de test qui allume les LED une par une et d'observer le parcours de la lumière.

Branchement de la matrice NeoPixel : Arduino Uno, ESP32 et Pico

Pour un montage fiable, ajoute trois petits composants : une résistance de 300–500 Ω en série sur la ligne de données (elle protège l'entrée de la première LED contre les pics de tension), un condensateur électrolytique d'environ 1000 µF entre le 5V et le GND du panneau (il amortit l'appel de courant à la mise sous tension) et, si nécessaire, un convertisseur de niveau pour les cartes 3,3 V. Avec une alimentation de 5 V, le WS2812B veut voir au moins environ 3,5 V sur l'entrée de données (70 % de la tension d'alimentation) ; la sortie 3,3 V de l'ESP32 et du Pico fonctionne sur la plupart des panneaux, mais reste sous cette limite. Si tu vois du scintillement ou des couleurs aléatoires, utilise un circuit tampon comme le 74AHCT125 ; tu trouveras les détails dans l'article sur le convertisseur de niveau logique.

Premier programme de matrice pas à pas (Arduino Uno)

1. Dans l'IDE Arduino, ouvre le gestionnaire de bibliothèques et installe la bibliothèque Adafruit NeoPixel.
2. Branche le panneau selon le tableau : DIN à D6 avec une résistance de 330 Ω, GND au GND de l'Arduino, 5V à l'alimentation.
3. Règle les valeurs W et H du code selon la taille du panneau ; pour un 16x16, mets les deux à 16.
4. Au premier essai, garde une luminosité faible ; setBrightness(30) ramène le courant d'un panneau 8x8 à un niveau que l'USB peut supporter.
5. Téléverse le code ; tu dois voir un arc-en-ciel diagonal en mouvement. Si les couleurs paraissent hachées ligne par ligne, la disposition de ton panneau est différente : corrige la fonction xyIndex en conséquence.

1#include <Adafruit_NeoPixel.h>
2
3#define PIN_DATA 6                 // DIN pini (330 ohm ile) / DIN pin (via 330 ohm)
4#define W 8                        // panel genişliği / panel width
5#define H 8                        // panel yüksekliği / panel height
6#define NUM_LEDS (W * H)
7
8Adafruit_NeoPixel strip(NUM_LEDS, PIN_DATA, NEO_GRB + NEO_KHZ800);
9
10// (x, y) koordinatını LED numarasına çevirir (zikzak) / converts (x, y) to LED index (serpentine)
11uint16_t xyIndex(uint8_t x, uint8_t y) {
12  if (y & 1) {
13    return y * W + (W - 1 - x);    // tek satırlar sağdan sola / odd rows run right to left
14  }
15  return y * W + x;                // çift satırlar soldan sağa / even rows run left to right
16}
17
18void setup() {
19  strip.begin();
20  strip.setBrightness(30);         // 0-255, düşük tut / keep it low
21  strip.clear();
22  strip.show();
23}
24
25void loop() {
26  static uint16_t hueBase = 0;
27  for (uint8_t y = 0; y < H; y++) {
28    for (uint8_t x = 0; x < W; x++) {
29      uint16_t hue = hueBase + (x + y) * 4096U;   // çapraz gökkuşağı / diagonal rainbow
30      strip.setPixelColor(xyIndex(x, y), strip.gamma32(strip.ColorHSV(hue)));
31    }
32  }
33  strip.show();                    // tamponu panele gönder / push the buffer to the panel
34  hueBase += 256;                  // renkleri kaydır / shift the colors
35  delay(20);
36}

Le cœur du code est la fonction xyIndex() : elle masque le zigzag en inversant x sur les lignes impaires, si bien que dans le reste du code tu ne raisonnes plus qu'en coordonnées. ColorHSV() convertit en RGB une teinte de 0 à 65535 sur le cercle chromatique ; comme la teinte glisse quand la somme x + y augmente, on obtient des bandes de couleur diagonales. gamma32() corrige selon la perception de la luminosité par l'œil et rend les dégradés plus naturels. Enfin, tant que show() n'est pas appelé, rien n'est envoyé au panneau ; écrire d'abord tous les pixels en mémoire puis les envoyer d'un coup est le secret d'un affichage fluide.

Texte défilant avec Adafruit NeoMatrix

Pour dessiner des lettres et des icônes, pas besoin de t'occuper de chaque pixel. La bibliothèque Adafruit NeoMatrix transforme ton panneau NeoPixel en un écran compatible Adafruit GFX ; les fonctions que tu utilises sur les écrans OLED, comme print(), drawLine(), fillRect() et drawBitmap(), fonctionnent donc aussi sur la matrice. Quand tu installes Adafruit NeoMatrix depuis le gestionnaire de bibliothèques, installe aussi les dépendances Adafruit GFX et Adafruit NeoPixel. Les drapeaux du constructeur décrivent la disposition physique du panneau : NEO_MATRIX_TOP + NEO_MATRIX_LEFT indique que la première LED est en haut à gauche, NEO_MATRIX_ROWS que les LED suivent les lignes, et NEO_MATRIX_ZIGZAG que les lignes alternent en zigzag ; sur une carte à disposition simple, il suffit d'écrire NEO_MATRIX_PROGRESSIVE à la place de ZIGZAG. La police 5×7 par défaut s'adapte parfaitement à un panneau de 8 lignes, et chaque caractère, espace compris, fait 6 pixels de large. Un texte de neuf lettres fait 54 pixels ; la constante textWidth le calcule automatiquement, et quand x passe en dessous de cette valeur, le texte rentre de nouveau par la droite en changeant de couleur.

1#include <Adafruit_GFX.h>
2#include <Adafruit_NeoMatrix.h>
3#include <Adafruit_NeoPixel.h>
4
5#define PIN_DATA 6
6
7// 8x8 panel, ilk LED sol üstte, zikzak satırlar / 8x8 panel, first LED top-left, zigzag rows
8Adafruit_NeoMatrix matrix(8, 8, PIN_DATA,
9  NEO_MATRIX_TOP + NEO_MATRIX_LEFT + NEO_MATRIX_ROWS + NEO_MATRIX_ZIGZAG,
10  NEO_GRB + NEO_KHZ800);
11
12const char text[] = "BlueGrays";
13const int textWidth = (sizeof(text) - 1) * 6;   // karakter başına 6 piksel / 6 pixels per character
14int x = 8;                                      // yazı sağ kenardan başlar / text starts at the right edge
15uint8_t colorStep = 0;
16
17void setup() {
18  matrix.begin();
19  matrix.setTextWrap(false);       // satır kaydırma kapalı / no line wrap
20  matrix.setBrightness(40);
21  matrix.setTextColor(matrix.Color(255, 0, 0));
22}
23
24void loop() {
25  matrix.fillScreen(0);
26  matrix.setCursor(x, 0);
27  matrix.print(text);
28  if (--x < -textWidth) {          // yazı panelden tamamen çıktı / text fully left the panel
29    x = matrix.width();
30    colorStep = (colorStep + 1) % 3;
31    if (colorStep == 0) matrix.setTextColor(matrix.Color(255, 0, 0));
32    if (colorStep == 1) matrix.setTextColor(matrix.Color(0, 255, 0));
33    if (colorStep == 2) matrix.setTextColor(matrix.Color(0, 0, 255));
34  }
35  matrix.show();
36  delay(80);                       // kayma hızı / scroll speed
37}

La limite de mémoire de l'Arduino Uno

Le processeur ATmega328P de l'Arduino Uno n'a que 2048 octets de RAM, et chaque LED demande un tampon de couleur de 3 octets. Un panneau 8x8 tient facilement avec 192 octets, tandis qu'un 16x16, avec 768 octets, occupe à lui seul plus d'un tiers de la RAM. Le piège est le suivant : Adafruit NeoPixel alloue ce tampon pendant l'exécution du programme, donc il n'est pas inclus dans le taux d'utilisation des variables globales affiché en fin de compilation. Même si la compilation indique 70 % d'occupation, la mémoire peut manquer une fois le tampon du panneau ajouté ; la carte se bloque ou tu vois des couleurs absurdes. De plus, sur les cartes AVR, les interruptions sont désactivées pendant show() ; avec 256 LED, cela dure environ 7,7 ms, pendant lesquelles millis() peut prendre du retard et des données reçues par Serial peuvent être perdues. Pour les grands panneaux, un Arduino Mega avec 8 Ko de RAM ou un ESP32 avec des centaines de kilooctets de RAM est un bien meilleur choix.

Consommation de courant et limitation de la luminosité

Chaque canal de couleur d'un WS2812B consomme environ 20 mA à pleine luminosité ; quand les trois canaux sont allumés, donc en blanc, cela fait 60 mA par LED. Pour un calcul approximatif, utilise la formule I ≈ nombre de LED × 60 mA × (luminosité / 255). Un panneau 16x16 en blanc plein consomme 256 × 60 = 15 360 mA, soit plus de 15 A ; cela sollicite autant les alimentations que les fines pistes de cuivre du panneau. La bonne nouvelle, c'est qu'une matrice est très lumineuse : en intérieur, une luminosité de 20 à 50 sur 255 est déjà bien visible. Dans de vraies animations, toutes les LED ne sont pas blanches en même temps, donc le courant moyen est bien inférieur au calcul, mais il faut choisir l'alimentation pour le pire cas ou limiter par logiciel.

Sur un panneau 16x16, si tu n'amènes le courant que par une extrémité, la tension chute sur les LED du coin éloigné et le blanc paraît jaunâtre ou rougeâtre. Pour l'éviter, alimente le 5V et le GND à la fois par l'entrée et par la sortie du panneau, avec des câbles d'au moins 0,75 mm² de section ; c'est ce qu'on appelle l'injection d'alimentation. Côté logiciel, la fonction setMaxPowerInVoltsAndMilliamps(5, 2000) de la bibliothèque FastLED calcule le courant estimé à chaque image et réduit automatiquement la luminosité si la limite risque d'être dépassée. Si tu utilises une batterie, tu peux vérifier l'autonomie du circuit avec le calculateur d'autonomie de batterie ; pour le choix de l'alimentation, consulte l'article alimentation Arduino.

Animation de matrice 16x16 avec l'ESP32 (FastLED)

Avec sa grande RAM et son processeur à 240 MHz, l'ESP32 est un choix bien plus confortable pour les grands panneaux ; comme il génère le signal NeoPixel avec l'unité matérielle RMT, il ne mobilise pas trop le processeur. Le code ci-dessous dessine avec FastLED deux points de couleur qui glissent en laissant une traînée sur un panneau 16x16. beatsin8() produit une coordonnée qui oscille de façon sinusoïdale dans le temps, et fadeToBlackBy() assombrit un peu tous les pixels à chaque image pour créer l'effet de queue. Il suffit d'installer la dernière version de FastLED depuis le gestionnaire de bibliothèques ; les versions récentes prennent en charge les versions 2.x et 3.x du noyau Arduino pour ESP32.

1#include <FastLED.h>
2
3#define DATA_PIN 16                // DIN -> GPIO 16 (330 ohm ile) / DIN -> GPIO 16 (via 330 ohm)
4#define W 16
5#define H 16
6#define NUM_LEDS (W * H)
7
8CRGB leds[NUM_LEDS];
9
10// Zikzak dizilim için koordinat dönüşümü / coordinate mapping for serpentine layout
11uint16_t xyIndex(uint8_t x, uint8_t y) {
12  return (y & 1) ? (y * W + (W - 1 - x)) : (y * W + x);
13}
14
15void setup() {
16  FastLED.addLeds<WS2812B, DATA_PIN, GRB>(leds, NUM_LEDS);
17  FastLED.setBrightness(60);                       // genel parlaklık / global brightness
18  FastLED.setMaxPowerInVoltsAndMilliamps(5, 2000); // 5 V, en fazla 2 A / 5 V, max 2 A
19  FastLED.clear(true);
20}
21
22void loop() {
23  static uint8_t hue = 0;
24  fadeToBlackBy(leds, NUM_LEDS, 30);               // iz efekti / trail effect
25
26  uint8_t px1 = beatsin8(13, 0, W - 1);            // sinüs salınımlı koordinatlar / sine-wave coordinates
27  uint8_t py1 = beatsin8(17, 0, H - 1);
28  uint8_t px2 = beatsin8(11, 0, W - 1, 0, 64);
29  uint8_t py2 = beatsin8(7, 0, H - 1, 0, 128);
30
31  leds[xyIndex(px1, py1)] = CHSV(hue, 255, 255);
32  leds[xyIndex(px2, py2)] = CHSV(hue + 128, 255, 255);
33
34  FastLED.show();
35  hue++;
36  delay(16);                                       // yaklaşık 60 kare/sn / about 60 fps
37}

Matrice NeoPixel avec Raspberry Pi Pico et MicroPython

Dans MicroPython sur le Pico, le module neopixel est fourni d'origine ; pas besoin de copier de fichier supplémentaire. Le module génère lui-même le timing du signal : tu te contentes d'affecter la couleur avec np[i] = (r, g, b) et de l'envoyer au panneau avec write(). Comme MicroPython n'a pas de fonction setBrightness comme la bibliothèque Adafruit, tu limites toi-même la luminosité en multipliant les valeurs de couleur par un coefficient. L'exemple ci-dessous fait apparaître et disparaître doucement un cœur sur un panneau 8x8 ; l'icône est dessinée à partir d'un tableau bitmap où chaque ligne est un octet, le bit le plus à gauche correspondant à la colonne x = 0.

1from machine import Pin
2from neopixel import NeoPixel
3import time
4
5W, H = 8, 8
6np = NeoPixel(Pin(2), W * H)       # DIN -> GP2 (330 ohm ile) / DIN -> GP2 (via 330 ohm)
7BRIGHTNESS = 0.1                   # %10 parlaklık / 10% brightness
8
9HEART = [
10    0b01100110,
11    0b11111111,
12    0b11111111,
13    0b11111111,
14    0b01111110,
15    0b00111100,
16    0b00011000,
17    0b00000000,
18]
19
20def xy_index(x, y):
21    # zikzak dizilim / serpentine layout
22    if y % 2:
23        return y * W + (W - 1 - x)
24    return y * W + x
25
26def draw_bitmap(rows, color):
27    r, g, b = color
28    c = (int(r * BRIGHTNESS), int(g * BRIGHTNESS), int(b * BRIGHTNESS))
29    for y in range(H):
30        for x in range(W):
31            on = rows[y] & (0x80 >> x)     # soldaki bit x=0 / leftmost bit is x=0
32            np[xy_index(x, y)] = c if on else (0, 0, 0)
33    np.write()                     # panele gönder / push to the panel
34
35while True:
36    for level in range(0, 256, 8):         # kalp yavaşça yanar / heart fades in
37        draw_bitmap(HEART, (level, 0, 0))
38        time.sleep_ms(20)
39    for level in range(255, -1, -8):       # ve söner / and fades out
40        draw_bitmap(HEART, (level, 0, 0))
41        time.sleep_ms(20)

Idées de projets avec une matrice NeoPixel

• Panneau à texte défilant : fais défiler des messages récupérés sur Internet ou l'heure avec un ESP32 ; pour l'heure, utilise la méthode de l'article horloge NTP ESP32.
• Jeux de serpent et de blocs : fabrique une mini console de jeu colorée avec un panneau 16x16 et un joystick.
• Spectre sensible à la musique : affiche le niveau sonore mesuré par un micro sous forme de colonnes colorées ; détails dans l'article LED sensibles à la musique.
• Badge d'icônes : fais défiler avec un bouton des icônes comme un smiley, un cœur et une flèche sur un panneau 8x8.
• Thermomètre coloré : dessine une barre qui se remplit du bleu au rouge selon la température mesurée par un DHT11.
• Contrôle depuis le téléphone : installe WLED sur l'ESP32 et pilote le panneau en Wi-Fi avec des effets 2D prêts à l'emploi.
• Décoration de Noël : ajoute un panneau visuel avec des animations de neige et d'étoiles à ton projet de sapin de Noël à LED.

Erreurs courantes et solutions

La matrice NeoPixel est la façon la plus amusante de donner un écran coloré et animé à tes projets avec un panneau à petit prix. Commence petit : fais d'abord fonctionner le panneau 8x8 à faible luminosité, mets au point la fonction xyIndex, puis passe au texte défilant et aux animations 16x16. Si tu n'as besoin d'afficher que du texte et des chiffres d'une seule couleur, une matrice LED MAX7219 est une alternative qui consomme moins de courant. Dans l'application BlueGrays, tu peux étudier pas à pas, avec schémas et codes, le gyrophare de police WS2812B, le chenillard et les projets d'animation, ainsi que les jeux de serpent sur matrice 8x8 et 16x16.