ESP32 : 64 matrices 8×8 LED RVB WS2812B (Arduino IDE)

Ce guide montre comment utiliser le panneau matriciel 64 LED RVB 8×8 WS2812B avec l’ESP32 à l’aide de l’IDE Arduino. Nous vous montrerons comment contrôler chaque LED, définir différentes couleurs/luminosité, dessiner des formes/icônes et créer un effet arc-en-ciel RVB.

Nous avons également un guide dédié qui montre comment utiliser les LED RVB adressables WS2812B (Neopixels) avec la carte ESP32 à l’aide de l’IDE Arduino.

Conditions préalables

Avant de continuer, assurez-vous que l’IDE Arduino et les cartes ESP32 sont installés. Suivez le tutoriel suivant si ce n’est pas déjà fait :

Présentation du panneau matriciel 64 LED RVB 8 × 8 WS2812B (Neopixels)

Le panneau matriciel WS2812B 8×8 dispose de 64 LED RVB (également appelées néopixels) qui vous permettent de contrôler chaque LED indépendamment avec n’importe quelle couleur et luminosité en utilisant une seule broche numérique de votre ESP32.

Alimentation du panneau matriciel LED 8×8 WS2812B

Le panneau matriciel LED doit être alimenté à l’aide d’une source d’alimentation de 5 V. À 5 V, chaque LED consomme environ 50 mA lorsqu’elle est réglée à sa pleine luminosité. Cela signifie qu’à pleine luminosité en blanc pour 30 LED, le panneau matriciel peut consommer jusqu’à 1,5 A. Assurez-vous de sélectionner une source d’alimentation qui correspond à vos besoins. Un adaptateur secteur CA vers CC fournissant 5 V et 2 A devrait faire l’affaire :

Si vous utilisez une source d’alimentation externe, n’oubliez pas de connecter la masse de la source d’alimentation à la broche ESP32 GND. Dans ce tutoriel, nous allons contrôler 64 LED (c’est une matrice carrée 8×8) à l’aide d’une source d’alimentation externe.

Pièces requises

Pour ce projet, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou vous rendre directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Câblage de 64 matrices LED RVB WS2812B 8 × 8 à l’ESP32

Le câblage du WS2812B à l’ESP32 est assez simple, car il ne nécessite qu’une seule broche numérique (DIN) pour contrôler chaque LED individuellement.

* vous pouvez utiliser n’importe quel autre GPIO approprié. Consultez le guide de brochage ESP32 :

Le câblage du panneau matriciel 8×8 à l’ESP32 est très simple. Nous partagerons le schéma de câblage ci-dessous avec un adaptateur secteur externe, mais vous pouvez également utiliser le 5 V directement depuis l’ESP32 si vous n’utilisez pas de couleur blanche avec une luminosité totale.

Si vous utilisez un adaptateur secteur, connectez GND à V- et connectez GPIO 2 à la broche DIN (données). Ensuite, connectez l’adaptateur secteur externe 5V au V+ et GND au V-.

Installation de la bibliothèque FastLED

Il existe plusieurs bibliothèques pour interfacer les LED WS2812B avec l’ESP32. Nous utiliserons la bibliothèque FastLED. Vous pouvez l’installer rapidement en suivant ces étapes :

• Ouvrez le gestionnaire de bibliothèque Arduino IDE
• Rechercher FastLED
• Installez la bibliothèque FastLED de Daniel Garcia

Exemple n ° 1 – Contrôle ESP32 WS2812B 8 × 8 LED RVB du panneau matriciel individuellement

Le code suivant définit une couleur différente pour chaque LED RVB WS2812B de la matrice en utilisant les coordonnées (X, Y). Téléchargez le code suivant sur votre tableau et cela fonctionnera immédiatement.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-64-ws2812b-8x8-matrix-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 

