Leçons · Leçon A4 · Actionneurs et moteurs · 35 min
Les DEL adressables
Allume un anneau de DEL NeoPixel avec une seule broche de données, mélange les couleurs avec des nombres de rouge, de vert et de bleu, et calcule le courant dont l’anneau a besoin. Environ 35 minutes, avec un mélangeur de couleurs que tu peux déplacer.
Un seul fil pour beaucoup de lumières
Allumer douze DEL ordinaires demande douze broches et douze résistances. Les DEL adressables fonctionnent autrement. L’anneau que tu vas utiliser a douze petites DEL sur un seul circuit imprimé, et tout l’anneau ne demande qu’un seul fil de données depuis ta carte [4][5].
Adafruit les vend sous le nom de NeoPixels. Chaque « pixel » est une petite unité de DEL avec une DEL rouge, une verte et une bleue, et son propre petit contrôleur intégré [3]. La plupart utilisent la puce WS2812 ou une proche cousine [3]. Les données de couleur entrent par l’entrée de données (DIN) du premier pixel. Le côté sortie peut rester libre, ou alimenter la chaîne suivante [4].
Dans cette leçon, tu vas :
- brancher un anneau avec une résistance et un condensateur, comme Adafruit le recommande,
- choisir une couleur sous forme de trois nombres, et l’envoyer avec une bibliothèque,
- calculer le courant dont un anneau a besoin, et le garder sous contrôle.
Les couleurs sont des nombres
Chaque pixel mélange ses DEL rouge, verte et bleue. Tu lui donnes trois nombres, chacun de 0 (éteint) à 255 (plein) [7].
| Couleur | Rouge | Vert | Bleu |
|---|---|---|---|
| rouge | 255 | 0 | 0 |
| vert | 0 | 255 | 0 |
| bleu | 0 | 0 | 255 |
| magenta (rouge + bleu) | 255 | 0 | 255 |
| blanc (les trois) | 255 | 255 | 255 |
L’exemple d’Adafruit fabrique du magenta avec 255, 0, 255 [7]. Essaie d’autres mélanges dans le widget ci-dessous et compare avec ce que l’anneau montrera plus tard.
Dans le programme, strip.setPixelColor(n, red, green, blue) colore le pixel numéro n, compté à partir de 0 [7]. La bibliothèque sait aussi regrouper les trois nombres en un seul nombre de 32 bits avec strip.Color(r, g, b) [7].
Simulation et estimation, pas une mesure.
Règle pratique : 12 × 20 mA = 240 mA
Pire cas (blanc à fond, luminosité max) : 12 × 60 mA = 720 mA
Moins d’environ 500 mA pour cette couleur. L’anneau a quand même son propre bloc.
Voici l’état de départ : les commandes ont besoin de JavaScript.
Combien de courant ?
Voici les chiffres d’Adafruit [1] :
- Un pixel consomme jusqu’à 60 mA en blanc à la luminosité maximale (rouge, vert et bleu à fond).
- En usage réel, avec des couleurs mélangées et des animations, c’est bien moins. Adafruit utilise 20 mA par pixel comme règle pratique.
Pour un anneau de 12 :
- règle pratique : 12 × 20 mA = 240 mA (0,24 A)
- pire cas : 12 × 60 mA = 720 mA (0,72 A)
Ton alimentation doit pouvoir fournir au moins le pire cas si tu allumes un jour tout en blanc. Adafruit précise aussi que des ampères en trop ne gênent pas, car les pixels ne prennent que ce dont ils ont besoin, mais que des volts en trop, si [1].
Pourquoi pas la broche 3V3 de la carte ? Règle de la maison : n’alimente jamais un anneau, ni aucune pièce à beaucoup de DEL, avec la broche 3V3. Les pixels sont conçus pour environ 5 V [1]. Adafruit dit que même la broche 5V d’une carte Arduino ne peut fournir qu’environ 500 mA, et que dans le doute il faut donner aux pixels une alimentation séparée [4]. Le pire cas d’un anneau est de 720 mA.
Garde-le bas. La bibliothèque a strip.setBrightness(), un nombre de 0 à 255 qui limite la luminosité et le courant de tous les pixels. Adafruit dit de l’appeler une seule fois, dans setup(), et de ne pas s’en servir pour l’animation [7].
Alimentation et données : les règles
Les bonnes pratiques d’Adafruit, pour un débutant [1][2][3][4] :
- L’anneau a sa propre alimentation. Un boîtier de 3 piles AA alcalines avec interrupteur donne environ 4,5 V [1]. On le choisit exprès : à 4,5 V, les données à 3,3 V de l’ESP32 sont assez fortes pour les pixels (écran 5) [3]. Jamais quatre piles alcalines : elles donnent environ 6 V, trop pour certains NeoPixels et franchement trop pour le microcontrôleur [1]. Une tension U plus basse convient, avec une lumière un peu plus faible [1].
- Un gros condensateur sur l’alimentation de l’anneau. Adafruit suggère 500 à 1000 µF, prévu pour 6,3 V ou plus, entre le + et le − [1][2]. Nous en choisissons un prévu pour 10 V ou plus, et 16 V donne une marge confortable. C’est un condensateur électrolytique, il a donc un sens : la bande (et souvent la patte la plus courte) marque sa patte −, qui va au GND ; l’autre patte va au + de l’anneau [1]. Ne le monte jamais à l’envers. Il adoucit les brusques changements de courant [2].
- Une résistance sur le fil de données. Mets 300 à 500 Ω entre la broche de données et l’entrée de données de l’anneau, du côté le plus proche de l’anneau [2]. Nous prenons 330 Ω. Elle aide à protéger le premier pixel des pointes de tension [1].
- La masse d’abord. Quand tu branches sur une source sous tension, connecte la masse (−) avant tout le reste, et débranche-la en dernier [1][4].
- Les pixels d’abord, la carte ensuite. Alimente les pixels avant le microcontrôleur. Sinon, ils peuvent essayer de s’alimenter par le fil de données [2]. Ici : allume le boîtier de piles, puis branche l’USB.
- Masse commune. La masse de l’anneau va à la fois au − de l’alimentation et à une broche GND de l’ESP32 [4].
- Côté entrée seulement. Branche l’entrée de données, jamais la sortie [4]. Utilise les repères imprimés sur ton anneau [4].
- Soudure. Les anneaux demandent souvent des fils soudés sur leurs plots, et les plots sont minuscules : attention aux bavures de soudure [5]. Voir la leçon M1.
Données à 3,3 V, pixels à 5 V
Ton ESP32 envoie ses données à 3,3 V (leçon E4). Les pixels sont des « appareils à 5 V » [1]. Est-ce un problème ?
La réponse d’Adafruit : parfois. Le fabricant recommande un signal de données d’au moins 70 % de la tension d’alimentation des pixels [1], un chiffre qu’Adafruit appelle une règle pratique [3]. À 5 V, cela fait 3,5 V, un peu au-dessus de 3,3 V. C’est pour ça que notre anneau marche avec 3 piles alcalines : environ 4,5 V, et 70 % de 4,5 V font 3,15 V, en dessous des 3,3 V des données. Adafruit prend exactement cet exemple et dit qu’une logique à 3,3 V est alors assez robuste [3]. Des piles alcalines neuves démarrent plutôt vers 4,8 V (notre estimation, pas celle d’Adafruit), et 70 % de cela font 3,36 V, juste au-dessus de 3,3 V. Donc si le premier pixel scintille ou si les couleurs sont fausses, vérifie d’abord la masse commune, puis ajoute l’adaptateur de niveau 74AHCT125 (la solution de repli plus bas). Mais la vraie limite varie d’une marque de pixels à l’autre, et certaines pièces « compatibles WS2812 » acceptent moins [3]. Adafruit dit que beaucoup de projets marchent sans aucune correction, mais ajoute qu’un projet peut marcher sur ton bureau et échouer ailleurs [3].
Deux façons d’être tranquille, d’après Adafruit [1][3] :
- Baisser la tension d’alimentation des pixels pour qu’elle se rapproche de celle du signal.
- Ajouter un adaptateur de niveau logique entre la carte et le premier pixel. Adafruit cite des puces comme le 74AHCT125 et le 74HCT245 [4].
Notre câblage utilise la première façon : le boîtier de 4,5 V. Si les couleurs sont encore fausses ou si ça scintille, vérifie d’abord la masse commune, puis un adaptateur de niveau est le remède suivant [3][4].
Commander l’anneau
Il te faut la bibliothèque « Adafruit NeoPixel ». Dans l’IDE Arduino : Croquis, Inclure une bibliothèque, Gérer les bibliothèques, cherche « NeoPixel », installe « Adafruit NeoPixel by Adafruit » [6]. Elle prend en charge l’ESP32 [8].
Le programme dessine une petite « comète » qui fait le tour de l’anneau. Chaque appui sur le bouton change sa couleur, et le moniteur série affiche les trois nombres.
// Tinker Mission, leçon A4 : une comète de lumière sur un anneau NeoPixel de 12 pixels, les couleurs en nombres RGB
// Câblage (l'anneau a sa PROPRE alimentation : ne la prends jamais sur la broche 3V3) :
// Plot d'entrée de données de l'anneau (DIN ou IN) -> une résistance de 330 ohms -> GPIO 23 (place la résistance près de l'anneau)
// Plot d'alimentation de l'anneau (5V ou PWR) -> + d'une alimentation séparée (3 piles AA alcalines = environ 4,5 V ; JAMAIS 4 alcalines = 6 V)
// Plot GND de l'anneau -> - de cette alimentation ET une broche GND de l'ESP32 (masse commune)
// (utilise les repères imprimés sur TON anneau ; branche le côté entrée de données, jamais le côté sortie)
// Un condensateur de 1000 uF, 10 V ou plus, entre le 5V et le GND de l'anneau (bande = patte -, côté GND)
// Bouton : une patte à la GPIO 27, la patte diagonalement opposée à GND (pas de résistance nécessaire)
// Ordre de branchement : la masse d'abord. Allume le boîtier de piles AVANT de brancher le câble USB.
// Chaque appui change la couleur. Le moniteur série affiche les trois nombres (rouge, vert, bleu).
// Il faut la bibliothèque « Adafruit NeoPixel » (Croquis > Inclure une bibliothèque > Gérer les bibliothèques).
#include <Adafruit_NeoPixel.h>
const int DATA_PIN = 23;
const int BUTTON_PIN = 27;
const int LED_COUNT = 12; // change ce nombre pour qu'il corresponde à ton anneau
const uint8_t BRIGHTNESS = 40; // limite de 0 à 255, réglée une seule fois dans setup()
const int TAIL = 4; // la comète est sa tête plus 3 pixels plus faibles
const unsigned long STEP_MS = 80;
Adafruit_NeoPixel strip(LED_COUNT, DATA_PIN, NEO_GRB + NEO_KHZ800);
struct Colour {
const char* name;
uint8_t red;
uint8_t green;
uint8_t blue;
};
const Colour COLOURS[] = {
{ "red", 255, 0, 0 },
{ "green", 0, 255, 0 },
{ "blue", 0, 0, 255 },
{ "yellow", 255, 255, 0 }, // rouge + vert
{ "magenta", 255, 0, 255 }, // rouge + bleu
{ "cyan", 0, 255, 255 }, // vert + bleu
{ "white", 255, 255, 255 }, // les trois : la couleur la plus gourmande
};
const int COLOUR_COUNT = sizeof(COLOURS) / sizeof(COLOURS[0]);
int colourIndex = 0;
int head = 0;
bool wasPressed = false;
unsigned long lastStep = 0;
void printColour() {
const Colour& c = COLOURS[colourIndex];
Serial.print(c.name);
Serial.print(": red ");
Serial.print(c.red);
Serial.print(", green ");
Serial.print(c.green);
Serial.print(", blue ");
Serial.println(c.blue);
}
// Dessine la comète : la tête en pleine couleur, chaque pixel derrière deux fois plus faible que le précédent.
void drawComet() {
const Colour& c = COLOURS[colourIndex];
strip.clear();
for (int i = 0; i < TAIL; i++) {
int pixel = (head - i + LED_COUNT) % LED_COUNT;
strip.setPixelColor(pixel, c.red >> i, c.green >> i, c.blue >> i);
}
strip.show();
}
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
strip.begin();
strip.setBrightness(BRIGHTNESS); // une seule fois, ici : cela limite le courant pour tout le programme
strip.show(); // départ avec tous les pixels éteints
printColour();
}
void loop() {
bool pressed = (digitalRead(BUTTON_PIN) == LOW);
if (pressed && !wasPressed) { // vient d'être appuyé (pas maintenu)
colourIndex = (colourIndex + 1) % COLOUR_COUNT;
printColour();
}
wasPressed = pressed;
if (millis() - lastStep >= STEP_MS) {
lastStep = millis();
head = (head + 1) % LED_COUNT;
drawComet();
}
delay(5);
}
Télécharger le dossier du croquis (.zip)
Ouvre le moniteur série à 115200 baud.
Comment le lire :
Adafruit_NeoPixel strip(LED_COUNT, DATA_PIN, NEO_GRB + NEO_KHZ800)crée l’objet anneau : combien de pixels, quelle broche, et le type de pixel.NEO_GRB + NEO_KHZ800convient à la plupart des produits NeoPixel [7].strip.begin()prépare la broche de données.strip.show()juste après envoie « tout éteint » [7].strip.setBrightness(BRIGHTNESS)limite la lumière et le courant une seule fois, ici danssetup(), comme Adafruit le conseille [7]. À 40 sur 255, chaque couleur est ramenée à environ 16 % : la comète blanche ne demande qu’environ 20 mA, et même l’anneau entier en blanc resterait vers 0,12 A au lieu de 0,72 A (une estimation, pas une mesure) [1][7].drawComet()prépare les couleurs, puisshow()les envoie toutes d’un coup [7]. La tête a la pleine couleur. Chaque pixel derrière reçoit la moitié du précédent, avec>> i, qui divise un nombre par deuxifois.- La comète avance avec
millis(), pas avecdelay(), comme dans la leçon K4. Le bouton est surveillé en permanence, donc la couleur change tout de suite. strip.clear()éteint tous les pixels dans les données préparées [7].
Essaie tes propres changements
Change une seule chose, téléverse, observe.
- Ta propre couleur. Ajoute une ligne à
COLOURS, par exemple orange,{ "orange", 255, 80, 0 }. L’anneau montre-t-il ce que tu attendais ? Change les nombres un peu à la fois. - Mélange avec des nombres. Avant de téléverser, devine à quoi ressemblera
255, 255, 0. Puis vérifie avec l’anneau et le widget. - La luminosité. Mets
BRIGHTNESSà 10, puis à 100. La différence est-elle celle que tu attendais ? N’arrive jamais à 255 en blanc, sauf si ton alimentation peut fournir le pire cas [1]. - Vitesse et queue. Change
STEP_MSetTAIL. Que se passe-t-il avecTAILà 1 ? - Deux comètes. Dessine une deuxième tête du côté opposé de l’anneau,
LED_COUNT / 2pixels plus loin. - La taille de ton anneau. Change
LED_COUNTpour qu’il corresponde à ton anneau. Les anneaux existent en plusieurs tailles, par exemple 12, 16 ou 24 pixels [5].
Quand ça ne marche pas
- Rien ne s’allume. Vérifie que tu as branché le côté entrée de données, pas la sortie [4]. Vérifie que le boîtier de piles est allumé et que la masse de l’anneau rejoint à la fois le boîtier et l’ESP32 [4].
- Mauvaises couleurs, ou clignotement bizarre. Vérifie d’abord que l’anneau, l’alimentation et la carte ont une masse commune : le GND de l’anneau doit aller à la fois au − de l’alimentation et à une broche GND de la carte [4]. Si tes pixels ont aussi une DEL blanche (RGBW), la déclaration demande
NEO_RGBWau lieu deNEO_GRB[4][7]. - Scintillement aléatoire, ou mauvaises couleurs au bout de l’anneau. Le signal de données est peut-être trop faible : essaie un adaptateur de niveau (écran 5) [3]. Garde le fil de données court [2]. Un gros condensateur calme aussi les brusques changements de courant [2].
- L’anneau ou le boîtier de piles chauffe. Baisse
BRIGHTNESSet compare ton alimentation avec les chiffres de courant [1]. - Ça marchait, puis tu as branché dans un autre ordre et ça ne marche plus. Allume le boîtier de piles avant l’USB, et connecte la masse en premier [1][2].
- « Adafruit_NeoPixel.h: No such file » à la compilation. La bibliothèque n’est pas encore installée [6].
- Rien dans le moniteur série. Règle-le sur 115200 baud, comme
Serial.begin(115200).
Vérifie-toi
Trois petites questions. Rien n’est enregistré, prends ton temps.
Un anneau a 12 pixels, tous allumés en blanc à pleine luminosité. Quel est le courant dans le pire cas, avec la valeur de jusqu’à 60 mA par pixel ?
- 60 mA
- 240 mA
- 720 mA
Tu appelles strip.setPixelColor(3, 0, 0, 255) et rien ne se passe sur l’anneau. Pourquoi ?
- La couleur n’est pas envoyée tant que tu n’appelles pas strip.show()
- Le bleu demande une luminosité de 0
- Le pixel 3 n’existe pas
Voir la réponse
La couleur n’est pas envoyée tant que tu n’appelles pas strip.show(). setPixelColor() n’a pas d’effet immédiat : il prépare la couleur, et show() l’envoie aux pixels [7]. Les pixels sont comptés à partir de 0 : le pixel 3 est donc le quatrième, et les trois nombres sont le rouge, le vert et le bleu, de 0 à 255 [7].
D’où l’anneau doit-il tirer son alimentation ?
- De la broche 3V3 de la carte, c’est la plus proche
- D’une alimentation séparée qui lui convient, avec sa masse reliée au GND de la carte
- De la broche de données elle-même
Voir la réponse
D’une alimentation séparée qui lui convient, avec sa masse reliée au GND de la carte. Un anneau peut demander plusieurs centaines de milliampères [1], alors que même la broche 5V d’une carte Arduino ne fournirait qu’environ 500 mA, d’après Adafruit [4]. Il a donc sa propre alimentation, et les masses sont reliées pour que le signal de données ait un zéro commun [4].
En bref
- Un anneau NeoPixel se commande avec un seul fil de données. La couleur de chaque pixel, ce sont trois nombres de 0 à 255 pour le rouge, le vert et le bleu [4][7].
- Un pixel consomme jusqu’à 60 mA en blanc plein, et bien moins en usage courant. Un anneau de 12 pixels, c’est 0,24 A avec la règle pratique et 0,72 A dans le pire cas [1].
- Donne à l’anneau sa propre alimentation, relie les masses, ajoute une résistance de 330 Ω sur le fil de données et un gros condensateur sur l’alimentation. N’utilise jamais la broche 3V3 de la carte [1][2][4].
- Utilise
setBrightness()une seule fois danssetup()pour limiter le courant, etshow()pour envoyer les couleurs [7]. Alimenter l’anneau en environ 4,5 V rend les données à 3,3 V fiables, et un adaptateur de niveau est le remède si ce n’est toujours pas le cas [3].
Prochaine étape : M3, les mécanismes, ou un projet qui a besoin d’un anneau de lumière.
Sources
Voir les 8 sources
- Adafruit, « Adafruit NeoPixel Überguide », « Powering NeoPixels » (appareils généralement à 5 V, tensions plus basses acceptables mais lumière plus faible ; condensateur de 500 à 1000 µF pour 6,3 V ou plus ; résistance de 300 à 500 ohms sur la ligne de données ; connecter la masse en premier ; jusqu’à 60 mA par pixel en blanc maximal, 20 mA par pixel comme règle pratique, le chiffre de 60 mA pour une marge garantie ; quatre piles NiMH donnent 4,8 V, quatre alcalines donnent 6 V, ce qui est trop ; des ampères en trop ne gênent pas, des volts en trop si ; signal minimal recommandé de 70 % de la tension du NeoPixel ; deux remèdes pour les contrôleurs à 3,3 V : baisser la tension des pixels ou utiliser un adaptateur de niveau ; trois piles AA alcalines donnent 4,5 V) — https://learn.adafruit.com/adafruit-neopixel-uberguide/powering-neopixels
- Adafruit, « Adafruit NeoPixel Überguide », « Best Practices » (condensateur entre + et − ; résistance de 300 à 500 ohms au bout du fil le plus proche des pixels ; garder la distance courte ; connecter la masse en premier ; alimenter les pixels avant le microcontrôleur, sinon ils peuvent s’alimenter par la ligne de données) — https://learn.adafruit.com/adafruit-neopixel-uberguide/best-practices
- Adafruit, « Adafruit NeoPixel Überguide », « Logic Level Shifting » (le niveau haut minimal est un pourcentage de la tension d’alimentation, souvent cité à 70 % ; les pièces compatibles WS2812 peuvent accepter moins ; beaucoup de projets marchent sans adaptateur de niveau, mais un essai sur table peut réussir et un essai sur le terrain échouer ; l’adaptateur de niveau rend le signal robuste ; exemple chiffré : trois piles AA alcalines donnent environ 4,5 V, 70 % de cela font 3,15 V, donc une logique à 3,3 V est assez robuste) — https://learn.adafruit.com/adafruit-neopixel-uberguide/logic-level
- Adafruit, « Adafruit NeoPixel Überguide », « Basic Connections » (données depuis n’importe quelle broche numérique ; brancher l’entrée de données, pas la sortie ; la sortie de données peut alimenter la chaîne suivante ; repères imprimés sur le ruban ; adaptateurs de niveau comme le 74AHCT125 ou le 74HCT245 ; masse commune avec l’alimentation et la carte ; la broche 5V d’une petite carte ne fournit qu’environ 500 mA alors que chaque pixel peut consommer jusqu’à 60 mA, donc avec beaucoup de pixels il faut une alimentation séparée) — https://learn.adafruit.com/adafruit-neopixel-uberguide/basic-connections
- Adafruit, « Adafruit NeoPixel Überguide », « NeoPixel Rings » (anneaux de 12, 16, 24 et 60 pixels ; les plots sont très rapprochés, donc attention aux bavures de soudure et aux courts-circuits) — https://learn.adafruit.com/adafruit-neopixel-uberguide/neopixel-rings
- Adafruit, « Adafruit NeoPixel Überguide », « Arduino Library Installation » (installer « Adafruit NeoPixel by Adafruit » depuis le gestionnaire de bibliothèques ; exemple strandtest) — https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-installation
- Adafruit, « Adafruit NeoPixel Überguide », « Arduino Library Use » (déclarer l’objet anneau avec le nombre de pixels, la broche et NEO_GRB + NEO_KHZ800 ; begin() et show() ;
setPixelColor(n, red, green, blue)avec des valeurs de 0 à 255, pixels comptés à partir de 0 ; Color() regroupe les trois valeurs ; show() envoie les données et setPixelColor n’a pas d’effet immédiat ; clear() ; setBrightness() de 0 à 255 pour limiter le courant et la luminosité, à appeler une seule fois dans setup()) — https://learn.adafruit.com/adafruit-neopixel-uberguide/arduino-library-use - Adafruit, bibliothèque Adafruit_NeoPixel, README, « Supported Chipsets » (la bibliothèque liste l’ESP32 à toute vitesse parmi les puces prises en charge) — https://raw.githubusercontent.com/adafruit/Adafruit_NeoPixel/master/README.md