FranceFurs - Forum Furry

Hellowww,

A défaut de pouvoir prendre la plume pour les inktobers (mes talents de dessinateur étant inexistant), je vais prendre la plume pour faire une petite présentation de l'animatronique centrée autours des LEDs.

Impossible de présenter tout en détails en une seule fois... je vais donc rester assez générique au début.
N'hésitez pas à me faire par de vos remarques ou vos questions afin que ce sujet puisse être enrichi petit à petit.

Par la suite, je vous invite à aller faire un tour sur un autre sujet accès sur la mise en application : [Animatronique] Fursuits et LEDs


Introduction :

Les ampoules LEDs permettant de faire des économies d'énergies, on en a tous déjà entendu parlé.
Mais là où cela devient intéressant, c'est qu'il existe des LEDs que l'on peut piloter individuellement pour faire toute sorte d'effet lumineux.

Un fursuiter assez connu pour ça étant Gem Raptor, dont la partie Animatronique a été réalisée par Made2Glow : http://www.made2glow.com/portfolio/GemRaptor/index.html
Mais avant d'en arriver là, il y a pas mal de boulot ! Mieux vaut commencer petit avec quelques LEDs par-ci par-là et étoffer progressivement.

Pour ce genre de projet, vous aurez principalement besoin :
- de LEDs (surprenant non ? )
- d'un microcontrôleur
- d'une source d'énergie
- de beaucoup d'imagination

Je ne peux malheureusement rien faire concernant l'imagination mais je peux vous présenter les autres éléments.
Les parties conception/assemblage et programmation feront l'objet d'un prochain chapitre.


Les LEDs :

Pour réaliser ses premières animations, le plus simple consiste à acheter un ruban LED.
Attention tout de même à ne pas acheter le premier ruban RGB disponible sur amazon, il s'agit très certainement d'un ruban LED 12V dont les LEDs ne sont pas pilotables individuellement.

Les rubans à base de LEDs WS2812B sont un bon compromis en terme de rapport qualité/prix (c'est ce que j'utilise personnellement).
Sur amazon, compter environ 15€ le mètre de ruban de 60 LEDs ou bien 50€ pour 5 mètres et 300 LEDs.
En achetant en chine (aliexpress), on peut diviser les prix par 2 ou 3 mais il faut savoir patienter entre 2 et 4 semaines de délais de livraison...



Le ruban en lui même étant assez fragile, je conseille très fortement d'opter pour des rubans avec une protection IP65 ou IP67.
Les LEDs seront ainsi protégées de l'arrachement et le ruban en lui même sera un peu plus rigide, ce qui évite d'avoir une soudure qui casse à cause d'un angle trop important.

Une autre solution consiste à acheter des petits bout de PCB avec la LED soudée dessus.
Cela permet d'avoir quelque chose de beaucoup plus flexible et plus solide qu'un ruban tout en étant libre de la distance entre les LEDs.
En revanche, il faut faire soit même l'assemblage et chainer chaque module les uns après les autres.



Il existe aussi des panneaux de LEDs de différentes tailles (8x8, 16x16 ou 32x8), très pratique pour faire une sorte de petit écran.
Tout le linkage est déjà fait, il n'y a qu'un seul connecteur à brancher pour afficher un smiley ou autre.





Le microcontrôleur :

Il s'agit ici de l'organe de commande, c'est lui qui est en charge de piloter les LEDs et de gérer les animations.
Impossible de ne pas citer Arduino qui est une référence en la matière lorsqu'il s'agit de bricoler quelque chose d'électronique dans son coin.

La carte "Arduino UNO" est la plus connue de toutes mais sa taille non négligeable n'est pas un avantage pour des applications embarquées.
Officiellement, on lui préfèrera sa petite sœur, la "Arduino nano".
Officieusement, les copies chinoises "Arduino pro micro" et "Arduino pro mini" sont tout aussi bien à un prix beaucoup plus abordable.
A noter tout de même que la carte "Arduino pro mini" est légèrement plus petite que les autres mais n'embarque pas de connecteur USB de programmation (il faut utiliser un adaptateur FTDI externe).
Compter 20€ pour la version nano officielle (ce qui est selon moi disproportionné) et seulement quelques euros pour les versions officieuses.



Au niveau puissance de calcul, toutes ces cartes ont le même processeur et conviennent très bien pour des projets embarquant quelques dizaines voir une ou deux centaines de LEDs.
Pour des projets plus conséquent avec plusieurs centaines de LEDs, il est préférable d'opter pour des cartes plus puissantes (NodeMCU ou Tensy par exemple).


La source d'énergie :

Que ce soit les LEDs WS2812B ou le microcontrôleur, ils ont besoin d'une tension de 5V.
Une Power Bank USB est donc particulièrement adaptée car elle embarque la batterie et toute l'électronique de gestion de Charge/Décharge.



Attention à la consommation théorique des LEDs !
La datasheet des LEDs WS2812B annonce une consommation de 60mA par LEDs donc on atteint très rapidement les limites d'une Power Bank dotée d'un port 1A avec seulement 16 LEDs.
Les bonnes Power Bank ont un port 2.4A, ce qui permet d'alimenter jusqu'à 40 LEDs.
D'autres ont plusieurs ports et peuvent monter jusqu'à 6A en cumulé, ce qui fait une centaine de LEDs.
Heureusement, il s'agit ici de la consommation maximale que l'on atteint seulement si l'on met le Rouge, le Vert et le Bleu au max, ce qui revient à faire du blanc à pleine luminosité.
En pratique, les animations que l'on fait n'exploitent jamais toutes les couleurs de toutes les LEDs au max au même moment donc on peut se permettre de mettre plus de LEDs.

