Projet de Fontaine à remonter le temps : modifier simplement la couleur des LEDS

International Français
1

Bonjour,

je suis tombé sur ce projet JF Time Fountain et je souhaiterais simplement utiliser un bandeau de LED RGB 5050 (et donc faire varier la couleur à l'aide d'un potentiomètre ou dans une boucle) à la place du bandeau de LEDs blanches.

Visiblement pas si simple...
L'effet est obtenu en faisant varier la fréquence d'éclairage des LEDs (effet stroboscopique) en lien avec la fréquence d'ouverture/fermeture de la valve solénoïde.

Il y a plusieure possibilités à la fois électronique & lignes de code afin de parvenir à un éclairage de couleurs variable tout en conservant scrupuleusement le fonctionnement de la fontaine.

L'arduino nano v3.0 ayant suffisamment de ressources pour cela (y compris l'ajout d'un potentiomètre pour réglé la couleur désirée) j'ai pensé utiliser 2 PIN et 2 mosfet supplémentaires pour gérer le RGB en détournant la PIN utilisée actuellement pour commander le bandeau de LEDs blanches, mais du coups comment gérer la commande stroboscopique sur le bandeau RGB ?
Ou bien utiliser 3 PINs PWM et 3 mosfet pour le RGB et utiliser la PIN (PWM) et le mosfet actuel qui gère l'effet stroboscopique mais en commandant la masse du bandeau ?

Je dispose déjà du bandeau de LEDs 5050 dont je relierais les 3 pin RGB pour obtenir du blanc dans un premier temps avant de savoir gérer le RGB grâce à votre aide dans ce projet...

J'avoue qu'il y a un peu de confusion dans mon esprit de débutant car l'auteur utilise une librairie PWM.h qui permet de changer la fréquence de la sortie PWM utilisé ainsi que des commandes analog.write() sur ces même sorties (celle de LED_strip je crois bien) :-[ ::slight_smile:

Quel serait la solution la plus élégante à votre avis ?