#define DIN_PIN        2
#define MATRIX_WIDTH   8
#define MATRIX_HEIGHT  8
#define NUM_LEDS       (MATRIX_WIDTH * MATRIX_HEIGHT)
#define BRIGHTNESS     80          // Brightness (0-255)
#define LED_TYPE       WS2812B
#define COLOR_ORDER    GRB
#define ZIGZAG         true        // Set false if your panel is wired in straight rows instead of zigzag
#define DELAY_MS       500

CRGB leds[NUM_LEDS];

// Convert (x,y) coordinates to the corresponding index in the matrix
uint16_t coordToIndex(uint8_t x, uint8_t y) {
  if (ZIGZAG && (y & 0x01)) {
    x = (MATRIX_WIDTH - 1) - x;
  }
  return (y * MATRIX_WIDTH) + x;
}

// Set the color of a pixel at (x,y)
void setPixel(uint8_t x, uint8_t y, uint8_t r, uint8_t g, uint8_t b, uint8_t brightness = 255) {
  if (x >= MATRIX_WIDTH || y >= MATRIX_HEIGHT) 
    return;
  CRGB color = CRGB(r, g, b);
  color.nscale8(brightness);
  leds[coordToIndex(x, y)] = color;
}

void setup() {
  FastLED.addLeds(leds, NUM_LEDS);
  FastLED.setBrightness(BRIGHTNESS);
  FastLED.clear();
}

void loop() {
  setPixel(0, 0, 255, 0, 0);         // First LED x=0 and y=0  |  Red - Full brightness
  FastLED.show();
  delay(DELAY_MS);

  setPixel(3, 3,  0, 255, 0, 128);   // LED x=3 and y=3  |  Green - 50% brightness
  FastLED.show();
  delay(DELAY_MS);

  setPixel(7, 7, 0, 0, 255, 200);    // Last LED x=7 and y=7  |  Blue - ~78% brightness
  FastLED.show();
  delay(DELAY_MS);

  FastLED.clear();                   // All LEDs off
  FastLED.show();
  delay(DELAY_MS);
}

Afficher le code brut

Comment fonctionne le code ?

Jetons un coup d’œil rapide au code pour voir comment fonctionne ce premier exemple.

Y compris la bibliothèque

Tout d’abord, vous devez inclure la bibliothèque FastLED.h, nécessaire pour contrôler les LED WS2812B.

#include 

Variables globales

Les données du panneau matriciel dans la broche (DIN_PIN) sont connectées à l’ESP32 GPIO 2.

#define DIN_PIN   2

Définissez la largeur et la hauteur de la matrice, puis multipliez ces deux valeurs pour calculer le nombre total de LED.

#define MATRIX_WIDTH     8
#define MATRIX_HEIGHT   8
#define NUM_LEDS            (MATRIX_WIDTH * MATRIX_HEIGHT)

Réglez la luminosité de toutes les LED (la plage est de 0 à 255).

#define BRIGHTNESS   80

Définissez le type de LED WS2812B et définissez l’ordre des couleurs sur GRB. La plupart des LED WS2812B utilisent l’ordre GRB et non RVB.

#define LED_TYPE              WS2812B
#define COLOR_ORDER    GRB

La variable ZIGZAG est utilisée dans la fonction coordToIndex() pour attribuer la position correcte des LED selon que les LED sont câblées en zigzag ou si toutes les lignes de la matrice sont câblées dans le même sens.

#define ZIGZAG     true

Temps de retard de l’animation en millisecondes (500 ms = 0,5 s).

#define DELAY_MS   500

Créez un tableau appelé LEDs contenant toutes les couleurs des 8 LED. CRGB est la définition du type de couleur de FastLED (Rouge, Vert, Bleu).

CRGB leds[NUM_LEDS];

coordVersIndex()

La fonction coordToIndex() convertit les coordonnées (x, y) en index correspondant dans la matrice :

uint16_t coordToIndex(uint8_t x, uint8_t y) {
  if (ZIGZAG && (y & 0x01)) {
    x = (MATRIX_WIDTH - 1) - x;
  }
  return (y * MATRIX_WIDTH) + x;
}

setPixel()