Attention aussi la consommation minimale de l'ensemble, on peut avoir des surprises avec certaines Power Bank.
En effet, certaines Power Bank surveillent le courant consommé et passent en veille lorsque celui-ci est trop faible.
Il est alors nécessaire d'ajouter un système qui consomme un peu plus de temps en temps pour éviter la mise en veille.

Bien qu'on trouve toute sorte de choses à prix très attractif sur aliexpress, je ne recommande pas forcément d'y acheter une Power Bank là bas car on n'est jamais sûre à 100% de la qualité.
Mieux vaut prendre une Power Bank de qualité dotée de multiples protections (surintensité entre autre) plutôt qu'un truc Low Cost qui risquerait d'exploser en cas de courant trop élevé.
Du coup, compter entre 15 et 30€ pour une bonne Power Bank, voir 50€ pour celles qui offrent jusqu'à 6A.


Divers :

A ces 3 éléments principaux viendront s'ajouter un peu de fils, quelques connecteurs, un ou plusieurs boitiers, de la gaine silicone, etc...
Pas de grosses dépenses ici mais quitte à passer commande, autant ne pas les oublier.


--------------------------------------------- Fin du premier chapitre... ---------------------------------------------

Chapitre 2 : https://forum.francefurs.org/viewtopic.php?f=4&t=11369#p294038
Chapitre 3 : https://forum.francefurs.org/viewtopic.php?f=4&t=11369#p294685

Autre sujet : https://forum.francefurs.org/viewtopic.php?f=22&t=11545
(mise en application de cette présentation pour la conception d'une fursuit animée)

Le post parfait pour m'endormir à 23h ^v^
sinon avec un minimum de sérieux (et d’œil ouvert) ça me semble être un bon début de mode d'emploie pour ce faire de superbe suit de lumière (moi qui pensé en mettre sur celle de Lunédore, pauvre fou que j'été ^v^)

_________________
Croa croa. Moi oiseau de mauvais augure? mais non... Juste nécrophage filou et farceur ^v^
déçue? vous vous attendiez à quoi? ^v^

Très bien fait et instructif, continue, c'est un projet qui peut intéresser pas mal de monde

_________________
Believe in the tufts.

Merci pour ce post, il est super !

_________________
100% Ichimatsu !
Si les chats envahissent le monde, je serais sans doute à leur côté... rrrrrrrrrrr~
La vérité sort de la bouche des chatons !

vraiment sympa
ça me conforte dans mes propres choix et idées ^w^
j'attends la suite avec impatience

Hellowww,

Comme prévu, on se retrouve pour un deuxième épisode consacré à la conception/assemblage.
Puis viendra un troisième épisode concernant la programmation, probablement d'ici quelques jours.