Je joins le schéma électronique (je n'ai pas su l'insérer en tant qu'image) ainsi que le code de jolliFactory - "JF Time Fountain V1.0.ino" dans lequel je pense intégrer le code "Led RGB pot.ino" pour une gestion de la couleur avec un seul potentiomètre.

Merci à vous tous

Gilles

JF_TimeFountain_V1_0.ino (8.22 KB)

Led RGB pot.ino (3.2 KB)

JF Time Fountain.jpg
JF Time Fountain.jpg1024×630 46.9 KB

2

Le code d'origine sera facilement modifiable.

Cependant, si tu mets des LED RGB, c'est 3 couleurs à gérer, donc 3 potentiomètres à lire, ça reste à la portée d'une carte nano.

Une autre idée: 3 boutons pour incrémenter la valeur de chaque couleur?

3

oui trois potentiomètres et pour gérer l'effet stroboscopique vous les allumez ou éteignez à la bonne fréquence - genre blink without delay

On déclare des PINs PWM

// PWM sur les pins 3, 5, 6, 9, 10 or 11 sur un UNO "de base"
const byte pinRouge = 5;
const byte pinVerte = 6;
const byte pinBleue = 9;

On déclare les potentiomètres

// on utilise des potentiomètres connectés sur les entrées analogiques pour faire varier la couleur
const byte pinPotentiometreRouge = A0;
const byte pinPotentiometreVerte = A1;
const byte pinPotentiometreBleue = A2;

On définit des variables pour la couleur du ruban analogique et la gestion du timing

byte pwmRouge = 127;
byte pwmVerte = 127;
byte pwmBleue = 127;
const byte pwmEteint = 0; // NOIR

unsigned long dureeLedsOFF = 10; // gérable aussi par potentiomètre (à rajouter :))
unsigned long dureeLedsON = 3;    // gérable aussi par potentiomètre (à rajouter :))
unsigned long chronoStroboscope;
boolean ledsEteintes;

On définit des fonctions pour allumer ou éteindre le ruban

void eteindreLEDS()
{
  analogWrite(pinRouge, pwmEteint);
  analogWrite(pinVerte, pwmEteint);
  analogWrite(pinBleue, pwmEteint);
  ledsEteintes = true;
}

void allumerLEDS()
{
  analogWrite(pinRouge, pwmRouge);
  analogWrite(pinVerte, pwmVerte);
  analogWrite(pinBleue, pwmBleue);
  ledsEteintes = false;
}

On écrit une fonction qui lit les paramètres

void ajusterParametres()
{
  // quand on enchaine des lectures analogiques sur différentes pins il est bon de laisser la tension
  // à l'entrée de l'ADC se stabiliser et donc on fait une double lecture.
  // un analogRead prends environ 100 µs, donc ça reste rapide

  analogRead(pinPotentiometreRouge);
  pwmRouge = map(analogRead(pinPotentiometreRouge), 0, 1023, 0, 255);

  analogRead(pinPotentiometreVerte);
  pwmVerte = map(analogRead(pinPotentiometreVerte), 0, 1023, 0, 255);

  analogRead(pinPotentiometreBleue);
  pwmBleue = map(analogRead(pinPotentiometreBleue), 0, 1023, 0, 255);
}

Voilà le corps du code n'a plus qu'à faire

void setup() {
  Serial.begin(115200);
  pinMode(pinRouge, OUTPUT);
  pinMode(pinVerte, OUTPUT);
  pinMode(pinBleue, OUTPUT);
  eteindreLEDS();
  chronoStroboscope = 0;
}

void loop()
{
  // gestion des potentiomètres
  ajusterParametres();

  // Effet stroboscope
  if (ledsEteintes) {
    if (millis() - chronoStroboscope >= dureeLedsOFF) {    // est-ce le moment de les allumer ?
      allumerLEDS();
      chronoStroboscope = millis();
    }
  } else {
    if (millis() - chronoStroboscope >= dureeLedsON) {    // est-ce le moment de les éteindre ?
      eteindreLEDS();
      chronoStroboscope = millis();
    }
  }

//... ici vous gérez la pompe et vanne un peu de manière similaire

}

ou un truc approchant.. (tapé ici)

bien sûr les pins gèrent du PWM pas directement sur le ruban, il y a un MOSFET N-channel du genre IRLB8721 entre les 2 pour piloter la puissance.

4

Je verrais bien un quatrième potard pour faire varier la fréquence (le duty cycle) du PWM autour de la valeur initiale, afin de voir les gouttes monter ou descendre lentement

5

lesept:
Je verrais bien un quatrième potard pour faire varier la fréquence (le duty cycle) du PWM autour de la valeur initiale, afin de voir les gouttes monter ou descendre lentement

oui c'est l'objet du commentaire sur

unsigned long dureeLedsOFF = 10; // gérable aussi par potentiomètre (à rajouter :))
unsigned long dureeLedsON = 3;    // gérable aussi par potentiomètre (à rajouter :))

En pratique un strobe c'est un flash rapide et un moment bcp plus long éteint, donc il faudrait 2 potentiomètres pour bien faire, un pour la durée allumée et un pour la durée éteinte, d'où l'idée des 2 valeurs

6

Merci beaucoup les gars,

il ne s'agit pas d'un projet "from scratch" mais d'une tentative de modification la plus légère possible d'un projet très complet.

@Jambe : je suis bien content d'avoir trouvé un petit code bien astucieux (que je fournis en fichier attaché) qui me permettra d'obtenir quasiment toutes les couleurs de l'arc en ciel et plus, juste en tournant un seul potentiomètre...

@lesept : ce qui est déjà prévu dans le projet, c'est un capteur de distance IR ( j'ai un GP2D120 de sharp) qui fait varier le processus stroboscopique bandeau de leds + gouttes d'eau en approchant la main ou en l'éloignant ( montré sur la vidéo ), en plus il est prévu 4 modes de fonctionnement. Mais c'est vrai que j'avais aussi pensé à remplacer le capteur IR par un potentiomètre...

@J-M-L : merci beaucoup pour cette étude détaillé :slight_smile: Comme je le disais il ne s'agit pas d'un projet "from scratch". Je voudrait simplement remplacer le bandeau de leds blanches du montage de JolliFactory par un bandeau de leds RGB 5050 dont je dispose, et y ajouter le réglage de la couleur bien sûr, en utilisant un seul potentiomètre supplémentaire comme je l'explique plus haut à "Jambe" :slight_smile:

Donc la boucle principale du code de JolliFactory fait déjà pas mal de chose : la gestion du bouton poussoir pour commuter les 4 modes de fonctionnement, la gestion des 3 potentiomètres actuels (auxquels il faudrait en ajouter 1 ou 2), la gestion de la puissance de la pompe à eau, du solénoïde pour les bulles associée à celle du bandeau de LEDs (c'est là qu'il me faut changer des choses :wink: ), et je crois bien que c'est tout :slight_smile:

Pour le coeur même de ce petit projet qui est le réglage de la fréquence stroboscopique du bandeau de LEDs ajustée je suppose au pouillem près en association avec la fréquence du solénoïde pour les bulles, l'auteur à choisit d'utiliser une librairie PWM.h qui permet simplement de modifier la fréquence PWM de la broche utilisée (actuellement un bandeau de LEDs blanches donc 1 seule sortie) mais il applique aussi simplement la commande AnalogWrite sur cette même broche pour allumer ou éteindre progressivement le bandeau de LEDs dans des petites boucles...

Penses-tu qu'il soit possible de remplacer tout cela en se passant de la librairie PWM.h au bénéfice de l'allumage/extinction des 3 pin de sortie RGB (via les mosfet bien sûr) à la bonne fréquence variable gérée au sein même de la boucle principale du code actuel ?

Bien amicalement

Gilles