Projet plaque lumineuse (type enseigne) mais plus encore :p

Bonjour, suite à mes tests sur différent format de matrice, je fais référence à ce sujet qui m'a permis de comprendre et d'avancer.

Je cherche à peaufiner mon projet de plaque lumineuse, celle-ci sera placé dans un camion en 24V.
J'ai déjà trouvé un transformateur 24-12V 20A qui sera suffisant.
J'ai vu à plusieurs endroit qu'il fallait mettre un condensateur, pouvez vous m'aiguiller sur une référence ? Si je comprends bien, celui-ci est à mettre entre le + et - au début de la bande de led ?
La valeur de 1000uF 10V sera-t-elle adaptée sur mon montage ? (exemple du montage serpentin ci -dessous)

Photo du projet en cours:

L'arduino est un modèle MEGA, afin de gagner de la place sur les différentes images à l'origine que j'avais prévu, je souhaite gérer mes bandes de leds par ligne, comme une enseigne par exemple, avec des dégradés, clignotements… De cette manière, j'imagine qu'un code (que j'ai déjà vu) pourrait mettre en mouvement ces différentes lignes, cela serait plus léger que de mettre plusieurs images (50 voir 100 :sweat_smile: )

J'ai donc trouvé plusieurs code et plusieurs idées, cependant, chaque solution et bien sur à adapter.

Dans les faits, je pense utiliser et rester sur la bibliothèque fastled.
Le montage actuel est en serpentin.

  • Le premier inconvénient est que ça me fait inversé mon code sur les lignes paires sur chaque image. (cf: premier sujet du forum ci dessus) j'ai une belle solution mais ça reste fastidieux.
  • Le deuxième serait la gestion du code (inconnu à ce jour :laughing: ) Il faudrait que je gère chaque bande de la première leds à la soixantième, les une à la suite des autres en pensant à l'inversion :crazy_face:

Entrons dans le vif du sujet :nerd_face:
Afin de simplifier tout ça, je me dis qu'il serait plus intéressant que je gère chaque ligne indépendamment en utilisant 10 broches de l'arduino MEGA, une pour chaque ligne.
Je pourrais ainsi adapter ce code en remettant chaque bande de leds dans le même sens:
source: LOCODUINO - Enseigne de magasin

/*
 * Programme pour arduino uno
 * par C. Bézanger Octobre 2013
 * Licence GNU GPLv3
 *
 * Ce programme réalise le clignotement d'une enseigne publicitaire.
 * Il fait clignoter selon un certain rythme six Leds reliées aux sorties 4 à  9.
 * Il utilise des fonctions pour alterner les rythmes.
*/
 
/*
 * Initialisation des broches 4 à 9 en sortie
 */
void setup () {
  pinMode (4, OUTPUT) ;
  pinMode (5, OUTPUT) ;
  pinMode (6, OUTPUT) ;
  pinMode (7, OUTPUT) ;
  pinMode (8, OUTPUT) ;
  pinMode (9, OUTPUT) ;
}
 
/*
 * Fonction loop
 */
void loop () {
  // Extinction de toutes les Leds au départ du programme
  for (byte i = 4 ; i <= 9 ; i++) 
  {
    digitalWrite (i, LOW) ; // éteint la Led reliée à la broche i
  }
 
  // Séquence N°1 ; chenillard
  sequence_Un () ;
  delay (500) ;  // délai de 500 millisecondes
 
  // Séquence N°2 : cumul sur la gauche du mouvement de Led
  sequence_Deux () ;
  delay (500) ;  // délai de 500 millisecondes
 
  // Séquence N°3 : clignotement de l'ensemble 3 fois
  sequence_Trois () ;
  delay (2000) ; // délai de 2 secondes
 
  // Séquence 4 : extinction successive de la gauche vers la droite
  sequence_Quatre () ;
  delay (2000) ; 
 
  // Recommence la séquence
}
 
/*
 * Séquence N°1 ; chenillard
 */
void sequence_Un ()
{
  for (byte n = 0 ; n <= 2 ; n++)
  {
    for (byte i = 4 ; i <= 9 ; i++)
    {
      digitalWrite (i, HIGH) ;    // allume la Led sur broche i
      delay (100) ;               // durée du flash 150 millisecondes
      digitalWrite (i, LOW) ;     // éteint la Led
      delay (50) ;
    }
  }
}
 
/*
 * Séquence N° 2 : cumul sur la gauche du mouvement de Led
 */
void sequence_Deux ()
{
  for (byte n = 0 ; n <= 5 ; n++)
  {
    for (byte i = 4 ; i <= (9-n) ; i++)
    {
      digitalWrite (i, HIGH) ; // allume la Led sur broche i
      delay (150) ;            // durée du flash 150 millisecondes
      digitalWrite (i, LOW) ;  // éteint la Led
    }
    digitalWrite ( (9 - n) , HIGH ) ; // dernière Led reste allumée
  }
}
 
/*
 * Séquence N°3 : clignotement de l'ensemble 3 fois
 */
void sequence_Trois ()
{
  for (byte j = 1 ; j <= 3 ; j++) 
  {
    for (byte k = 4 ; k <= 9 ; k++) 
    {
      digitalWrite (k , LOW) ;
    }
    delay (500) ;
    for (byte l = 4 ; l <= 9 ; l++) 
    {
      digitalWrite (l, HIGH) ;
    }
    delay (500) ;
  }
}
 
/*
 * Séquence 4 : extinction successive de la gauche vers la droite
 */
