La bibliothèque WS2812B conviviale pour le CMoz ESP32-S3 Mini — conçue pour les vêtements connectés (wearables) et la mode technologique par TinkerTailor.ca et la chaîne CMozMaker.

--> Vous voulez que le code soit écrit pour vous et vous souhaitez modifier les effets ? Générateur de code interactif

Votre CMoz ESP32-S3 Mini dispose déjà d'une LED adressable intégrée (sur le GPIO 3). Cette bibliothèque permet à cette dernière — et à toute bande LED que vous ajouteriez — de briller magnifiquement avec environ cinq lignes de code, et elle vous parle en français clair lorsqu'un problème survient.

---

	CMozGlow	Bibliothèques LED classiques
Messages d'erreur en français clair	✅ errorText() vous indique exactement quoi corriger	❌ échec silencieux ou plantage
Gestion intelligente de la batterie	✅ définissez une limite en mA, l'intensité baisse automatiquement	⚠️ cachée ou absente
Pixel d'état en direct	✅ pixel intégré : vert = tout va bien, rouge = erreur	❌
Effets non bloquants intégrés	✅ update() dans loop() — pas de delay()	⚠️ les exemples sont souvent bloquants
Moteur matériel asynchrone	✅ show() revient en ~100 µs même sur de longues bandes	⚠️ bloque ~30 µs × nombre de LED
Mode AutoPilot double cœur	✅ une ligne permet d'allouer les LED à leur propre cœur CPU	❌
Effets pour la mode technologique	✅ Sequin, Catwalk, Loom, Silk, Aurora, Morse…	❌ principalement des arcs-en-ciel
Couleurs corrigées par gamma	✅ activé par défaut — les couleurs correspondent à vos réglages	⚠️ désactivé par défaut

Comme les effets ne sont jamais bloquants, vos boutons, capteurs et code Bluetooth continuent de fonctionner pendant l'animation des lumières — essentiel pour les vêtements interactifs.

---

PlatformIO — ajoutez le dossier de la bibliothèque au répertoire lib/ de votre projet, ou une fois publié :

; platformio.ini
[env:cmoz_s3_mini]
platform  = espressif32
board     = esp32-s3-devkitc-1
framework = arduino
lib_deps  = cmoz/CMozGlow @ ^1.2.2

Arduino IDE — Croquis → Inclure une bibliothèque → Ajouter la bibliothèque .ZIP… et choisissez CMozGlow.zip. Puis, dans Outils :

• Board : ESP32S3 Dev Module
• USB CDC On Boot : Enabled (Activé) ← ne sautez pas cette étape ! C'est ce qui permet au Serial (et aux messages d'erreur conviviaux de CMozGlow) d'atteindre le Moniteur Série via le port USB.

Ouvrez Fichier → Exemples → CMozGlow → CMozGlow_Basics, ou collez ceci :

#include <CMozGlow.h>

// ══════════ MODIFIEZ CECI ══════════
const uint8_t  EFFECT   = 8;    // 0-9, tableau ci-dessous
const uint16_t NUM_LEDS = 1;    // intégré uniquement = 1
const uint8_t  SPEED    = 5;    // 1 doux … 10 festif
const uint32_t COLOR    = CMozGlow::Color(255, 42, 120);
const uint8_t  LED_PIN  = 3;    // GPIO 3 = pixel intégré ; changez pour d'autres cartes
// ══════════════════════════════════

CMozGlow glow(NUM_LEDS, LED_PIN);

void setup() {
  Serial.begin(115200);
  if (!glow.begin()) {
    Serial.println(glow.errorText());   // il vous dit quoi corriger !
    while (true) delay(1000);
  }
  glow.setPowerBudgetmA(450);           // sûr sur USB ou petite LiPo
  glow.setEffect(EFFECT);
  glow.setEffectColor(COLOR);
  glow.setEffectSpeed(SPEED);
}

void loop() {
  glow.update();                        // c'est tout !
}

Téléversez. Le pixel intégré devrait commencer à danser comme une aurore. Changez le numéro de l' EFFECT, téléversez à nouveau, répétez. Cette unique constante suffit pour découvrir toutes les options.

Connectez le DIN de votre bande WS2812B au GPIO 3, GND au GND, et 5V à une alimentation appropriée. Le pixel intégré devient le pixel 0 et votre bande commence à partir du pixel 1.