Pour pouvoir assembler tous les éléments du projet, il va falloir un minimum de matériel électronique :
- un fer à souder (pour ce que l'on veut faire, un petit fer à souder 30 Watt à 10€ conviendra amplement)
- une pompe à dessouder (5€) et/ou de la tresse à dessouder (3€), c'est parfois très pratique
- une petite éponge
- une pince à dénuder
- une pince coupante

Un peu de consommable :
- de l'étain
- de la gaine thermorétractable

Et pourquoi pas aussi les quelques outils du parfait petit bricoleur (cutter, lime, tournevis, etc...)


J'en profite pour faire un petit rappel des éléments électroniques du projet :
- LED WS2812B
- microcontrôleur (type Arduino pro mini par exemple)
- Power Bank
- connecteur 3 pins (en tapant "3 pins JST" sur amazon ou aliexpress, on tombe sur des packs de 10 connecteur mâle/femelle avec fils ou à sertir, c'est sympa)

- connecteur USB (là encore, on peut trouver des lots de connecteur à souder en cherchant "connecteur USB")

- câble 3 conducteurs pour la liaison vers les LEDs (personnellement, j'ai trouvé mon bonheur sur aliexpress en cherchant "cable LED 3 pins")
- câble 2 connecteurs pour la liaison vers la Power Bank (du câble audio pour haut parleur, ça peut faire l'affaire)

Et pourquoi pas aussi de quoi étanchéifier le tout :
- de la gaine silicone
- du joins silicone transparent (type joins pour salle de bain)

Attention à ne pas prendre du câble trop fin (qui ne supportera pas le courant des LEDs) ni trop gros (qui sera impossible à souder correctement).
Attention aussi à bien veiller à la souplesse du câble pour ne pas avoir quelque chose de trop rigide.

A cela viendra s'ajouter un petit boitier pour y placer l'électronique.
On trouve pleins de boitiers plastiques en vente sur internet mais on peut aussi faire de la récupération : boite d'élastique, boite d'allumettes, tube d'éfferalgan, soyez inventif !

Et pour finir, il faut aussi prévoir un système de maintient du ruban tout en permettant si possible de pouvoir le démonter facilement (on appréciera le fait de pouvoir retirer le ruban pour pouvoir laver sa fursuit par exemple).
A ce sujet, voici quelques idées :
- du scratch velcro (ma solution préférée)
- du bon scotch double face (le scotch déjà pré-collé à l'arrière des rubans LEDs ne colle généralement pas longtemps)
- du fils et une aiguille (pour coudre le velcro à son support par exemple)
- des colliers rilsan
- un pistolet à colle
etc... (vous avez d'autres idées ? n'hésitez pas à proposer)


Maintenant que cela est dit, on va pouvoir s'attaquer au vif du sujet : l'assemblage de tous ces éléments.

Je ne vous le cache pas, il va falloir prendre le fer à souder et s'en servir mais il n'y a absolument rien de compliqué là dedans !
En cas de doute sur le maniement du fer, n'hésitez pas à faire un petit tour sur youtube, ce n'est pas les tutoriels qui manquent.

Si c'est la première fois que vous manipulez un fer, je peux éventuellement vous conseiller de faire quelques essais sur une "plaque à trous".
Cela permettra de s'entrainer un peu avant de faire la soudure définitive dans les trous de l'Arduino.


Un petit conseil que je peux donner : garder à l'esprit que le mieux est l'ennemi du bien.
A force de réchauffer l'étain pour vouloir refaire une soudure qui ne parait pas très joli, on finit par avoir quelque chose d'immonde (si il est chauffé trop longtemps, l'étain finit par se dégrader).
Du coup, si la soudure est ratée, il est parfois préférable de retirer l'étain et recommencer plutôt que de s'acharner dessus.
Sans compter le fait que les pistes électriques de l'arduino et du ruban LED ne vont pas supporter indéfiniment la chaleur du fer.
Bref, entrainez-vous à faire quelque chose de propre et vite (une soudure bien faite, cela ne prend pas plus de quelques secondes).

Au niveau du ruban, la première chose à faire consiste à identifier le sens en repérant la position des pins DIN et DOUT situées de part et d'autre du ruban.
- la pin DIN sert à recevoir les données, en provenance de l'arduino ou du ruban n-1
- la pin DOUT sert à envoyer les données, vers le ruban n+1 (ou à laisser non connectée si aucun autre ruban n'est à ajouter)

On se retrouve donc avec 3 pins d'un coté :
- GND : à relier au GND de l'arduino et au GND de la prise USB de la Power Bank
- DIN : à relier **théoriquement** à n'importe quelle pin numérique (0 à 13) ou analogique (A0 à A5) de l'arduino
- +5V : à relier à la pin +5V de la prise USB de la Power Bank

J'insiste un peu sur **théoriquement** car en pratique, on évitera :
- les pins 0 et 1 qui servent au Serial (debug et programmation)
- la pin 13 qui sert à la LED interne de l'arduino

A noter que les forts courants consommés par toutes les LED favorisent les chutes de tension dans le ruban.
De ce fait, la dernière LED du ruban peut être alimentée avec une tension bien moindre que les 5V présents en début de ruban, ce qui réduit ses performances.
Si il vous est possible de rajouter des fils pour injecter l'alimentation (GND et +5V) au début ET à la fin du ruban, ne vous en privez pas !

N'hésitez pas à ajouter un bon gros condensateur en début de ruban, ça peut aider pour encaisser les pics de courant des LEDs.

Pour la soudure des fils, il faut le faire sur les zones prévues à cet effet.


Ces zones permettent aussi de couper et/ou fusionner 2 rubans entre eux (en reliant le DOUT du ruban n-1 au DIN du ruban n+1)


On dit souvent qu'il faut toujours couper le ruban au milieu de la zone sécable mais ce n'est pas forcément ce que je préconise personnellement.
En effet, en faisant ça, on se retrouve avec 2 demi-zone de chaque coté, ce qui n'est pas du tout pratique pour y souder des fils (la zone est extrêmement petite et donc très fragile).
Personnellement, je coupe souvent avant/après de façon à avoir une plage de soudure entière de chaque coté, ce qui est beaucoup plus solide.
Par contre, cette technique implique de sacrifier une LED à chaque coupure.


Au niveau de l'arduino, on a :
- la pin GND : à relier au GND du ruban et au GND de la prise USB de la Power Bank
- la pin +5V : à relier au 5V de la prise USB de la Power Bank **attention**
- une pin IO : à relier au DIN du ruban

Là encore, j'insiste un peu sur **attention** pour éviter les mauvaises surprises.
De manière général, il n'est pas conseillé de mettre en parallèle plusieurs sources de tension.
Il n'est donc pas conseillé de mettre en parallèle le +5V d'un port USB de PC et le +5V d'un port d'alimentation d'une Power Bank.
Or, en reliant le +5V de l'arduino au +5V de la prise USB de la Power Bank, vous aurez forcément ce problème en branchant l'Arduino en USB pour le reprogrammer.
Pour éviter cela, je vous propose 2 solutions :
- ne pas brancher la Power Bank quand l'arduino est branché au PC, mais cela signifie aussi que c'est le PC qui alimentera les LEDs, donc problème si il y en a beaucoup car tous les ports USB de PC ne peuvent pas forcément sortir 2.4A comme c'est le cas des Power Bank
- ne pas faire la liaison +5V entre l'arduino et le +5V du port USB du PC, ce qui revient à laisseer la Power Bank alimenter seule le montage

Voici ce que cela peut donner :



Le petit bout de carte électronique avec 6 résistances (Rload) correspond au système de consommation minimal permettant à ma Power Bank de ne pas passer en veille.
On ne le voit pas sur les photos mais il y a un transistor au dos de cette plaque pour ne pas activer les résistances en permanence afin d'économiser un peu de batterie (je commande les résistances uniquement de temps à autre, c'est suffisant pour empêcher la mise en veille).

Pour finir, je vous fais confiance concernant l'assemblage final du projet avec les différentes techniques vues plus haut (adhésif, velcro, rislan, etc...)
Gardez tout de même à l'esprit que :
- le ruban est fragile !!!
**** à la longue, il ne supportera pas d'être tordu indéfiniment dans tous les sens
**** si un angle droit doit être fait (ce que je ne conseille pas), il faut impérativement le faire au niveau de la zone sécable et non en plein milieu d'une LED
- l'arduino aussi est fragile
**** une boite solide et si possible étanche est conseillée
- le port USB de l'arduino doit rester accessible
**** le changement du programme de l'arduino (et donc les animations générées) se fait par USB donc mieux vaut pouvoir y accéder sans tout démonter


Des questions ? Des points qui ne semblent pas clairs ? pas assez détaillés ? faites moi signe !


--------------------------------------------- Fin du second chapitre... ---------------------------------------------

Chapitre 3 : Coming soon...

Hello les gens !

Pas évidant de trouver un peu de temps libre pour ce troisième chapitre (travaux, boulot, etc...) mais étant donné qu'on est tous plus ou moins confiné en ce moment, j'en profite pour me replonger dans le sujet

Voici dans ce troisième chapitre consacré à la programmation !

Après y avoir réfléchit, je me suis dis que faire tout un tutoriel de programmation ne serait pas forcément la meilleurs idée étant donné qu'il y a beaucoup à dire et que l'on en trouve déjà plein sur le net, qui seront surement bien mieux expliqué que ce que je pourrais faire.
Du coup, je vais assumer que si vous vous lancez là dedans, vous avez un minimum de connaissance en programmation (ou que vous êtes assez débrouillard pour comprendre et adapter des copier/coller).
Bref, ce chapitre sera donc organisé sous forme d'exemples pour présenter différentes animations que l'on peut faire sur ces LEDs.

A noter que l'Arduino se programme en C/C++ mais si vous avez déjà des bases dans un langage (java, python, visual basic, etc...), vous ne devrez pas être trop perdu étant donné que l'on retrouve généralement les mêmes mots clefs (if, else, for, while, etc...)
Dans tous les cas, je vous conseille d'aller faire un tour sur le site de Eskimon qui explique comment prendre en main l'Arduino en partant de zéro, quitte à passer un peu vite certains chapitres si vous avez les bases.

Pour votre premier programme Arduino, vous aurez besoin de l'IDE Arduino (téléchargeable ici) ainsi que la lib NeoPixel (téléchargeable ici).
L'ajout de cette lib se fait dans le menu "Croquis", puis "Inclure une bibliothèque" puis "Ajouter la bibliothèque ZIP".
A noter qu'il y a aussi la lib FastLED qui est plutôt bien fournie et propose déjà de nombreuses animations, libre à chacun de tester et de se faire son opinion.

Maintenant que cela est fait, parlons un peu de la lib NeoPixel.

Celle-ci permet de gérer des rubans LEDs au travers de la classe Adafruit_NeoPixel qui aura besoin de connaitre : le nombre de LEDs du ruban, la pin de l'Arduino reliée au ruban, le protocole de communication qui dépend de la référence des LEDs de votre ruban.
Une fois une instance créée, nous utiliserons principalement les fonctions setPixelColor et show qui permettent respectivement de changer la couleur d'une LED et de mettre à jour tout le ruban.
A noter que setPixelColor ne fait qu’enregistrer la couleur dans la mémoire interne de l'Arduino (donc extrêmement rapide) tandis que show communique avec le ruban pour le mettre à jour (donc beaucoup plus lent).
Il convient donc d'appeler setPixelColor pour toutes les LEDs que l'on souhaite modifier puis de faire un appel à show pour mettre à jour tout ça.

Pour ce qui est des couleurs, vu le nombre d'artistes numériques ici, je ne vais probablement rien vous apprendre en annonçant que chaque couleur peut être définit comme un composante de rouge, de vert et de bleu, dont la valeur varie entre 0 et 255.
A noter tout de même que le ruban n'étant pas sur un arrière plan noir, il est impossible d'afficher la couleur noir et les couleurs sombres.
Par exemple, la couleur (32,32,32) correspondant à un gris très sombre sur un écran sera en réalité un blanc très peu lumineux sur le ruban.



Maintenant, place au premier exemple pour mettre cela en pratique :

Code:

#include <Arduino.h>
#include <stdint.h>

#include <Adafruit_NeoPixel.h>



#define PIN_PIXELS 6

#define NB_PIXELS 60



Adafruit_NeoPixel pixels ( NB_PIXELS, PIN_PIXELS, (NEO_GRB+NEO_KHZ800) );



void setup ( void ) {
   
   Serial.begin(115200);
   Serial.println(">Start:");
   
   pixels.begin();
   
}



void loop ( void ) {
   
   for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
      pixels.setPixelColor(i, 255, 0, 0);
   }
   
   pixels.show();
   
   delay(1000);
   
   for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
      pixels.setPixelColor(i, 0, 0, 0);
   }
   
   pixels.show();
   
   delay(1000);
   
}

Vous remarquerez qu'il n'y a pas de fonction main, c'est une typicité d'Arduino à laquelle on finit par s'y habituer.
Il faut en effet définir une fonction setup (pour l'initialisation) qui sera automatiquement appelée au début du programme puis une fonction loop qui sera appelée en boucle par la suite.

Quelques explications :
- lignes 8 et 10, on définit la pin connectée au ruban ainsi que le nombre de LEDs
- ligne 14, on construit l'instance de Adafruit_NeoPixel évoquée plus haut (j'utilise des LED WS2812B donc le protocole est (NEO_GRB+NEO_KHZ800))
- ligne 18, on définit la fonction setup qui initialise le Serial (la console de debug Arduino) ainsi que notre ruban LED
- ligne 29, on définit la fonction loop qui vient faire clignoter le ruban
Pour ce clignotement:
- on commence par mettre toutes les LED en rouge (255,0,0) avec la première boucle for suivie d'un appel à show pour envoyer ce rouge au ruban
- puis une attente d'une seconde (fonction delay d'Arduino)
- on repasse toutes les LED sur OFF (0,0,0) et le show associé
- et à nouveau attente d'une seconde
Le tout se répétant indéfiniment car la fonction loop est appelée en boucle

Bon, ça clignote, c'est joli, mais on ne va pas aller loin avec ça...
D'autant plus que la fonction delay est bloquante, ce qui signifie qu'elle met en pause l'exécution du programme pendant en certain temps.
C'est pratique pour ce clignotement mais si on doit aussi gérer l'animation d'un second ruban ou faire une action quand on clique sur un bouton, ça va poser problème car pendant que le programme est en pause, il ne test pas l'état du bouton.

Du coup, je vous propose d'oublier la fonction delay et de la remplacer par un peu de mathématique avec la fonction millis.
Cette fonction millis retourne ne nombre de millis secondes depuis le lancement du programme, ce qui est très pratique.

Voici comment faire la même chose avec millis :

Code:

void loop ( void ) {
   
   uint32_t time = millis();
   
   if ( ((time/1000)%2) == 0 ) {
      for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
         pixels.setPixelColor(i, 255, 0, 0);
      }
   } else {
      for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
         pixels.setPixelColor(i, 0, 0, 0);
      }
   }
   
   pixels.show();
   
}

Toute l'astuce se trouve dans ce if ( ((time/1000)%2) == 0 ) ligne 33.
Comme dit plus haut, millis retourne le nombre de millis secondes depuis le lancement du programme donc au premier appel de loop, ce sera très certainement 0, puis peut-être encore 0 (si le programme a été rapide), puis 1, peut-être encore 1, puis 2, etc... et ainsi ce suite, millis retourne une valeur qui augmente au fur et à mesure que le programme s’exécute.
En divisant par 1000, on obtiens donc le nombre de secondes depuis le lancement du programme : d'abord 0, puis 1, puis 2, puis 3, etc... au fur et à mesure que le programme s’exécute.
Vient ensuite le modulo 2, qui correspond au reste de la division euclidienne par 2, ce qui donnera le résultat 0 si le nombre est pair (0,2,4,etc...) ou 1 si le nombre est impair.
Du coup, c'est la boucle for qui met la couleur rouge qui est exécutée lorsque le nombre de secondes est pair tandis que ce sera OFF si le nombre est impair.

Si l'on veut faire défiler plusieurs couleurs, il suffit simplement de changer la valeur du modulo pour avoir un résultat autre que 0 ou 1.
Par exemple, avec un modulo 3, on aura comme résultat 0, 1, ou 2, ce qui pourrait permettre de faire défiler 3 couleurs :

Code:

void loop ( void ) {
   
   uint32_t time = millis();
   
   uint8_t colormod = ((time/1000)%3);
   
   if ( colormod  == 0 ) {
      for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
         pixels.setPixelColor(i, 255, 0, 0);
      }
   }
   if ( colormod  == 1 ) {
      for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
         pixels.setPixelColor(i, 0, 255, 0);
      }
   }
   if ( colormod  == 2 ) {
      for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
         pixels.setPixelColor(i, 0, 0, 255);
      }
   }
   
   pixels.show();
   
}

