Discussion :

[cobra38]

Bonjour à tous ,

Je suis sur un petit projet à base de bande de Leds WS2812B
Le principe est de découper ces rubans de Leds et de les fixer sur des "rails" de longueurs différentes
pour former ainsi une sorte de circuit un peu à l'image des rails pour voies ferrées

chaque rails comporterait un nombre fixe de Leds, le problème est que la bibliothèque Neopixel (<Adafruit_NeoPixel.h> ) que j'utilise
impose la programmation du nombre exact de Leds du circuit concerné ( par ex : mon ruban fait 5 m de longueur avec 30leds/m donc au total je dois programmer 150 leds )
or le but final est de constituer un circuit à l'aide de rails dont le nombre de Leds final ne peut qu'être défini qu'après la réalisation du circuit

Ma question est donc :
Y aurai-il un moyen de connaître de façon automatique le nombre de leds utilisées au moment l'initialisation du programme
afin de déterminer le nombre final de leds utilisées à mettre dasn une variable pour l'incorporer au programme ?

J'espère avoir été clair dans l'exposé de mon petit souci

merci encore d'avoir pris la peine de me lire

bien cordialement
pascal

[f-leb]

Salut,

La communication se fait par un protocole série sur un seul fil (voir ici pour le protocole). Chaque Led reçoit une information RVB, et lorsqu'elle reçoit une autre information RVB dans la foulée, elle la présente sur sa sortie pour la Led suivante, mais il n'y a pas de retour d'information prévu par le protocole, pas d'accusé de réception ou d'acquittement... Donc je ne pense pas que cela soit possible.

[cobra38]

merci f-leb

je ne vois donc pas comment m'en sortir à part mettre manuellement le nombre de leds par roue codeuse (par ex )
avant de lancer le programme

[cobra38]

ou ...
compter le nombre de rails ....

[Jay M]

Oui, au premier lancement du programme il faudrait pouvoir fournir le nombre de rails et le nombres de LEDs sur chaque rail (ou le nombre total). Ensuite on sauve ça en EEPROM ou Flash et les fois suivantes il n'y a plus besoin de fournir l'information.

Cela nécessitera de ne pas fait l'instanciation du bandeau en variable globale, mais dans le setup() au run time.

[cobra38]

Salut Jay M

L'idée est donc de raccorder les rails et le programme déterminerai le nombre de LEDs automatiquement
Hypothèse :
1)chaque rail possède le même nombre de LED par construction ( ex : 10 )
2) tous les rails sont connectés par des connecteurs magnétiques en entrée et en sortie à 4 pins ( +,-,data,pin)
3) une résistance ( ex 100K ) est branchée en T entre Pin (reliée en entrée et sortie du rail) et le (-)


en connectant tous les rails et donc les toutes résistances en // , on devrait aboutir par lecture d'une tension sur une entrée de l'Arduino image du nombre de rails raccordé

[Vincent PETIT]

Bonjour,
Si tu trouves un moyen de mesurer le courant du bandeau de LED alors à l'initialisation, en les allumant, tu devrais pouvoir estimer leur nombre.

A l'initialisation ton programme allume la 1er led, puis 2eme, puis la 3ème etc en laissant toutes celles d'avant allumées. Chaque led qui s'allume (avec la même couleur) fera augmenter le courant jusqu'à la dernière LED ensuite le courant n'augmentera plus car le bandeau sera coupé.

J'ai regardé cette doc https://cdn.sparkfun.com/datasheets/...ds/WS2812B.pdf mais j'ai pas trouvé la conso d'une LED... Ce qui est aussi bizarre que d'oublier de préciser la motorisation dans la doc d'une voiture

[cobra38]

Bonjour,
Si tu trouves un moyen de mesurer le courant du bandeau de LED alors à l'initialisation, en les allumant, tu devrais pouvoir estimer leur nombre.