🧵 Règle d'or : NUM_LEDS = 1 + longueur de votre bande. Une bande de 12 LED signifie NUM_LEDS = 13.

Le GPIO 3 est seulement la broche par défaut, car c'est là que se trouve le pixel intégré de la carte CMoz. N'importe quelle broche de sortie valide fonctionne — passez-la comme second argument :

CMozGlow glow(NUM_LEDS, 6);     // 20 LED sur GPIO 6

Chaque exemple dispose d'une constante LED_PIN en haut pour exactement cela. Et CMozGlow n'est pas limité à CMoz — il fonctionne sur n'importe quelle carte de la famille ESP32 : ESP32-S3, ESP32-S2, ESP32-C3 et l'ESP32 classique. Il connaît le brochage réel de chaque puce et vous indiquera en français clair si vous choisissez une broche qui ne peut pas piloter de LED :

puce	broches fonctionnelles
ESP32-S3	0–21, 33–48
ESP32-S2	0–21, 33–46
ESP32-C3	0–10, 18–21
ESP32 classique	0–5, 12–19, 21–23, 25–27, 32, 33

Sur une carte sans pixel intégré, NUM_LEDS est simplement la longueur de votre bande — la règle d'or ci-dessus ne s'applique qu'aux cartes comme la CMoz qui en possèdent une intégrée.

---

#	Nom	Constante	Description
0	Solid	CMOZ_FX_SOLID	couleur fixe
1	Sequin	CMOZ_FX_SEQUIN	éclats aléatoires, comme des paillettes sous les projecteurs
2	Catwalk	CMOZ_FX_CATWALK	un balayage audacieux avec traînée fondu
3	Loom	CMOZ_FX_LOOM	deux "fils" colorés qui s'entrecroisent
4	Heartbeat	CMOZ_FX_HEARTBEAT	battement double réaliste (lub-dub)
5	Firefly	CMOZ_FX_FIREFLY	lumières douces qui respirent à des endroits aléatoires
6	Silk	CMOZ_FX_SILK	reflets lents, comme la lumière sur du tissu
7	Ember	CMOZ_FX_EMBER	lueur chaleureuse de feu de camp
8	Aurora	CMOZ_FX_AURORA	aurores boréales 🇨🇦
9	Morse	CMOZ_FX_MORSE	fait clignoter un message en code Morse

Tous les effets respectent setEffectColor() (sauf Ember et Aurora, qui utilisent leurs propres palettes) et setEffectSpeed(1–10).

Astuce Morse : définissez votre message en premier — glow.setMorseMessage("MEET AT 9"); — lettres, chiffres et espaces, jusqu'à 63 caractères. Fantastique pour les badges et les défis de décodage en classe.

---

Chaque WS2812B peut consommer jusqu'à 60 mA en blanc total. Treize pixels en blanc total représentent près de 0,8 A — plus que ce qu'un port USB ou une petite batterie LiPo peut fournir.

CMozGlow vous protège :

glow.setPowerBudgetmA(450);   // ne jamais dépasser ~450 mA

Avant chaque image, la bibliothèque estime la consommation de courant et, si vous dépassez le budget, elle réduit silencieusement l'intensité. Vous pouvez vérifier ce qui s'est passé :

Serial.println(glow.estimatedCurrentmA()); // consommation approx. de la dernière image
Serial.println(glow.powerLimited());       // 1 si la réduction auto. a eu lieu

Budgets suggérés : port USB ≈ 450 mA, petite LiPo (400 mAh) ≈ 250 mA, alimentation dédiée 5 V/2 A ≈ 1500 mA. L'estimation est une approximation (~20 mA par canal de couleur à pleine puissance + ~1 mA par puce au repos) — gardez toujours une marge.

---

L'ESP32-S3 possède deux cœurs de processeur, et le loop() de votre croquis s'exécute sur le cœur 1. AutoPilot lance une petite tâche d'arrière-plan sur le cœur 0 qui anime les LED en continu :

glow.setEffect(CMOZ_FX_AURORA);
glow.autoUpdate(true);      // ✈️ décollage — plus besoin de update()