Une couleur toutes les secondes, c'est peut-être un peu trop lent, ou trop rapide, ça dépend des goûts de chacun.
Pour changer ça, c'est extrêmement simple, il suffit de changer la valeur de la division.
- Diviser par une valeur plus faible aura pour effet d'augmenter la cadence
- Diviser par une valeur plus forte aura pour effet de réduire la cadence

Bref, vous l'aurez compris, il faut faire preuve d'imagination pour trouver les bonnes formules permettant d'effectuer les bonnes actions en fonction du temps qui s'écoule.

On peut bien évidement faire du fadding en se servant de ce temps pour générer la composante d'une couleur.
Un petit exemple qui allume progressivement le ruban, puis l'éteint tout aussi progressivement :

Code:

void loop ( void ) {
   
   uint32_t time = millis();
   
   uint32_t count = (time%200);
   
   uint8_t col;
   
   if ( count < 100 ) {
      col = map(count, 0, 99, 0, 255);
   } else {
      col = map(count, 100, 199, 255, 0);
   }
   
   for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
      pixels.setPixelColor(i, col, 0, 0);
   }
   
   pixels.show();
   
}

Avant d'entrer dans les détails, je dois vous présenter la fonction map(x, A, B, C, D), qui permet de mapper une valeur x de l'intervalle [A;B] vers l'intervalle [C;D].
Dans ce code, je commence par récupérer le temps avec un modulo 200, ce qui me permet d'avoir une valeur d'animation qui part de 0 et augmente progressivement jusqu'à 199 puis repart à 0.
Si cette valeur est inférieur à 100, on est dans la première partie de l'animation, il faut augmenter l'intensité de la couleur, donc je map cette valeur 0-99 vers intervalle 0-255 correspondant à une composante de couleur.
Pour la seconde partie, ce sera le else, avec cette fois ci une valeur de 100-199 que je map sur l'intervalle 255-0 (on notera que l'intervalle de sortie est inversé car je souhaite que la composante diminue en partant de 255 pour rejoindre 0 au fur et à mesure que le temps passe).