La fonction setPixel() définit la couleur et la luminosité d’un seul pixel sur la matrice LED. Tout d’abord, il vérifie si les coordonnées sont correctes, puis construit une couleur CRGB à partir des valeurs de couleur fournies (rouge, vert, bleu), met à l’échelle l’intensité de cette couleur en fonction du paramètre de luminosité (de 0 à 255), et enfin écrit la couleur correcte dans le tableau global de LED à l’index renvoyé par la fonction coordToIndex().

void setPixel(uint8_t x, uint8_t y, uint8_t r, uint8_t g, uint8_t b, uint8_t brightness = 255) {
  if (x >= MATRIX_WIDTH || y >= MATRIX_HEIGHT) 
    return;
  CRGB color = CRGB(r, g, b);
  color.nscale8(brightness);
  leds[coordToIndex(x, y)] = color;
}

Si vous avez une matrice de LED en zigzag vous vous référez aux coordonnées de chaque LED comme suit :

installation()

Dans le setup(), commencez par initialiser la bande ou l’anneau LED à l’aide de la bibliothèque FastLED. Vous devez passer les arguments :

• Type de LED = WS2812B
• Broche de données = DIN_PIN
• Ordre des couleurs = GRB (la plupart des LED WS2812B utilisent l’ordre GRB, pas RVB)

FastLED.addLeds(leds, NUM_LEDS);

Réglez le niveau de luminosité global et éteignez toutes les LED au début.

FastLED.setBrightness(BRIGHTNESS);   
FastLED.clear();

boucle()

La boucle() s’exécute en continu. Il définit d’abord la première LED (avec les coordonnées x=0 et y=0) sur la couleur Rouge (R=255, G=0, B=0).

setPixel(0, 0, 255, 0, 0);

La ligne précédente définit uniquement la couleur. Pour changer réellement la couleur des LED physiques, vous devez appeler la méthode show().

FastLED.show();

Ajoutez un délai de 500 millisecondes :

delay(DELAY_MS);

Ensuite, nous définissons la couleur et la luminosité de deux autres LED de la matrice.

setPixel(3, 3,  0, 255, 0, 128);   // LED x=3 and y=3  |  Green - 50% brightness
FastLED.show();
delay(DELAY_MS);

setPixel(7, 7, 0, 0, 255, 200);    // Last LED x=7 and y=7  |  Blue - ~78% brightness
FastLED.show();
delay(DELAY_MS);

Enfin, nous éteignons toutes les LED en appelant la méthode clear().

FastLED.clear();
FastLED.show();
delay(DELAY_MS);

Démonstration

Voici une illustration de l’exemple exécuté :

Exemple n ° 2 – Forme de dessin ESP32 sur le panneau matriciel WS2812B 8 × 8

Le code suivant dessine une forme avec un effet de battement de cœur sur le panneau matriciel WS2812B 8×8. Vous pouvez télécharger le code suivant sur votre carte ESP32.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-64-ws2812b-8x8-matrix-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 

#define DIN_PIN       2
#define MATRIX_WIDTH  8
#define MATRIX_HEIGHT 8
#define NUM_LEDS      (MATRIX_WIDTH * MATRIX_HEIGHT)
#define BRIGHTNESS    80         // Brightness (0-255)
#define LED_TYPE      WS2812B
#define COLOR_ORDER   GRB
#define ZIGZAG        true       // Set false if your panel is wired in straight rows instead of zigzag
#define FLIP_H        false      // Set true if the image displays mirrored left to right
#define FLIP_V        false      // Set true if the image displays upside down

CRGB leds[NUM_LEDS];

// Heart shape (8x8)
const bool heart[MATRIX_HEIGHT][MATRIX_WIDTH] = {
  {0,0,0,0,0,0,0,0},
  {0,1,1,0,0,1,1,0},
  {1,1,1,1,1,1,1,1},
  {1,1,1,1,1,1,1,1},
  {1,1,1,1,1,1,1,1},
  {0,1,1,1,1,1,1,0},
  {0,0,1,1,1,1,0,0},
  {0,0,0,1,1,0,0,0}
};