A l'initialisation ton programme allume la 1er led, puis 2eme, puis la 3ème etc en laissant toutes celles d'avant allumées. Chaque led qui s'allume (avec la même couleur) fera augmenter le courant jusqu'à la dernière LED ensuite le courant n'augmentera plus car le bandeau sera coupé.

J'ai regardé cette doc https://cdn.sparkfun.com/datasheets/...ds/WS2812B.pdf mais j'ai pas trouvé la conso d'une LED... Ce qui est aussi bizarre que d'oublier de préciser la motorisation dans la doc d'une voiture

Bonsoir Vincent

L'idée serait de passer par un INA219 pour mesurer le courant sur la ligne des 5V des Leds
la question que je me pose c'est :
Doit-on obligatoirement passer par Neopixel pour allumer les Leds car sauf erreur la bibliothèque oblige à donner le nombre de LEDs câblées pour fonctionner ?
c'est la raison pour laquelle je pensais à une autre méthode mais je garde çà comme idée
merci bien

[Guesset]

Bonjour,

Il y a une possibilité qui consisterait à envoyer le dernier Dout sur une entrée E du microcontrôleur. Par un test dichotomique (chaine de n couleurs puis n = n + n/2 ou n = n/2 selon résultat etc.), on peut trouver le nombre exact N de leds (N couleurs : pas d'entrée sur E, N+1 couleurs : une (ou des) entrée(s) sur E).

On peut aussi envoyer des couleurs qui représentent des valeurs (0x000001, 0x00002 etc) En envoyant une assez longue séquence, le premier code apparaissant sur E sera N+1. C'est plus rapide mais demande de décoder les séquences qui se présentent en E.

Salutations

[f-leb]

Doit-on obligatoirement passer par Neopixel pour allumer les Leds car sauf erreur la bibliothèque oblige à donner le nombre de LEDs câblées pour fonctionner ?

Avec l'opérateur new, tu peux différer le dimensionnement, voir l'exemple : Adafruit_NeoPixel/examples/simple_new_operator/simple_new_operator.ino.

Tu déclares un pointeur :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Adafruit_NeoPixel *pixels;

Puis tu instancies un premier ruban avec un nombre maximal de leds :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

pixels = new Adafruit_NeoPixel(MAX_PIXELS, pin, pixelFormat);

Plus tard, quand tu connais le nombre de pixels vraiment connectés, tu supprimes l'objet en mémoire et tu en reconstruis un à la bonne taille :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
delete pixels;
pixels = new Adafruit_NeoPixel(num_pixels, pin, pixelFormat);

[Vincent PETIT]

L'idée serait de passer par un INA219 pour mesurer le courant sur la ligne des 5V des Leds
la question que je me pose c'est :
Doit-on obligatoirement passer par Neopixel pour allumer les Leds car sauf erreur la bibliothèque oblige à donner le nombre de LEDs câblées pour fonctionner ?
c'est la raison pour laquelle je pensais à une autre méthode mais je garde çà comme idée

Salut,
Tu pourrais en effet passer un INA219.

Tu peux très bien mettre un nombre énorme de LED dans la bibliothèque Neopixel, une fois que le courant donné par l'INA219 cesse d'augmenter c'est que tu es arrivé à la dernière LED. Si tu as incrémenté une variable à chaque fois que tu as allumée une LED alors tu sauras combien il y en avait.

[Jay M]

Oui - OK sur ESP32 avec le module RMT c’est possible effectivement

[cobra38]

Bonjour à tous

Heureux de constater que ma question reste ouverte ,
pour ma part, je continue plus sur la mise en œuvre des "rails" que sur la programme car je pensais naïvement que le problème semblait résolu

pourriez-vous développer svp le problème car pour ma part , l'utilisation d'un nano (certes en simulation ) fonctionnait
( je n'ai pas encore testé en réel avec une bande de 150 Leds )
mais suivant les propos précédents, on peut craindre une dérive dans le calcul du nombre de Leds raccordées lié à la lenteur de l'µC

est-cela ?
pascal

[f-leb]

Salut,

Le problème est qu'à chaque fois que tu allumes une nouvelle led, il faut envoyer les signaux aussi pour allumer les leds qui précèdent dans le ruban.

Mais pour discuter concrètement des performances, il faut nous dire combien de leds tu dois allumer ? Combien de "rails" au maximum ? Combien de leds par "rail" ?

De quelle durée tu peux disposer pour faire l'apprentissage du nombre de leds ? C'est grave si cela prend une seconde ou deux ? Ou c'est critique, il faut faire cela en 1/10è ou 1/100è de seconde ?

[Jay M]

voilà un code de test (que je n'ai pas pu testé)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
#include <FastLED.h>
 
const size_t MAX_NB_LEDS = 50;
const byte stripInPin = 2;
const byte stripOutPin = 3;
volatile bool endOfStripActivated = false;
 
CRGB leds[MAX_NB_LEDS];
 
void endOfStrip() {
  endOfStripActivated = true;
  detachInterrupt(digitalPinToInterrupt(stripOutPin));
}
 
void setup() {
  pinMode(stripOutPin, INPUT);
  FastLED.addLeds<NEOPIXEL, 2>(leds, 0, MAX_NB_LEDS);
  Serial.begin(115200);
 
  for (int i = 0; i < MAX_NB_LEDS; i++) leds[i] = CRGB::Black;
  FastLED.show();
 
  detachInterrupt(digitalPinToInterrupt(stripOutPin));  // Désactiver toute interruption en attente
  attachInterrupt(digitalPinToInterrupt(stripOutPin), endOfStrip, RISING);
 
  for (int i = 0; i < MAX_NB_LEDS; i++) {
    leds[i] = CRGB::White;
    FastLED.show();
    if (endOfStripActivated) { // la lecture est atomique et on a désactivé l'interruption
      Serial.print("Fin du bandeau i=");
      Serial.println(i);
      break;
    }
    leds[i] = CRGB::Black;
    delay(100);
  }
}
 
void loop() {}

Le bandeau est sur la pin 2 et son DOUT sur la pin 3 et on déclare 50 LEDs possible même si le bandeau disons en a 30.

Le code allume en blanc une à une les LEDs tout en ayant les interruptions activées donc si on voit une activité sur DOUT, l'interruption est déclenchée et elle met le drapeau à vrai et désactive cette interruption. La loop reprend alors la suite et voit que le drapeau est passé à vrai et affiche le compte...

Je n'ai pas regardé la doc des neopixels cependant pour voir si autre chose que la couleur était passée sur DOUT. Dans ce cas, ça ne fonctionnera pas même en affichant du noir (que des 0 donc pas de RISING)

Peut-être faut il la pin en INPUT_PULLUP; je ne sais pas si DOUT n'est pas flottante. Dans ce cas ce serait HIGH par défaut et il faudrait attendre un LOW, donc mettre le bandeau à blanc d'abord puis ensuite envoyer du noir ?

bref - faut creuser la spec....

[f-leb]

Je n'ai pas regardé la doc des neopixels cependant pour voir si autre chose que la couleur était passée sur DOUT. Dans ce cas, ça ne fonctionnera pas même en affichant du noir (que des 0 donc pas de RISING)

Voici comment sont codés les 0 et les 1 dans le protocole :


Un signal à l'état bas pendant plus de 50us équivaut à un Reset. Il y aura donc des fronts montants même en ne passant que des 0.
Sinon le signal n'est constitué que des 24 bits des composantes RVB pour chaque Led. S'il y a plus de 24 bits, c'est passe à ta led voisine...

[f-leb]

Il faut espérer que la librairie FastLED n'empêche pas les interruptions...

[edgarjacobs]

Hello,

@Jay M: lignes 13 et 25, ne serait-ce pas plutôt stripInPin ?

[f-leb]

voilà un code de test (que je n'ai pas pu testé)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
 
#include <FastLED.h>
 
const size_t MAX_NB_LEDS = 50;
const byte stripInPin = 2;
const byte stripOutPin = 3;
volatile bool endOfStripActivated = false;
 
CRGB leds[MAX_NB_LEDS];
 
void endOfStrip() {
  endOfStripActivated = true;
  detachInterrupt(digitalPinToInterrupt(stripOutPin));
}
 
void setup() {
  pinMode(stripOutPin, INPUT);
  FastLED.addLeds<NEOPIXEL, 2>(leds, 0, MAX_NB_LEDS);
  Serial.begin(115200);
 
  for (int i = 0; i < MAX_NB_LEDS; i++) leds[i] = CRGB::Black;
  FastLED.show();
 
  detachInterrupt(digitalPinToInterrupt(stripOutPin));  // Désactiver toute interruption en attente
  attachInterrupt(digitalPinToInterrupt(stripOutPin), endOfStrip, RISING);
 
  for (int i = 0; i < MAX_NB_LEDS; i++) {
    leds[i] = CRGB::White;
    FastLED.show();
    if (endOfStripActivated) { // la lecture est atomique et on a désactivé l'interruption
      Serial.print("Fin du bandeau i=");
      Serial.println(i);
      break;
    }
    leds[i] = CRGB::Black;
    delay(100);
  }
}
 
void loop() {}

En fait, quand tu écris FastLED.addLeds<NEOPIXEL, 2>(leds, 0, MAX_NB_LEDS);, tu déclares un ruban de 50 leds, et la méthode show() va systématiquement écrire sur les 50 leds du ruban. L'interruption va donc se déclencher dès le premier passage dans la boucle.

J'ai trouvé qu'avec FastLED[0].setLeds(leds, currentNbLeds);, on pouvait dynamiquement limiter le nombre de leds actives du ruban. Je ferai des essais quand wokwi voudra bien compiler mes programmes dans un temps raisonnable, leur serveur a l'air débordé...

[f-leb]

Je pense avoir réussi avec ce code avec wokwi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#include <FastLED.h>
 
const size_t MAX_NB_LEDS = 50; 
const byte stripInPin = 2;      // Pin d'entrée (DIN du ruban)
const byte stripOutPin = 3;     // Pin de sortie (DOUT dernière LED)
volatile bool endOfStripActivated = false;
 
CRGB leds[MAX_NB_LEDS];
int currentNbLeds = 1;       // Nombre de LEDs actives au départ
 
void endOfStrip() {
  endOfStripActivated = true;
  detachInterrupt(digitalPinToInterrupt(stripOutPin));  // Désactive l'interruption
}
 
void setup() {
  pinMode(stripOutPin, INPUT);  // Configure Dout comme entrée
  FastLED.addLeds<NEOPIXEL, stripInPin>(leds, MAX_NB_LEDS);  // Taille maximale
  Serial.begin(115200);
}
 
void loop() {
  // Limite dynamiquement la plage active
  FastLED[0].setLeds(leds, currentNbLeds);
 
  // Allumer les LEDs actives
  for (int i = 0; i < currentNbLeds; i++) {
    leds[i] = CRGB::White;  // Active les LEDs blanches
  }
 
  // Attache l'interruption pour détecter la fin du ruban
  attachInterrupt(digitalPinToInterrupt(stripOutPin), endOfStrip, RISING);
  delay(10);
  FastLED.show();  // Envoie les données aux Leds actives
  delay(50);
 
  // Vérifie si la fin a été atteinte
  if (endOfStripActivated) {
    Serial.print("Fin du bandeau i=");
    Serial.println(currentNbLeds);
    endOfStripActivated = false;
    while (true);
  } else if (currentNbLeds < MAX_NB_LEDS) {
    // Si non atteint, incrémenter
    currentNbLeds++;
  } else {
    Serial.println("Toutes les Leds sont détectées.");
    while (true);
  }
}

50 leds au maxi, puis j'ai le message : Fin du bandeau i= 17

Ce qui est conforme à l'attendu avec cet anneau de 16 leds.