Et pour finir, le top du top, histoire de faire exploser le cerveau avec les mathématiques, on peut aussi intégrer la position de la LED dans le calcul.
On peut par exemple incrémenter virtuellement le temps avec l'index de la LED, de sorte qu'elle s'anime en avance par rapport à la LED précédente, ce qui aura pour effet de créer un défilement :

Code:

void loop ( void ) {
   
   uint32_t realTime = millis();
   
   for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
      uint32_t virtualTime = (realTime + i*20);
      uint32_t count = (virtualTime%200);
      uint8_t col;
      if ( count < 100 ) {
         col = map(count, 0, 99, 0, 255);
      } else {
         col = map(count, 100, 199, 255, 0);
      }
      pixels.setPixelColor(i, col, 0, 0);
   }
   
   pixels.show();
   
}

Ici, il s'agit de la même animation que précédemment, sauf que les LEDs ont toutes un déphasage temporelle de 20ms les unes par rapport aux autres grâce à (realTime + i*20).
Du coup, au lieux que tout le ruban s'éteigne puis s'allume en même temps, chaque LED est indépendante.
Quand une LED est éteinte, la LED suivante ne le sera que 20ms plus tard, et ainsi de suite.
Du coup, au fur et à mesure que le temps passe, la zone d'extinction se déplace d'une LED à l'autre, ce qui cré une animation de défilement le long du ruban.
- Si l'on veut que le défilement soit plus rapide, il suffit de faire un décalage plus faible avec par exemple (realTime + i*5)
- Si l'on veut que le défilement soit plus lent, il suffit de faire un décalage plus important avec par exemple (realTime + i*40)
- Si l'on veut que le défilement soit dans l'autre sens, il suffit de faire une soustraction plutôt qu'une addition avec par exemple (realTime - i*20)

