Dans ce projet, nous allons créer un éditeur de forme matricielle pour une matrice LED 8 × 8 WS2812B fonctionnant sur une carte ESP32. L’ESP32 se connecte à votre Wi-Fi et dessert une page Web où vous dessinez des formes et les affichez directement sur une matrice 8×8. Dans l’éditeur, vous pouvez sélectionner une couleur pour chaque pixel et la luminosité globale. Toutes vos formes sont stockées dans la mémoire de l’ESP32 et restent enregistrées même après un redémarrage.
Vous pouvez afficher les formes enregistrées dans un widget de style galerie sur lequel vous pouvez cliquer pour afficher instantanément sur la matrice physique, charger dans l’éditeur pour les modifier ou créer un diaporama pour afficher une séquence de formes.

Vous aimerez peut-être lire : Construire un serveur Web ESP32 : le guide complet pour les débutants (Arduino IDE).
Aperçu du projet
L’image suivante montre la page Web que vous allez créer pour ce projet.

Voici les principales caractéristiques de ce projet :
- Page Web de l’éditeur de forme de grille 8 × 8 : vous pouvez définir une couleur personnalisée pour chaque pixel afin de dessiner des formes.
- Contrôle de la luminosité : un curseur ajuste la luminosité de l’ensemble de la forme.
- 10 emplacements mémoire pour vos formes : vous pouvez stocker jusqu’à 10 formes dans LittleFS au format JSON (elles restent donc stockées même après un redémarrage).
- Charger pour modifier : cliquer sur une forme enregistrée dans le widget de la galerie l’affiche sur la matrice physique et la charge à nouveau dans l’éditeur afin que vous puissiez la modifier.
- Aperçus des formes de la galerie : l’aperçu de chaque forme enregistrée montre la forme finale qui sera affichée.
- Aperçu instantané : testez un dessin sur les LED physiques avant de le stocker sur un emplacement.
- Supprimer la forme : la suppression d’une forme enregistrée efface également les LED physiques.
- Animation du diaporama : activez un diaporama qui parcourt toutes les formes enregistrées avec un intervalle de temps réglable.
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 :
Vous pourriez également trouver utile de lire ces autres guides :
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 peuvent être contrôlées individuellement avec n’importe quelle couleur et luminosité à l’aide d’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 couleur blanche) 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.

| Matrice 8×8 | ESP32 |
| V- | GND |
| VACARME | N’importe quelle broche numérique (par exemple : GPIO 2)* |
| Adaptateur secteur | |
| GND | ESP32 GND |
| GND | Matrice 8×8 V- |
| 5V | Matrice 8×8 V+ |
* 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 la couleur blanche à pleine luminosité.
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-.

Installer les bibliothèques requises dans l’IDE Arduino
Vous devez installer plusieurs bibliothèques pour ce projet. Suivez les instructions suivantes.
Installez la bibliothèque FastLED en suivant ces étapes :
- Ouvrez le gestionnaire de bibliothèque Arduino IDE
- Rechercher FastLED
- Installez la bibliothèque FastLED de Daniel Garcia

Vous avez également besoin des bibliothèques pour créer le serveur Web. Recherchez ESPAsyncWebServer et installez ESPAsyncWebServer par ESP32Async.

Ensuite, recherchez AsyncTCP et installez AsyncTCP par ESP32Async.

Enfin, tapez ArduinoJSON et installez la dernière version ArduinoJSON 7.X de Benoit Blanchon.