C'est tout. Votre loop() est maintenant libre à 100 % pour vos capteurs, Bluetooth, tactile et servos — l'animation s'exécute littéralement sur une partie différente du silicium. Chaque appel CMozGlow reste sûr à utiliser en cours de vol (setEffect(), setPixel(), setBrightness(), couleurs, vitesse — tout), car toute la bibliothèque est protégée par un mutex récursif. Désactivez-le à tout moment avec glow.autoUpdate(false); autoRunning() vous informe de l'état actuel.

Bon à savoir :

• Quand l'utiliser — projets interactifs où le loop() effectue un vrai travail : échantillonnage tactile capacitif, BLE, code audio-réactif, asservissement de servos. Pour un simple croquis "lumières seulement", leupdate() classique dans le loop() suffit amplement.
• Les appels manuels show()/update() sont sans risque mais inutiles en cours d'exécution — AutoPilot effectue déjà le rendu selon le programme, et le minuteur d'image empêche tout double affichage.
• Le cœur 0 est également le cœur Wi-Fi/BLE. La tâche de rendu est légère (priorité 1, en veille entre les images), ils cohabitent donc sans problème, mais si vous générez un trafic Wi-Fi intense et utilisez plus de 500 LED, vérifiez vos temps de traitement.
• L'arrêt est propre. autoUpdate(false) et end() attendent que la tâche confirme son arrêt et que le matériel termine l'image en cours avant toute manipulation de mémoire. Aucune tâche suspendue, aucune erreur d'accès à la mémoire libérée (use-after-free) — jamais.

Essayez Fichier → Exemples → CMozGlow → CMozGlow_AutoPilot : il compte les tours de loop() par seconde afin que vous puissiez constater à quel point votre programme est déchargé.

---

Chaque appel susceptible d'échouer renvoie false et enregistre une raison :

if (!glow.setPixel(999, 255, 0, 0)) {
  Serial.println(glow.errorText());
  // "l'index du pixel dépasse la fin du ruban — les index vont de 0 à numPixels()-1"
}

Utilisez le pixel embarqué comme voyant d'état en direct — idéal pour déboguer un costume sur lequel vous ne pouvez pas brancher de moniteur série :

glow.statusPixel(true);   // pixel 0 : vert pâle = tout va bien, rouge = une erreur est survenue

Code	Signification
CMOZ_OK	tout est normal
CMOZ_ERR_NOT_BEGUN	begin() n'a pas été appelé ou a échoué
CMOZ_ERR_BAD_PIN	cette broche GPIO ne peut pas piloter de LED (utilisez 0–21 ou 33–48)
CMOZ_ERR_BAD_COUNT	le nombre de LED doit être compris entre 1 et 2000
CMOZ_ERR_ALLOC	mémoire insuffisante (ruban trop long)
CMOZ_ERR_RMT	échec du démarrage du périphérique LED
CMOZ_ERR_INDEX	l'index du pixel dépasse la fin du ruban
CMOZ_ERR_BAD_EFFECT	le numéro d'effet n'existe pas (valides : 0–9)
CMOZ_ERR_BAD_ARG	argument hors limites
CMOZ_ERR_TASK	la tâche d'arrière-plan d'AutoPilot n'a pas pu démarrer ou s'arrêter

Utilisez glow.lastError() pour le code, glow.errorText() pour la description, et glow.clearError() pour réinitialiser.

---

CMozGlow glow(numLeds);            // GPIO 3 par défaut
CMozGlow glow(numLeds, pin);       // ou toute broche de sortie ESP32-S3 valide

bool begin();                      // appeler une fois dans setup() ; false = vérifier errorText()
void end();

// pixels
bool setPixel(i, r, g, b);         // 0-255 chacun
bool setPixel(i, color);           // format 0xRRGGBB
uint32_t getPixel(i);
void fill(color);
void clear();
bool show();                       // transmettre l'image au matériel ; retourne en ~µs
uint16_t numPixels();

// aspect
void setBrightness(0-255);         // variateur principal non destructif
void setGamma(true/false);         // correction gamma, activée par défaut

// sécurité portable
void setPowerBudgetmA(mA);         // 0 = illimité
uint16_t estimatedCurrentmA();
bool powerLimited();

// effets (non bloquants)
bool setEffect(0-9);               // ou constantes CMOZ_FX_…
void setEffectColor(color);
bool setEffectSpeed(1-10);
bool setMorseMessage("TEXT 123");
bool update();                     // à appeler dans chaque loop() ; true lors du rendu
static const char* effectName(id);