Bref, les combinaison sont infinies, il suffit de se creuser le cerveau pour enchainer les conditions et les calculs mathématiques.
Le même exemple avec une animation qui change de sens toutes les 3 secondes, ça donnerait ça :

Code:

void loop ( void ) {
   
   uint32_t realTime = millis();
   
   for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
      uint32_t virtualTime;
      if ( ((realTime/3000)%2) == 0 ) {
         virtualTime = (realTime + i*20);
      } else {
         virtualTime = (realTime - i*20);
      }
      uint32_t count = (virtualTime%200);
      uint8_t col;
      if ( count < 100 ) {
         col = map(count, 0, 99, 0, 255);
      } else {
         col = map(count, 100, 199, 255, 0);
      }
      pixels.setPixelColor(i, col, 0, 0);
   }
   
   pixels.show();
   
}

Voila, je pense qu'on a fait un beau tour d'horizon des différentes animations.
Il y aura peut-être d'autres chapitres pour voir comment intégrer d'autres éléments (bouton poussoir par exemple), optimiser un peu le tout, les pièges à éviter, peut-être de nouvelles animations, etc...
Comme toujours, n'hésitez pas à me faire part de vos remarques et questions.

Avant de se quitter, un petit bonus, l'effet arc en ciel défilant grâce à la fonction ColorHSV qui permet de convertir une composante HUE (0-65535) en une couleur :

Code:

void loop ( void ) {
   
   uint32_t tm = millis();
   
   for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
      pixels.setPixelColor(i, Adafruit_NeoPixel::ColorHSV( (tm+i*10)*50 ) );
   }
   
   pixels.show();
   
}

Comme quoi, ce n'est pas forcément les effets les plus Wooowwww les plus dure à implémenter.
Maintenant, vous savez pourquoi on retrouve plein d'arc en ciel défilant sur les rubans LEDs

Pour ajouter à ces ressources, Hackaday vient de publier un court article sur un simulateur de matrice NeoPixel :
Neopixel matrix simulation lets you virtually groove to the lights
Cela peut aider peaufiner le code et le matériel associé jusqu'à obtenir le résultat voulu.

_________________
"Writing is perhaps the greatest of human inventions, binding together people who never knew each other, citizens of distant epochs. Books break the shackles of time. A book is proof that humans are capable of working magic." (Carl Sagan)

Waoww, franchement bien fait ce simulateur ! Très beau boulot de la part de l'auteur !

Je me suis un peu plongé dans le code de la page et je dois avouer que je suis assez surpris par la technique utilisé.
Le code source du programme est envoyé au serveur qui s'occupe de le compiler et le renvoyer au navigateur sous forme de fichier hex.
Et c'est ensuite le navigateur qui exécute (ou émule devrais-je plutôt dire) ce fichier hex.
Plutôt original et franchement balèze comme technique de faire un émulateur JS d'un fichier compilé pour architecture arduino !

Le seul petit reproche que je pourrais faire, c'est que l'on ne peut pas choisir la taille de la matrice...
Et que la page d'exemple pour ruban Neopixel est très limitée avec sa taille de seulement 8 LEDs...

Du coup, j'ai fais un petit bout de code pour détourner la page de simulation de matrice pour s'en servir comme un ruban Neopixel.
Il faut s'imaginer que seules les LEDs en périphérie de la matrice forment le ruban, ce qui fait un ruban de maxi 60 LEDs, ce qui est déjà pas mal.

Pour cela, il suffit de copier ceci en début de code :

Code:

#include "FastLED.h"

#define SIM_NUM_ROWS 16
#define SIM_NUM_COLS 16

#define SIM_NUM_LEDS ( SIM_NUM_ROWS * SIM_NUM_COLS )

#define SIM_DATA_PIN 3

CRGB simLedBuff[SIM_NUM_LEDS];