Arduino Sketch – Serveur Web de l’éditeur de forme matricielle ESP32
Le code suivant exécute un serveur Web avec la page Web de l’éditeur de formes matricielles sur laquelle vous pouvez créer des formes personnalisées à afficher et exécuter des animations.
/*
Rui Santos & Sara Santos - Raspberryme.com
Complete project details at https://Raspberryme.com/esp32-8x8-matrix-shape-editor-web-server/
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
#include
#include
#include
#include
#include
// REPLACE WITH YOUR NETWORK CREDENTIALS
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";
#define DIN_PIN 2
#define MATRIX_WIDTH 8
#define MATRIX_HEIGHT 8
#define NUM_LEDS (MATRIX_WIDTH * MATRIX_HEIGHT)
#define BRIGHTNESS 200 // Brightness (0-255)
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
#define ZIGZAG false // Set false if your panel is wired in straight rows instead of zigzag
#define FLIP_H true // Set true if the image displays mirrored left to right
#define FLIP_V true // Set true if the image displays upside down
#define NUM_SLOTS 10 // Number of stored shape slots
#define SHAPES_DIR "/shapes"
CRGB leds[NUM_LEDS];
AsyncWebServer server(80);
CRGB currentPixelColors[MATRIX_HEIGHT][MATRIX_WIDTH]; // Colors per pixel for the shape currently loaded into memory
uint8_t currentBrightness = 128;
bool haveShapeLoaded = false;
int currentSlot = -1; // Which saved slot is on screen (-1 = preview/none)
// Slideshow state
bool slideshowActive = false;
uint32_t slideshowInterval = 2000; // Delay in ms between shapes
uint32_t slideshowLastTick = 0;
int slideshowIndex = -1; // Last slot shown (-1 = none)
int slideshowOrder[NUM_SLOTS]; // Slots that currently hold a shape
int slideshowCount = 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;
}
// Renders currentPixelColors (scaled by currentBrightness) to the physical LEDs
void renderCurrentShape() {
FastLED.clear();
if (haveShapeLoaded) {
for (uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
for (uint8_t x = 0; x < MATRIX_WIDTH; x++) {
CRGB c = currentPixelColors[y][x];
if (c == CRGB::Black) continue;
c.nscale8_video(currentBrightness);
setPixel(x, y, c);
}
}
}
FastLED.show();
}
// Clears the matrix and resets the current shape state
void clearMatrix() {
haveShapeLoaded = false;
currentSlot = -1;
FastLED.clear();
FastLED.show();
}
// Converts a JSON array of {r,g,b} pixel objects into a 2D CRGB LED matrix grid
bool jsonPixelsToGrid(JsonArray pixels, CRGB out[MATRIX_HEIGHT][MATRIX_WIDTH], bool clampUntrusted) {
if (pixels.isNull() || pixels.size() != NUM_LEDS) return false;
int i = 0;
for (uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
for (uint8_t x = 0; x < MATRIX_WIDTH; x++) {
JsonObject px = pixels[i].as();
if (px.isNull()) return false;
int r = px["r"] | 0;
int g = px["g"] | 0;
int b = px["b"] | 0;
if (clampUntrusted) {
r = constrain(r, 0, 255);
g = constrain(g, 0, 255);
b = constrain(b, 0, 255);
}
out[y][x] = CRGB(r, g, b);
i++;
}
}
return true;
}
// Returns the filesystem path for a given slot number (0-9)
bool slotPath(int slot, char* outPath, size_t outLen) {
if (slot < 0 || slot >= NUM_SLOTS) return false;
snprintf(outPath, outLen, "%s/%d.json", SHAPES_DIR, slot);
return true;
}
// Checks if a given slot has a saved shape (file exists)
bool slotExists(int slot) {
char path[32];
if (!slotPath(slot, path, sizeof(path))) return false;
return LittleFS.exists(path);
}
// Loads a saved shape from a slot into currentPixelColors/currentBrightness
bool loadSlotToCurrent(int slot) {
char path[32];
if (!slotPath(slot, path, sizeof(path))) return false;
if (!LittleFS.exists(path)) return false;
File f = LittleFS.open(path, "r");
if (!f) return false;
JsonDocument doc;
DeserializationError err = deserializeJson(doc, f);
f.close();
if (err) {
Serial.printf("loadSlotToCurrent: JSON parse failed for slot %d: %s\n", slot, err.c_str());
return false;
}
if (!jsonPixelsToGrid(doc["pixels"].as(), currentPixelColors, false)) {
Serial.printf("loadSlotToCurrent: slot %d has bad pixel array\n", slot);
return false;
}
currentBrightness = doc["brightness"] | 128;
haveShapeLoaded = true;
currentSlot = slot;
return true;
}
// Saves a shape to a slot, validating the input first
bool saveSlot(int slot, const char* name, JsonArray pixels, uint8_t brightness) {
char path[32];
if (!slotPath(slot, path, sizeof(path))) return false;
if (pixels.size() != NUM_LEDS) return false;
for (JsonVariant v : pixels) {
JsonObject o = v.as();
if (o.isNull() || !o["r"].is() || !o["g"].is() || !o["b"].is()) {
return false;
}
}
JsonDocument doc;
doc["name"] = name;
JsonArray px = doc["pixels"].to();
for (JsonVariant v : pixels) {
JsonObject src = v.as();
JsonObject dst = px.add();
dst["r"] = constrain(src["r"].as(), 0, 255);
dst["g"] = constrain(src["g"].as(), 0, 255);
dst["b"] = constrain(src["b"].as(), 0, 255);
}
doc["brightness"] = brightness;
File f = LittleFS.open(path, "w");
if (!f) return false;
bool ok = serializeJson(doc, f) > 0;
f.close();
return ok;
}
// Deletes a saved shape from a slot
bool deleteSlot(int slot) {
char path[32];
if (!slotPath(slot, path, sizeof(path))) return false;
if (!LittleFS.exists(path)) return true; // already gone
return LittleFS.remove(path);
}
// Refreshes the slideshowOrder array with the current occupied slots
void refreshSlideshowOrder() {
slideshowCount = 0;
for (int s = 0; s < NUM_SLOTS; s++) {
if (slotExists(s)) {
slideshowOrder[slideshowCount++] = s;
}
}
}
// Builds a JSON array describing every slot (used to populate the gallery)
String buildSlotListJson() {
JsonDocument doc;
JsonArray arr = doc.to();
for (int s = 0; s < NUM_SLOTS; s++) {
JsonObject o = arr.add();
o["slot"] = s;
char path[32];
slotPath(s, path, sizeof(path));
if (LittleFS.exists(path)) {
File f = LittleFS.open(path, "r");
JsonDocument shapeDoc;
DeserializationError err = deserializeJson(shapeDoc, f);
f.close();
if (!err) {
o["occupied"] = true;
o["name"] = shapeDoc["name"] | "";
o["brightness"] = shapeDoc["brightness"] | 0;
o["pixels"] = shapeDoc["pixels"];
} else {
o["occupied"] = false;
}
} else {
o["occupied"] = false;
}
}
String out;
serializeJson(doc, out);
return out;
}
// Web page served for the UI to control the 8x8 matrix
const char INDEX_HTML[] PROGMEM = R"HTMLPAGE(
8x8 Matrix Shape Editor
)HTMLPAGE";
// Applies a JSON payload containing "pixels" and "brightness" to the current shape in memory
bool applyPixelPayload(JsonVariant& doc) {
CRGB tmp[MATRIX_HEIGHT][MATRIX_WIDTH];
if (!jsonPixelsToGrid(doc["pixels"].as(), tmp, true)) return false;
::memcpy(currentPixelColors, tmp, sizeof(tmp));
currentBrightness = doc["brightness"] | 128;
haveShapeLoaded = true;
currentSlot = -1;
return true;
}
// Sends JSON response: {"ok":true}
void sendOk(AsyncWebServerRequest* request) {
request->send(200, "application/json", "{\"ok\":true}");
}
// Sends JSON response: {"ok":false,"error":"..."}
void sendError(AsyncWebServerRequest* request, const char* msg) {
JsonDocument resp;
resp["ok"] = false;
resp["error"] = msg;
String out;
serializeJson(resp, out);
request->send(200, "application/json", out);
}
// Parses a JSON body containing "slot" and validates it is in the range 0-9
bool parseSlot(JsonObject doc, int& outSlot) {
int slot = doc["slot"] | -1;
if (slot < 0 || slot >= NUM_SLOTS) return false;
outSlot = slot;
return true;
}
// Sets up all the web server routes for the UI and API
void setupWebServerRoutes() {
// Serve the UI web page
server.on("/", HTTP_GET, [](AsyncWebServerRequest *request) {
request->send_P(200, "text/html", INDEX_HTML);
});
// GET /api/shape/list -> JSON array describing all 10 shape slots
server.on("/api/shape/list", HTTP_GET, [](AsyncWebServerRequest *request) {
request->send(200, "application/json", buildSlotListJson());
});
// POST /api/shape/save { slot, name, pixels[64], brightness } -> saves the shape to that slot
AsyncCallbackJsonWebHandler* saveHandler = new AsyncCallbackJsonWebHandler(
"/api/shape/save",
[](AsyncWebServerRequest *request, JsonVariant &json) {
JsonObject doc = json.as();
int slot;
const char* name = doc["name"] | "Shape";
JsonArray pixels = doc["pixels"].as();
uint8_t brightness = doc["brightness"] | 128;
if (!parseSlot(doc, slot)) {
sendError(request, "invalid slot");
} else if (pixels.isNull() || pixels.size() != NUM_LEDS) {
sendError(request, "invalid pixel data");
} else if (!saveSlot(slot, name, pixels, brightness)) {
sendError(request, "write failed");
} else {
refreshSlideshowOrder();
sendOk(request);
}
}
);
server.addHandler(saveHandler);
// POST /api/shape/display { slot } -> displays the shape from that slot
AsyncCallbackJsonWebHandler* displayHandler = new AsyncCallbackJsonWebHandler(
"/api/shape/display",
[](AsyncWebServerRequest *request, JsonVariant &json) {
JsonObject doc = json.as();
int slot;
slideshowActive = false;
if (!parseSlot(doc, slot) || !loadSlotToCurrent(slot)) {
sendError(request, "slot empty or invalid");
return;
}
renderCurrentShape();
sendOk(request);
}
);
server.addHandler(displayHandler);
// POST /api/shape/delete { slot } -> deletes the shape from that slot
AsyncCallbackJsonWebHandler* deleteHandler = new AsyncCallbackJsonWebHandler(
"/api/shape/delete",
[](AsyncWebServerRequest *request, JsonVariant &json) {
JsonObject doc = json.as();
int slot;
if (!parseSlot(doc, slot)) {
sendError(request, "invalid slot");
return;
}
bool ok = deleteSlot(slot);
refreshSlideshowOrder();
if (slot == currentSlot) {
clearMatrix();
}
if (ok) sendOk(request);
else sendError(request, "delete failed");
}
);
server.addHandler(deleteHandler);
// POST /api/preview { pixels[64] (each {r,g,b}), brightness } -> preview the shape
AsyncCallbackJsonWebHandler* previewHandler = new AsyncCallbackJsonWebHandler(
"/api/preview",
[](AsyncWebServerRequest *request, JsonVariant &json) {
slideshowActive = false;
if (applyPixelPayload(json)) {
renderCurrentShape();
sendOk(request);
} else {
sendError(request, "invalid pixel data");
}
}
);
server.addHandler(previewHandler);
// POST /api/clear {} -> turns the matrix off
server.on("/api/clear", HTTP_POST, [](AsyncWebServerRequest *request) {
slideshowActive = false;
clearMatrix();
sendOk(request);
});
// POST /api/slideshow { active: bool, interval: ms } -> starts/stops the slideshow animation and sets the interval
AsyncCallbackJsonWebHandler* slideshowHandler = new AsyncCallbackJsonWebHandler(
"/api/slideshow",
[](AsyncWebServerRequest *request, JsonVariant &json) {
JsonObject doc = json.as();
bool active = doc["active"] | false;
uint32_t interval = doc["interval"] | 2000;
if (interval < 250) interval = 250;
refreshSlideshowOrder();
slideshowInterval = interval;
slideshowActive = active && (slideshowCount > 0);
slideshowLastTick = millis();
JsonDocument resp;
resp["ok"] = true;
resp["active"] = slideshowActive;
resp["count"] = slideshowCount;
String out;
serializeJson(resp, out);
request->send(200, "application/json", out);
}
);
server.addHandler(slideshowHandler);
server.onNotFound([](AsyncWebServerRequest *request) {
request->send(404, "text/plain", "Not found");
});
}
// Updates the slideshow animation if it's active and enough time has passed since the last frame
void updateSlideshow() {
if (!slideshowActive || slideshowCount == 0) return;
uint32_t now = millis();
if (now - slideshowLastTick < slideshowInterval) return;
slideshowLastTick = now;
slideshowIndex = (slideshowIndex + 1) % slideshowCount;
int slot = slideshowOrder[slideshowIndex];
if (loadSlotToCurrent(slot)) {
renderCurrentShape();
}
}
void setup() {
Serial.begin(115200);
// Initialize LittleFS and create the shapes directory if it doesn't exist
if (!LittleFS.begin(true)) {
Serial.println("LittleFS mount failed even after format attempt.");
}
if (!LittleFS.exists(SHAPES_DIR)) {
LittleFS.mkdir(SHAPES_DIR);
}
refreshSlideshowOrder();
// Initialize FastLED
FastLED.addLeds(leds, NUM_LEDS);
FastLED.setBrightness(BRIGHTNESS);
FastLED.clear();
FastLED.show();
// Start the Wi-Fi connection
WiFi.begin(ssid, password);
Serial.print("Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWi-Fi Connected!");
// Print the ESP32 IP Address
Serial.print("Access ESP32 IP Address: http://");
Serial.println(WiFi.localIP());
// Set up routes requests and start the web server
setupWebServerRoutes();
server.begin();
Serial.println("ESP32 Web Server started!");
}
void loop() {
// Handle the slideshow animation when it's active
updateSlideshow();
}
Afficher le code brut
Avec les bibliothèques mentionnées précédemment installées dans votre IDE Arduino, il vous suffit d’insérer vos informations d’identification réseau dans les lignes suivantes du code, et cela fonctionnera immédiatement.
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_SSID";
Comment fonctionne le code
Continuez à lire pour découvrir comment fonctionne le code ou passez à la section Démonstration.
Inclure les bibliothèques requises
Pour contrôler une matrice LED 8×8 WS2812B (64 LED), l’ESP32 utilise la bibliothèque FastLED (lire notre guide de démarrage ESP32 : 64 matrices 8×8 LED RVB WS2812B). Il utilise également le Wi-Fi pour l’accès au réseau, la bibliothèque ESPAsyncWebServer pour un serveur Web asynchrone, LittleFS pour accéder au stockage de fichiers ESP et ArduinoJson pour analyser et sérialiser les données de forme.
#include
#include
#include
#include
#include
#include
Variables globales
Nous devons définir quelques variables globales pour configurer la matrice.
Les données du panneau matriciel dans la broche (DIN_PIN) sont connectées à l’ESP32 GPIO 2.
#define DIN_PIN 2
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
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
Cartographie des coordonnées
La fonction coordToIndex(x, y) convertit les coordonnées de la grille en index LED correspondant. En utilisant les variables définies dans la section précédente, la fonction peut également retourner l’image horizontalement ou verticalement et inverser une ligne sur deux lorsque le panneau matriciel est câblé en zigzag. Cela garantit que la disposition visuelle correspond au câblage physique.
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;
}
Forme d’affichage
La fonction renderCurrentShape() est chargée d’afficher réellement la forme actuellement sélectionnée sur la matrice LED physique. Il conserve un tableau de couleurs 2D (currentPixelColors), une valeur de luminosité (0 à 255) et un indicateur indiquant si une forme est chargée. Cette fonction efface les LED, applique la luminosité, écrit les couleurs via setPixel(), puis appelle FastLED.show() pour afficher la forme sur la matrice physique.
void renderCurrentShape() {
FastLED.clear();
if (haveShapeLoaded) {
for (uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
for (uint8_t x = 0; x < MATRIX_WIDTH; x++) {
CRGB c = currentPixelColors[y][x];
if (c == CRGB::Black) continue;
c.nscale8_video(currentBrightness);
setPixel(x, y, c);
}
}
}
FastLED.show();
}
Stockage de forme
Il stocke jusqu’à 10 formes sous forme de fichiers JSON individuels (/shapes/0.json (…) /shapes/9.json) sur LittleFS. Chaque fichier stocke un nom, une luminosité et un tableau plat de 64 objets {r,g,b}. Il dispose de quelques fonctions d’assistance pour gérer le chemin du fichier, vérifier si un fichier existe, charger une forme dans le tampon actuel, supprimer une forme, etc.
Éditeur de forme matricielle (page Web)
Une page Web avec HTML, CSS et JavaScript stockés dans PROGMEM est servie à la root/URL. Il charge une grille 8 × 8 pour le dessin, un sélecteur de couleurs, un curseur de luminosité, un champ de nom, un sélecteur d’emplacement, une galerie de formes enregistrées avec aperçus et des commandes de diaporama.
Points de terminaison de l’API
- GET / – renvoie la page Web de l’éditeur de forme matricielle
- GET /api/shape/list – renvoie un tableau JSON décrivant chaque emplacement (drapeau occupé, nom, luminosité, données de pixels)
- POST /api/shape/save – valide le numéro d’emplacement et le tableau de pixels, puis écrit la forme dans LittleFS et actualise la liste du diaporama
- POST /api/shape/display – charge un emplacement enregistré en mémoire et le restitue (arrête également tout diaporama en cours)
- POST /api/shape/delete – supprime le fichier et si cet emplacement est actuellement affiché, la matrice est effacée
- POST /api/preview – applique une forme et une luminosité temporaires sans les enregistrer
- POST /api/clear – désactive la matrice et si le diaporama est en cours d’exécution, il l’arrête également
- POST /api/slideshow – démarre/arrête le cycle à travers la séquence de formes et définit l’intervalle (minimum 100 ms)
installation()
Dans setup(), il initialise le Serial Monitor, monte LittleFS (formate si nécessaire et crée le répertoire /shapes), initialise la bande FastLED, se connecte au réseau Wi-Fi configuré et imprime l’adresse IP ESP32.
void setup() {
Serial.begin(115200);
// Initialize LittleFS and create the shapes directory if it doesn't exist
if (!LittleFS.begin(true)) {
Serial.println("LittleFS mount failed even after format attempt.");
}
if (!LittleFS.exists(SHAPES_DIR)) {
LittleFS.mkdir(SHAPES_DIR);
}
refreshSlideshowOrder();
// Initialize FastLED
FastLED.addLeds(leds, NUM_LEDS);
FastLED.setBrightness(BRIGHTNESS);
FastLED.clear();
FastLED.show();
// Start the Wi-Fi connection
WiFi.begin(ssid, password);
Serial.print("Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println("\nWi-Fi Connected!");
// Print the ESP32 IP Address
Serial.print("Access ESP32 IP Address: http://");
Serial.println(WiFi.localIP());
(...)
Enfin, il crée toutes les routes Web mentionnées dans la section précédente et démarre le serveur Web asynchrone.
setupWebServerRoutes();
server.begin();
Animation du diaporama
Lorsqu’elle est active, la fonction updateSlideshow() est appelée à chaque boucle(), puis elle vérifie si l’intervalle configuré est écoulé. Il parcourt ensuite la liste de tous les emplacements occupés, charge la forme suivante et l’affiche sur la matrice physique. La liste des emplacements de forme occupés est automatiquement mise à jour chaque fois que des formes sont enregistrées ou supprimées.
void loop() {
updateSlideshow();
}
Démonstration
Après avoir inséré vos informations d’identification réseau, téléchargez le code sur la carte ESP32. Ouvrez le moniteur série à un débit en bauds de 115 200 et appuyez sur le bouton ESP32 RST.

L’adresse IP de l’ESP32 sera imprimée dans le moniteur série.

Ouvrez n’importe quel navigateur sur votre réseau local et entrez votre adresse IP ESP32. Une page Web similaire devrait se charger.

L’interface utilisateur de l’éditeur de formes matricielles comporte trois sections principales : l’éditeur de grille, la galerie avec les formes enregistrées et l’animation du diaporama.
Dans la page Web de l’éditeur de forme de grille 8 × 8, vous pouvez définir une couleur personnalisée, puis sélectionner chaque pixel de la grille pour dessiner des formes personnalisées. Vous disposez également d’un curseur de contrôle de la luminosité qui ajuste la luminosité de l’ensemble de la forme.
Vous pouvez définir le nom de la forme et la position de l’emplacement pour enregistrer vos formes sur l’ESP32 dans LittleFS au format JSON (afin qu’elles restent stockées même après un redémarrage). Vous pouvez utiliser les boutons pour prévisualiser le dessin actuel dans la matrice, effacer la grille de la page Web ou désactiver la matrice physique.

Dans l’autre section, vous disposez d’une galerie avec un aperçu de toutes les formes enregistrées. Lorsque vous cliquez sur une forme enregistrée, elle l’affiche sur la matrice physique et la charge à nouveau dans l’éditeur afin que vous puissiez la modifier. Vous pouvez également utiliser la croix rouge dans le coin supérieur droit pour supprimer toute forme enregistrée.

Enfin, vous disposez de la section d’animation du diaporama où vous pouvez activer le bouton bleu pour exécuter un diaporama qui parcourt toutes les formes enregistrées avec un intervalle de temps réglable en millisecondes (ms).

Ci-dessous, vous pouvez voir à quoi ressemblent certaines formes lorsqu’elles sont affichées sur la matrice.

Vous pouvez regarder la prochaine courte vidéo qui est une démonstration en direct de ce projet montrant toutes ses fonctionnalités.
Conclusion
Dans ce projet, nous avons créé un serveur Web qui vous permet de dessiner des formes personnalisées et de créer des animations à l’aide d’un panneau matriciel LED RVB WS2812B 8×8 avec la bibliothèque FastLED. 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 :

-
2 Pièces ESP32 NodeMCU USB C, Carte de Développement ESP32, Module WiFi 2,4 GHz Bluetooth Dual-Core avec Puce CH340, Compatible Arduino IDE, MicroPython et IoT pour Domotique, Capteurs, Automatisation
-
2PCS Carte de Développement ESP32 USB C avec Puce CH340 NodeMCU WROOM 32 | 2,4 GHz WiFi + Bluetooth, Dual Core Microcontrôleur pour Arduino, Support MicroPython, NodeMCU, AP/STA/AP+STA, 30PIN Broches