// Convert (x,y) coordinates to the corresponding index in the matrix
uint16_t coordToIndex(uint8_t x, uint8_t y) {
  if (FLIP_H) x = (MATRIX_WIDTH - 1) - x;
  if (FLIP_V) y = (MATRIX_HEIGHT - 1) - y;

  if (ZIGZAG && (y & 0x01)) {
    x = (MATRIX_WIDTH - 1) - x;
  }
  return (y * MATRIX_WIDTH) + x;
}

// Set the color of a pixel at (x,y)
void setPixel(uint8_t x, uint8_t y, CRGB color) {
  if (x >= MATRIX_WIDTH || y >= MATRIX_HEIGHT) 
    return;
  leds[coordToIndex(x, y)] = color;
}

// Draws the heart shape - scales its color by a brightness factor (0.0 - 1.0)
void drawShape(CRGB color, float scale) {
  FastLED.clear();
  CRGB c = color;
  c.nscale8_video((uint8_t)(scale * 255));
  for (uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
    for (uint8_t x = 0; x < MATRIX_WIDTH; x++) {
      if (heart[y][x]) setPixel(x, y, c);
    }
  }
}

// Pulses a heartrate LED pattern by changing the brightness over durationMs
// It creates a fade in and fade out effect
void pulse(CRGB color, float from, float to, uint16_t durationMs) {
  const uint8_t steps = 24;
  for (uint8_t i = 0; i <= steps; i++) {
    float t = (float)i / steps;
    float eased = (1 - cos(t * PI)) / 2.0;
    float scale = from + (to - from) * eased;
    drawShape(color, scale);
    FastLED.show();
    delay(durationMs / steps);
  }
}

void setup() {
  FastLED.addLeds(leds, NUM_LEDS);
  FastLED.setBrightness(BRIGHTNESS);
  FastLED.clear();
  FastLED.show();
}

void loop() {
  // Red color
  CRGB color = CRGB(255, 0, 0);
  // Heartbeat animation
  pulse(color, 0.30, 1.00, 120);
  pulse(color, 1.00, 0.55, 140);
  pulse(color, 0.55, 0.85, 100);
  pulse(color, 0.85, 0.30, 160);
  drawShape(color, 0.30);
  FastLED.show();
  delay(300);
}

Afficher le code brut

Présentation du code

Jetons maintenant un coup d’œil rapide au code de cette section. L’initialisation du code est très similaire à l’exemple n°1, mais au lieu de contrôler chaque LED individuellement, nous allons dessiner une forme de cœur 8×8.

const bool heart[MATRIX_HEIGHT][MATRIX_WIDTH] = {
  {0,0,0,0,0,0,0,0},
  {0,1,1,0,0,1,1,0},
  {1,1,1,1,1,1,1,1},
  {1,1,1,1,1,1,1,1},
  {1,1,1,1,1,1,1,1},
  {0,1,1,1,1,1,1,0},
  {0,0,1,1,1,1,0,0},
  {0,0,0,1,1,0,0,0}
};

Si vous souhaitez refléter la forme horizontalement ou verticalement, vous pouvez définir ces variables sur vrai ou faux.

#define FLIP_H        false        // Set true if the image displays mirrored left to right
#define FLIP_V        false        // Set true if the image displays upside down

La fonction drawShape() dessine une forme de cœur sur le panneau matriciel LED :

1. Tout d’abord, cela efface l’affichage ;
2. Ensuite, crée une copie de la couleur d’entrée et met à l’échelle sa luminosité à l’aide du facteur d’échelle (0,0 à 1,0) ;
3. Enfin, il parcourt chaque pixel de la matrice et allume la LED là où la forme du cœur est définie.[y][x] tableau en appelant setPixel() avec la couleur mise à l’échelle.

void drawShape(CRGB color, float scale) {
  FastLED.clear();
  CRGB c = color;
  c.nscale8_video((uint8_t)(scale * 255));
  for (uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
    for (uint8_t x = 0; x < MATRIX_WIDTH; x++) {
      if (heart[y][x]) setPixel(x, y, c);
    }
  }
}