#define NEO_GRB 0
#define NEO_KHZ800 0

class Adafruit_NeoPixel {
  public:
    Adafruit_NeoPixel(uint16_t n, uint16_t pin=6, int dummy=0);
    void begin();
    void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);
    void show();
  private:
    uint16_t _size;
};

Adafruit_NeoPixel::Adafruit_NeoPixel(uint16_t n, uint16_t pin, int dummy) {
  _size = n;
}

void Adafruit_NeoPixel::begin() {
  FastLED.addLeds<NEOPIXEL, SIM_DATA_PIN>(simLedBuff, SIM_NUM_LEDS);
  FastLED.setBrightness(255);
}

void Adafruit_NeoPixel::setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b) {
  if (n >= _size) {
    return;
  }
  if (n < SIM_NUM_COLS ) {
    simLedBuff[ (0 * SIM_NUM_COLS) + (n) ] = CRGB(r, g, b);
    return;
  }
  n -= SIM_NUM_COLS;
  if (n < (SIM_NUM_ROWS-1)) {
    simLedBuff[ ((n+1) * SIM_NUM_COLS) + (SIM_NUM_COLS-1) ] = CRGB(r, g, b);
    return;
  }
  n -= (SIM_NUM_ROWS-1);
  if (n < (SIM_NUM_COLS-1) ) {
    simLedBuff[ (SIM_NUM_ROWS * SIM_NUM_COLS) - (n+2) ] = CRGB(r, g, b);
    return;
  }
  n -= (SIM_NUM_COLS-1);
  if (n < (SIM_NUM_ROWS-2)) {
    simLedBuff[ ((SIM_NUM_ROWS-(n+2)) * SIM_NUM_COLS) + (0) ] = CRGB(r, g, b);
  }
}

void Adafruit_NeoPixel::show() {
  FastLED.show();
}

Et du coup, on peut facilement tester mes exemples précédents
Avec par exemple le code de mon dernier exemple qui change de sens toutes les 3 secondes :

Code:

// ========== < SCRIPT SIMULATION > ==========

#include "FastLED.h"

#define SIM_NUM_ROWS 16
#define SIM_NUM_COLS 16

#define SIM_NUM_LEDS ( SIM_NUM_ROWS * SIM_NUM_COLS )

#define SIM_DATA_PIN 3

CRGB simLedBuff[SIM_NUM_LEDS];

#define NEO_GRB 0
#define NEO_KHZ800 0

class Adafruit_NeoPixel {
  public:
    Adafruit_NeoPixel(uint16_t n, uint16_t pin=6, int dummy=0);
    void begin();
    void setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b);
    void show();
  private:
    uint16_t _size;
};

Adafruit_NeoPixel::Adafruit_NeoPixel(uint16_t n, uint16_t pin, int dummy) {
  _size = n;
}

void Adafruit_NeoPixel::begin() {
  FastLED.addLeds<NEOPIXEL, SIM_DATA_PIN>(simLedBuff, SIM_NUM_LEDS);
  FastLED.setBrightness(255);
}

void Adafruit_NeoPixel::setPixelColor(uint16_t n, uint8_t r, uint8_t g, uint8_t b) {
  if (n >= _size) {
    return;
  }
  if (n < SIM_NUM_COLS ) {
    simLedBuff[ (0 * SIM_NUM_COLS) + (n) ] = CRGB(r, g, b);
    return;
  }
  n -= SIM_NUM_COLS;
  if (n < (SIM_NUM_ROWS-1)) {
    simLedBuff[ ((n+1) * SIM_NUM_COLS) + (SIM_NUM_COLS-1) ] = CRGB(r, g, b);
    return;
  }
  n -= (SIM_NUM_ROWS-1);
  if (n < (SIM_NUM_COLS-1) ) {
    simLedBuff[ (SIM_NUM_ROWS * SIM_NUM_COLS) - (n+2) ] = CRGB(r, g, b);
    return;
  }
  n -= (SIM_NUM_COLS-1);
  if (n < (SIM_NUM_ROWS-2)) {
    simLedBuff[ ((SIM_NUM_ROWS-(n+2)) * SIM_NUM_COLS) + (0) ] = CRGB(r, g, b);
  }
}

void Adafruit_NeoPixel::show() {
  FastLED.show();
}



// ========== < SCRIPT APPLICATION > ==========

#define PIN_PIXELS 3

#define NB_PIXELS 64

Adafruit_NeoPixel pixels ( NB_PIXELS, PIN_PIXELS, (NEO_GRB+NEO_KHZ800) );

void setup() {
  pixels.begin();
}

void loop ( void ) {
   
   uint32_t realTime = millis();
   
   for ( int i = 0 ; i < NB_PIXELS ; i++ ) {
      uint32_t virtualTime;
      if ( ((realTime/3000)%2) == 0 ) {
         virtualTime = (realTime + i*20);
      } else {
         virtualTime = (realTime - i*20);
      }
      uint32_t count = (virtualTime%200);
      uint8_t col;
      if ( count < 100 ) {
         col = map(count, 0, 99, 0, 255);
      } else {
         col = map(count, 100, 199, 255, 0);
      }
      pixels.setPixelColor(i, col, 0, 0);
   }
   
   pixels.show();
   
}

Pardonnez moi le double post mais j'ai reçu un mail de l'auteur du simulateur suite à un petit commentaire laissé sur le site.

Il se trouve qu'il est possible de customiser un peu l'éditeur en ajoutant le paratètre beta-editor=yeah dans l'URL.
Nouveau Lien : https://wokwi.com/playground/neopixel-strip?beta-editor=yeah

