English

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 :

  1. brancher un anneau avec une résistance et un condensateur, comme Adafruit le recommande,
  2. choisir une couleur sous forme de trois nombres, et l’envoyer avec une bibliothèque,
  3. calculer le courant dont un anneau a besoin, et le garder sous contrôle.
Un seul fil de données pour douze pixels À gauche, un anneau de 12 pixels numérotés de 0 à 11. Un seul fil de données entre au pixel 0, l’entrée de données, DIN. Des flèches vont de pixel en pixel autour de l’anneau, de 0 à 1 à 2 et ainsi de suite, jusqu’au pixel 11, puis vers la sortie de données, DOUT, qui reste libre ou alimente la chaîne suivante. À droite, un pixel agrandi : une DEL rouge, une verte et une bleue et un minuscule contrôleur dans un seul petit boîtier. Les numéros des pixels commencent à 0. FIG. 1 — UN FIL, BEAUCOUP DE LUMIÈRES01234567891011DIN : entréedepuis la GPIO 23 (par 330 Ω)DOUT : libre(ou la chaîne suivante)RGBun pixel, agrandiDEL rouge, verte,bleuepetit contrôleurUn fil de données, 12 pixels.Les données entrent par DIN seulement.Les numéros commencent à 0.
Touche le schéma pour l’ouvrir en plein écran.

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].

Mélange une couleur, allume l’anneau (interactif)
Mélange une couleur, allume l’anneau (interactif) Simulation interactive, une estimation et pas une mesure. À gauche, un aperçu d’anneau de 12 pixels ; à droite, un échantillon de la couleur mélangée. Trois curseurs règlent le rouge, le vert et le bleu de 0 à 255 ; l’affichage montre les trois nombres et la couleur combinée. Un deuxième curseur choisit combien de pixels sont allumés, de 1 à 12, et une limite de luminosité de 0 à 255 les atténue. Une estimation du courant utilise jusqu’à 60 mA par pixel en blanc à fond comme pire cas et 20 mA par pixel comme règle pratique, les deux étiquetés. L’écran ne peut pas montrer la vraie luminosité des DEL. simulation, une estimationDIN → 012 allumésla couleur0xFF00FFaperçu : un écran ne montre pas l’éclat des DEL

Simulation et estimation, pas une mesure.

255, 0, 255strip.Color(255, 0, 255) = 0xFF00FF (16711935)
Estimation pour cette couleurenviron 480 mA12 × 60 mA × couleur 67 % × luminosité 100 %

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.

Trois nombres font une couleur À gauche, sur un fond sombre, trois disques de lumière rouge, verte et bleue qui se chevauchent. Là où le rouge et le bleu se croisent : magenta, 255, 0, 255. Rouge et vert : jaune, 255, 255, 0. Vert et bleu : cyan, 0, 255, 255. Les trois au milieu : blanc, 255, 255, 255. À droite, l’exemple magenta en trois barres de 0 à 255 : rouge plein à 255, vert vide à 0, bleu plein à 255. 0 veut dire éteint, 255 veut dire plein. FIG. 2 — MÉLANGER LA LUMIÈRErouge255, 0, 0vert0, 255, 0magenta255, 0, 255cyan0, 255, 255jaune255, 255, 0blanc255, 255, 255magenta = 255, 0, 255rouge255vert0bleu25501282550 = éteint, 255 = plein.setPixelColor(n, 255, 0, 255)
Touche le schéma pour l’ouvrir en plein écran.

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].