La fonction pulse() fait passer la luminosité de la forme du cœur d’un niveau à un autre pendant une durée spécifiée. À l’intérieur de cette fonction, il y a une boucle qui crée l’effet de fondu sur 24 petites étapes, à chaque étape, elle redessine la forme du cœur avec la nouvelle luminosité, met à jour les LED et fait une pause entre les étapes pour créer l’effet de pouls cardiaque.

void pulse(CRGB color, float from, float to, uint16_t durationMs) {
  const uint8_t steps = 24;
  for (uint8_t i = 0; i <= steps; i++) {
    float t = (float)i / steps;
    float eased = (1 - cos(t * PI)) / 2.0;
    float scale = from + (to - from) * eased;
    drawShape(color, scale);
    FastLED.show();
    delay(durationMs / steps);
  }
}

La boucle principale() exécute l’effet de battement de coeur rouge indéfiniment. Il définit d’abord la couleur sur rouge, puis appelle la fonction pulse() 4 fois pour éclaircir la forme du cœur, s’estomper un peu, s’éclaircir à nouveau plus doucement et s’estomper. Après cela, il maintient la forme du cœur dessinée à faible luminosité pendant une courte pause avant de recommencer la séquence.

void loop() {
  // Red color
  CRGB color = CRGB(255, 0, 0);
  // Heartbeat animation
  pulse(color, 0.30, 1.00, 120);
  pulse(color, 1.00, 0.55, 140);
  pulse(color, 0.55, 0.85, 100);
  pulse(color, 0.85, 0.30, 160);
  drawShape(color, 0.30);
  FastLED.show();
  delay(300);
}

Démonstration

Voici une illustration de l’exemple n°2 dessinant la forme du cœur rouge. La luminosité des LED va s’atténuer et s’atténuer pour créer l’effet de battement de cœur :

Exemple n ° 3 – Effet arc-en-ciel ESP32 sur le panneau matriciel WS2812B 8 × 8

Le code suivant crée un effet arc-en-ciel avec des couleurs se déplaçant doucement sur toutes les LED. Téléchargez le code ci-dessous sur votre carte ESP32.