Dans l'onglet lesson.md, on peut définir l'interface en rajoutant des LEDs.

Pour rajouter des LEDs, il suffit de rajouter des éléments wokwi-neopixel.
Il peut aussi être utile de rajouter un système de div avec un scale pour faire un ruban plus long contenant beaucoup de LEDs.

Pour un ruban de 60 LEDs, je vous propose ceci :

Code:

<div style="width: 1000px; overflow: visible; transform: scale(0.5); transform-origin: top left;">
<div style="width: 2000px">
<span style="background: #060; padding: 4px 4px 0;">
    <wokwi-neopixel pin="6" pixel="0"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="1"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="2"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="3"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="4"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="5"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="6"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="7"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="8"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="9"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="10"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="11"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="12"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="13"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="14"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="15"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="16"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="17"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="18"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="19"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="20"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="21"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="22"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="23"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="24"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="25"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="26"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="27"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="28"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="29"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="30"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="31"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="32"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="33"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="34"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="35"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="36"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="37"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="38"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="39"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="40"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="41"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="42"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="43"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="44"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="45"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="46"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="47"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="48"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="49"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="50"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="51"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="52"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="53"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="54"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="55"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="56"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="57"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="58"></wokwi-neopixel>
    <wokwi-neopixel pin="6" pixel="59"></wokwi-neopixel>
</span>
</div>
</div>

Après, ça reste du HTML, libre à chacun de définir son ruban comme bon lui semble.
On pourrait aussi faire plusieurs blocs qui serpentent les uns en dessous des autres.

Il est même possible de mettre 2 rubans séparés connecté chacun à une pin différente, cela fonctionne à merveille (ce simulateur est vraiment bien fait).

Reste ensuite à aller dans l'onglet sketch.ino et mettre son code à simuler.

Un petit exemple de sketch pour tester tout ça :

Code:

#include <Adafruit_NeoPixel.h>

#define PIN 6
#define NUMPIXELS 60

Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

void setup() {
  pixels.begin();
}

void loop ( void ) {
   
   uint32_t tm = millis();
   
   for ( int i = 0 ; i < NUMPIXELS ; i++ ) {
      pixels.setPixelColor(i, Adafruit_NeoPixel::ColorHSV( (tm*2-i*50)*50 ) );
   }
   
   pixels.show();
   
}

Bonne animation à tous

Heyo,

Je reviens donner un peu de vie à ce sujet pour y ajouter le petit coup de gueule du jour afin que d'autres membres se lançant là dedans ne fasse pas la même erreur...



Attention avec des petites LED en provenance de Chine, tous les revendeurs ne se valent pas, j'en ai fais l'amère expérience...

Avec seulement une résistance, un condensateur et une LED, on pourrait se dire qu'il n'y a pas de surprise, mais non, il semblerait que ce soit compliqué de recopier ce petit bout de PCB.
Du moins, c'est l'impression que j'ai en constatant que sur les LEDs que j'ai commandées, la résistance de 75 ohm servant à protéger la pin DIN se trouve en série sur la pin VDD et non sur la pin DIN.
Du coup, non seulement elle ne protège pas la pin DIN, mais elle plus elle crée une chute de tension sur la pin VDD qui perturbe fortement la LED et fou toutes mes animations en l'air lorsque la LED est fortement sollicitée

Bref, pour tous ceux qui veulent se lancer là dedans, je conseille vivement de bannir la marque XUNATA qui est pourtant bien notée (je n'arrive pas à comprendre pourquoi il n'y a pas un seul avis négatif évoquant ce problème).

Maintenant, je prends mes LEDs chez BTF-LIGHTING, qui est environ 30% pour chère que XUNATA mais ça se justifie :
- pas d'erreur de conception du PCB
- tous les vias sont doublés (au cas où un via soit oxidé, il en reste un)
- les plages de soudures sont plus larges (donc plus simple à souder)
- les LEDs sont envoyées dans un paquet anti statique (pas de risque de casse à cause des ESD)

Je voudrais ajouter au sujet deux articles sur des méthodes permettant de piloter un grand nombre de LED, que ce soit en rubans ou isolément :
Running Way More LED Strips On A Raspberry Pi With DMA
ESP32 Drives 20,000 WS2812 LEDs
Les commentaires fournissent aussi des détails et des kernels alternatifs avec encore plus de performance.

_________________
"Writing is perhaps the greatest of human inventions, binding together people who never knew each other, citizens of distant epochs. Books break the shackles of time. A book is proof that humans are capable of working magic." (Carl Sagan)

Hackaday vient de publier un court article sur le Neopixel Booster, un système de distribution de puissance adapté aux long rubans de LEDs. Il consiste surtout en un régulateur 5V capable de 4 ampères, afin de limiter les pertes résistives dans le ruban et de maintenir la couleur sur une plus grande longueur.

_________________
"Writing is perhaps the greatest of human inventions, binding together people who never knew each other, citizens of distant epochs. Books break the shackles of time. A book is proof that humans are capable of working magic." (Carl Sagan)

Intéressant, merci du partage.

Dommage que les schémas ne soient pas fournis

_________________
Développeur sur furmap.net

La page du projet sur Hackaday.io n'est pas très lisible mais les sources sont disponibles sur Github :
https://github.com/RoboticsBrno/RB0004-NeopixelBooster

_________________
"Writing is perhaps the greatest of human inventions, binding together people who never knew each other, citizens of distant epochs. Books break the shackles of time. A book is proof that humans are capable of working magic." (Carl Sagan)