void sequence_Quatre ()
{
  for (byte i = 9 ; i >= 4 ; i--) 
  {
    digitalWrite (i, LOW) ;
    delay (150);
  }
}

En utilisant ce code,
- je m'interroge sur la manière de laisser inerte certaine leds adressables et d'en allumer d'autre (en utilisant les animations bien sur)
- je me demande aussi comment gérer la couleur :
- par ligne ?
- sur l'ensemble ?
- avec des dégradés ?
- et pourquoi pas un effet Rainbow sur l'ensemble ?

Une dernière question qui pourrait remettre à nouveau en question l'architecture du montage :dizzy_face: (désolé :weary: )
Si je voulais adapter ce bel effet de feu, avec ce code, serait-ce envisageable ?
Vidéo: Quick video of "Fire2012" Here's what the "Fire2012" fire simulation looks like when running - FastLED Archive - Maker Forums
Code: Fire2012: an Arduino/LED fire simulation for FastLED - Pastebin.com

Je vous remercie déjà de m'avoir lu, et j'espère susciter votre intérêt et je comprends bien que je n'apporte pas grand chose comme code, à défaut de beaucoup de question que j'ai mis en italique pour apporter de la clarté :innocent:

Je cherche avant tout à comprendre en plus de réaliser mon projet.
L'idée étant également de pouvoir reproduire d'autres modèles pour des collègues/amis.

Merci
Patrice

Pour la connexion et les composants, tout est indiqué ici :

Lis l'ensemble des pages, ça fourmille d'informations. Si tu utilises une broche par ligne, il te faudra autant de résistances.

Pas de led inerte : pour celles qui ne sont pas allumées, tu mets simplement 0 dans le tableau.
La gestion de la couleur dépend de ton programme, c'est toi qui choisis. Il faut réfléchir à l'impact du câblage sur la complexité de la programmation.

avec FastLED regardez cet exemple :

il gère le câblage que vous avez avec une variable ➜ kMatrixSerpentineLayout

// Set 'kMatrixSerpentineLayout' to true if your pixels are 
// laid out back-and-forth, like this:
//
//     0 >  1 >  2 >  3 >  4
//                         |
//                         |
//     9 <  8 <  7 <  6 <  5
//     |
//     |
//    10 > 11 > 12 > 13 > 14
//                        |
//                        |
//    19 < 18 < 17 < 16 < 15

Bonjour lesept

Ayant aperçu les différents codes entre Adafruit et Fastled, j'avoue avoir eu une préférence pour Fastled. Je ne suis pas fermé mais ça me ferais tout reprendre de zéro.

Je prends note pour la résistance qui permet du coup de protéger la première led qui reçoit les données. Je suppose que cela est conseillé peut importe le modèle de led adressable ? Ce qui me fait penser que je n'ai pas indique sur ce sujet que j'utilisais des WS2812.

Je me suis mal exprimé concernant mes leds inertes, je parlais effectivement de leds éteintes.

Je ne suis pas contre de recâbler et/ou modifier mon installation, cependant, je comprends bien que la programmation peut vite devenir un casse-tête à mon niveau :sweat_smile:

Merci pour ton aide.
Patrice

Bonjour J-M-L

J'ai justement utilisé ce code pour mes différents tests.
Ca fonctionne bien, mais si par exemple, sur le serpentin, je souhaite allumer avec cet effet seulement les leds 1 - 2 - 3 puis 8 - 6 suivi de 11 - 13 et pour finir 18 - 17 - 16, ce qui correspondrait à un 0, c'est là ou je sèche, j'imagine que je peux faire un tableau qui indiquerait quelle leds resteraient éteintes ou en fonction, mais j'ai du mal à comprendre comment intégrer le tableau par exemple de mon premier sujet avec ce dernier code.

Merci encore pour votre aide.

L’idée n’est plus de réfléchir sous forme de position linéaire mais en coordonnées 2D (X et Y)

Je vois bien le principe de la 2D.
Je vais donc chercher à la mettre en place...
Merci

Bonjour,
C'est à partir d'un autre fil de discussion que j'ai découvert le programme GLEDIATOR. En gros, il gère une matrice de led générant un fichier avec l'" animation " reproductible ensuite par l'arduino. Je n'ai pas approfondi le sujet mais je pense que vous devriez y jeter un œil vous-même.
Regards.

Bonjour gonpezzi.

Merci pour cette piste très intéressante.
Je vais me renseigner.

Vis à vis de mon post, j’ai également eu des retours très intéressant sur Reddit.

Ce n’est pas très apprécié ici de voir des demandes dupliquées… des bénévoles vont vous donner leur temps pour écrire une réponse que vous aurez déjà eu potentiellement par ailleurs… ce temps de leur vie aurait été mieux investi à aider quelqu’un d’autre…

Perso quand dej vois cela, je passe mon chemin car ce n’est pas respectueux

Bonjour J-M-L, je n’ai bien entendu à aucun moment voulu être irrespectueux.

La piste concernant glediator est très intéressante d’après ce que j’ai déjà aperçu.
Le message de gonpezzi est du coup très apprécié et pertinent.

Très sincèrement
Patrice

Je me doute que ce n’était pas intentionnel, mais pensez y la prochaine fois.
Postez à un endroit. Attendez des réponses. Si pas de réponse au bout d’un moment (quelques jours)), allez poster ailleurs et dites le pour éviter que ceux qui cherchent à vous aider ne perdent leur temps.

J’en prends bonne note J-M-L. Merci