/*
  Rui Santos & Sara Santos - Raspberryme.com
  Complete project details at https://Raspberryme.com/esp32-64-ws2812b-8x8-matrix-arduino/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/
#include 

#define DIN_PIN        2
#define MATRIX_WIDTH   8
#define MATRIX_HEIGHT  8
#define NUM_LEDS       (MATRIX_WIDTH * MATRIX_HEIGHT)
#define BRIGHTNESS     80          // Brightness (0-255)
#define LED_TYPE       WS2812B
#define COLOR_ORDER    GRB
#define ZIGZAG         true        // Set false if your panel is wired in straight rows instead of zigzag

// Rainbow animation 
#define BASE_HUE           160    // Initial blue hue for new LED (0-255)
#define HUE_STEP_PER_TICK  3      // Amount the LED hue shifts per frame
#define DELAY_MS           80     // Animation speed
uint16_t ledsLit = 0;             // Number of LEDs currently turned on
uint16_t frame = 0;               // Counts animation frames

CRGB leds[NUM_LEDS];

// Convert (x,y) coordinates to the corresponding index in the matrix
uint16_t coordToIndex(uint8_t x, uint8_t y) {
  if (ZIGZAG && (y & 0x01)) {
    x = (MATRIX_WIDTH - 1) - x;
  }
  return (y * MATRIX_WIDTH) + x;
}

// Set the color of a pixel at (x,y)
void setPixel(uint8_t x, uint8_t y, CRGB color, uint8_t brightness = 255) {
    if (x >= MATRIX_WIDTH || y >= MATRIX_HEIGHT) 
      return;
    
    color.nscale8(brightness);
    leds[coordToIndex(x, y)] = color;
}

void setup() {
  FastLED.addLeds(leds, NUM_LEDS);
  FastLED.setBrightness(BRIGHTNESS);
  FastLED.clear();
  FastLED.show();
}

void loop() {
  // Turns on 1 LED per frame until fully lit
  if (ledsLit < NUM_LEDS) {
    ledsLit++;
  }

  // Update colors of all currently lit LEDs
  for (uint16_t i = 0; i < ledsLit; i++) {
    uint8_t x = i % MATRIX_WIDTH;
    uint8_t y = i / MATRIX_WIDTH;

    // Calculate hue based on how long this LED has been lit
    // Newer LEDs start at BASE_HUE, older ones shift further along the color wheel
    uint16_t age = frame - i;
    uint8_t  hue = BASE_HUE + (uint8_t)(age * HUE_STEP_PER_TICK);

    setPixel(x, y, CHSV(hue, 255, 255));
  }

  FastLED.show();
  delay(DELAY_MS);
  frame++;
}

Afficher le code brut

Présentation du code

Cet exemple commence également de la même manière que les précédents, nous nous concentrerons donc principalement sur le nouveau code de la fonction loop().

Tout d’abord, vous pouvez définir ces constantes pour contrôler la teinte bleue de départ et l’ampleur du décalage de couleur à chaque image.

#define BASE_HUE           160           // Initial blue hue for new LED (0-255)
#define HUE_STEP_PER_TICK  3     // Amount the LED hue shifts per frame

Il utilise deux compteurs statiques qui stockent leurs valeurs entre les trames :

• ledsLit – combien de LED sont actuellement allumées
• frame – compte les images d’animation

static uint16_t ledsLit = 0;        // Number of LEDs currently turned on
static uint16_t frame = 0;         // Counts animation frames

Dans la fonction loop(), si le panneau matriciel n’est pas encore complètement allumé, il allume une LED supplémentaire en augmentant ledsLit.

// Turns on 1 LED per frame until fully lit
if (ledsLit < NUM_LEDS) {
  ledsLit++;
}

Cette section de code suivante exécute un effet de couleur arc-en-ciel changeant sur le panneau matriciel 8×8. Il parcourt chaque LED allumée, trouve la position (x, y) et définit sa couleur en fonction de la durée pendant laquelle elle est allumée. Les LED allumées les plus récentes restent plus proches du bleu, tandis que les plus anciennes changent de couleur pour créer l’effet arc-en-ciel.

// Update colors of all currently lit LEDs
for (uint16_t i = 0; i < ledsLit; i++) {
  uint8_t x = i % MATRIX_WIDTH;
  uint8_t y = i / MATRIX_WIDTH;

  // Calculate hue based on how long this LED has been lit
  // Newer LEDs start at BASE_HUE, older ones shift further along the color wheel
  uint16_t age = frame - i;
  uint8_t  hue = BASE_HUE + (uint8_t)(age * HUE_STEP_PER_TICK);

  setPixel(x, y, CHSV(hue, 255, 255));
}

Enfin, il affiche les couleurs mises à jour sur les LED avec FastLED.show(). Il a un court délai et incrémente le compteur d’images afin que les couleurs continuent de changer dans la boucle suivante.

FastLED.show();
delay(DELAY_MS);
frame++;

Démonstration

Voici à quoi ressemble l’exemple n°3 lorsqu’il fonctionne pendant que les LED créent l’effet arc-en-ciel :

Vous pouvez regarder la courte vidéo suivante qui présente les trois exemples.

Conclusion

Dans ce didacticiel, vous avez appris à contrôler le panneau matriciel WS2812B RGB LED 8×8 à l’aide de la bibliothèque FastLED pour contrôler chaque LED individuellement, dessiner des formes et afficher l’effet arc-en-ciel. Nous avons d’autres tutoriels sur les LED RVB qui pourraient vous plaire :

Apprenez-en plus sur l’ESP32 avec nos ressources :

Nous espérons que vous avez apprécié ce projet et appris quelque chose de nouveau.

Merci d’avoir lu.

Cette vidéo vous emmène dans l’histoire de Raspberry Pi :