// AutoPilot (avancé)
bool autoUpdate(true/false);       // attribuer aux LED leur propre cœur CPU / arrêter
bool autoRunning();

// erreurs
CMozError lastError();
const char* errorText();
void clearError();
void statusPixel(true/false);      // pixel embarqué comme témoin d'état

// outils couleur
CMozGlow::Color(r, g, b);          // créer une couleur
CMozGlow::Wheel(0-255);            // parcourir l'arc-en-ciel

---

Rien ne s'allume. Consultez d'abord le message de errorText() dans le Serial. Ensuite : LED_PIN correspond-il bien à la broche utilisée par le DIN de votre ruban ? Le ruban et la carte partagent-ils une masse (GND) commune ? NUM_LEDS est-il au moins égal à 1 ?

Seul le pixel embarqué fonctionne. NUM_LEDS est probablement resté à 1 — n'oubliez pas d'ajouter la longueur de votre ruban. Vérifiez également que la flèche sur le ruban pointe bien à l'opposé de la carte (les données circulent dans une seule direction).

Les couleurs semblent ternes. C'est probablement le budget énergétique qui fait son travail — vérifiez powerLimited(). N'augmentez ce budget que si votre source d'alimentation peut le supporter.

Les couleurs semblent "fausses" par rapport à une autre bibliothèque. CMozGlow effectue une correction gamma par défaut pour que les mélanges de couleurs paraissent naturels. Pour des valeurs brutes, appelez glow.setGamma(false);.

Le premier pixel scintille avec un long ruban. Les longs câblages bénéficient d'une résistance de 300–500 Ω sur la ligne de données et d'un condensateur de 500–1000 µF aux bornes de l'alimentation — disponibles sur TinkerTailor.ca. 😉

La compilation et l'exécution fonctionnent, mais le moniteur série n'affiche rien. Dans Outils, assurez-vous que Board = ESP32S3 Dev Module et USB CDC On Boot = Enabled, puis téléversez à nouveau. Sans le CDC activé, le S3 envoie les données série vers un port UART auquel vous n'êtes pas connecté.

Erreur ctags "cannot open temporary file" avant la compilation (Windows). Cela ne vient pas de votre programme — il s'agit de fichiers obsolètes dans le dossier temporaire de Windows. Fermez l'IDE, appuyez sur Win + R, tapez %TEMP%, supprimez le contenu et réessayez.

La compilation réussit mais begin() renvoie false. Affichez errorText() — il précisera le problème exact (broche incorrecte, trop de LED, mémoire insuffisante ou périphérique RMT utilisé par une autre bibliothèque).

Vous utilisez du fil conducteur ? Gardez la ligne de données courte et cousez une ligne de masse le long de celle-ci. Les données des WS2812B sont sensibles au timing ; avec moins de 30 cm de fil, cela fonctionne généralement bien à une luminosité adaptée aux vêtements.

---

CMozGlow pilote les LED avec le périphérique RMT de l'ESP32-S3 — un composant matériel qui génère seul la forme d'onde complexe de 800 kHz des WS2812B — et il le fait de manière asynchrone : show() construit l'image (via une table de correspondance octet→forme d'onde précalculée), la transmet au matériel et rend la main immédiatement pendant que les LED sont en cours de rafraîchissement. L'intervalle obligatoire de "verrouillage" ≥280 µs est encodé à la fin de chaque transfert matériel, donc il n'y a aucune attente active (busy-waiting) dans la bibliothèque. Le prochain show() vérifie simplement que l'image précédente a bien quitté le fil — ce qui est largement le cas à n'importe quel taux de rafraîchissement normal.

Résultat pratique : sur un ruban de 200 LED, un envoi bloquant traditionnel fige votre programme pendant ~6 ms par image ; CMozGlow gère le transfert en environ 100 µs. Ajoutez AutoPilot, et le coût pour votre loop() est nul.

Cela fonctionne automatiquement sur les noyaux arduino-esp32 2.x et 3.x, et est thread-safe.

---

Fabriqué avec 💛 au Canada · Sous licence MIT · Tutoriels sur la chaîne YouTube CMozMaker · Pièces & tissus conducteurs sur TinkerTailor.ca