Combien de courant pour 12 pixels ? Un graphique en barres pour un anneau de 12 pixels, des estimations et pas des mesures. Un pixel en blanc à fond : jusqu’à 60 mA. Règle pratique, 12 fois 20 mA : 240 mA. Pire cas, 12 fois 60 mA : 720 mA. Une ligne en pointillés à environ 500 mA, ce qu’Adafruit dit que la broche 5V d’une petite carte peut donner : le pire cas la dépasse. FIG. 3 — LE BUDGET DE COURANTun pixel, blanc à fondjusqu’à 60 mArègle pratique12 × 20 mA = 240 mApire cas, tout blanc12 × 60 mA = 720 mA0200400600800mAenviron 500 mA : ce qu’Adafruit ditque la broche 5V d’une petite carte donneestimations, pas des mesuresL’anneau a son propre bloc : jamais la broche 3V3.
Touche le schéma pour l’ouvrir en plein écran.

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.
Câblage A4 : données sur 23 par 330 Ω, anneau sur son propre bloc 4,5 V, 1000 µF, GND commun Deux cadres. a, vue de montage. La DevKitC est hors de la plaque, USB à gauche, alimentée par son câble USB ; la GPIO 23 est sur sa rangée de broches du bas, donc des fils à embout femelle vont sur ses broches. Les rails du haut de la plaque portent l’alimentation de l’anneau : un boîtier de 3 piles AA alcalines, 4,5 V, avec interrupteur, éteint pendant le câblage. 1 rouge, plus du bloc vers le rail plus du haut ; 2 noir, moins du bloc vers le rail moins du haut. 3 noir, un fil épais étiqueté GND commun, d’une broche GND de la DevKitC vers le rail moins du haut. Un condensateur électrolytique de 1000 microfarads est à cheval sur les deux rails du haut, sa bande sur le rail moins, tension nominale 10 V ou plus. L’anneau, 12 pixels, a des fils soudés sur ses pastilles : 4 rouge, sa pastille 5V vers le rail plus ; 5 noir, sa pastille GND vers le rail moins ; 6 vert, sa pastille DIN vers la rangée 17 de la moitié haute ; DOUT reste libre. Une résistance de 330 ohms traverse la rainure centrale en rangée 17, près de l’anneau. 7 jaune, GPIO 23 vers la rangée 17 de la moitié basse. Le bouton est à cheval sur la rainure en rangées 3 et 5 : 8 bleu, GPIO 27 vers la rangée 3 ; 9 noir, rangée 5 vers le rail moins. Une ligne rouge en pointillés part de la broche 3V3, barrée : n’alimente jamais l’anneau par la 3V3. b, schéma : la GPIO 23 passe par la résistance de 330 ohms, près de l’anneau, vers DIN. La pile, 3 AA, 4,5 V, avec son interrupteur, alimente la pastille 5V de l’anneau ; le condensateur polarisé est entre le 5V et le GND de l’anneau, plus vers le 5V. Un trait épais relie le moins de la pile, le GND de l’anneau et le GND de l’ESP32 : GND commun. Le bouton est entre la GPIO 27 et GND. Une ligne en pointillés barrée va de la 3V3 vers l’anneau. FIG. 4 — CÂBLAGE, ANNEAU SUR SA PROPRE ALIMENTATIONaVue de montageENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GND+−−+jihgfedcba15101518rails du bas : pas utilisés3 × AA alcalines, 4,5 V+++ONOFF−1000 µF5VGNDDINDOUTanneau, 12 pixelslibre330 ΩboutonGND commun3V3 → anneau : jamaisGND27GND23GNDcâble USB :alimente lacarte1234567891rouge : + du bloc → rail + du haut2noir : − du bloc → rail − du haut3noir : broche GND → rail − : GND commun4rouge : pastille 5V de l’anneau → rail +5noir : pastille GND de l’anneau → rail −6vert : pastille DIN → rangée 17 (haut)7jaune : GPIO 23 → rangée 17 (bas)8bleu : GPIO 27 → bouton (rangée 3)9noir : bouton, autre patte (rangée 5) → rail −La 330 Ω traverse la rainure en rangée 17, près de l’anneau. Le 1000 µF est à cheval sur les rails du haut, bande sur −.Le rail + du haut n’alimente que l’anneau et le condensateur. Le bloc d’abord, puis l’USB. Jamais quatre piles alcalines.bSchémaESP323V32327GNDanneau12 pixelsDINGND5VDOUTlibre330 Ωprès de l’anneau+3 × AA4,5 V+1000 µFGND communboutonjamais : la 3V3 n’alimente pas l’anneau
Touche le schéma pour l’ouvrir en plein écran.

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_KHZ800 convient à 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 dans setup(), 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, puis show() 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 deux i fois.
  • La comète avance avec millis(), pas avec delay(), 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].
La comète avance d’un pixel à chaque pas Trois images de l’anneau de 12 pixels, à un pas d’écart, avec les numéros des pixels. Une tête brillante et trois pixels plus faibles derrière elle : 100 %, 50 %, 25 % et environ 12 %. Image 1, la tête sur le pixel 3, la queue sur 2, 1 et 0. Image 2, la tête sur le pixel 4. Image 3, la tête sur le pixel 5. À chaque pas, toute la comète avance d’un pixel autour de l’anneau. FIG. 5 — LA COMÈTEpas 1 : tête sur 301234567891011pas 2 : tête sur 401234567891011pas 3 : tête sur 501234567891011100 %50 %25 %12 %tête + 3 pixels plus faibles
Touche le schéma pour l’ouvrir en plein écran.

Essaie tes propres changements

Change une seule chose, téléverse, observe.

  1. 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.
  2. 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.
  3. 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].
  4. Vitesse et queue. Change STEP_MS et TAIL. Que se passe-t-il avec TAIL à 1 ?
  5. Deux comètes. Dessine une deuxième tête du côté opposé de l’anneau, LED_COUNT / 2 pixels plus loin.
  6. La taille de ton anneau. Change LED_COUNT pour 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_RGBW au lieu de NEO_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 BRIGHTNESS et 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.

  1. 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
    Voir la réponse

    720 mA. Chaque pixel peut consommer jusqu’à 60 mA en blanc à la luminosité maximale [1]. 12 × 60 mA = 720 mA. Le chiffre de 240 mA vient de la règle pratique de 20 mA par pixel, qui convient aux couleurs mélangées et aux animations, pas au pire cas [1].

  2. 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].

  3. 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 dans setup() pour limiter le courant, et show() 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
  1. 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
  2. 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
  3. 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
  4. 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
  5. 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
  6. 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
  7. 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
  8. 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

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.