Guirlande sur mesure

Bonjour,

Je vous sollicite (encore) dû à mon manque d'expérience.

Je souhaite faire une petite guirlande pour mettre dans un "bonhomme de neige" (en verre de plastique type verre jetable).

Pour la partie câblage sa ira mais pour la partie code j'ai essayé en combinant plusieurs recherche internet mais malheureusement ça ne fonctionne pas.

La led bleu réagis comme je veux mais pas les deux autres.

Ce que je souhaite faire :

1 : la LED bleu s'allume progressivement (variation de la luminosité)
2 : la LED bleu s’éteint aussi progressivement et la rouge commence à s'allumer aussi progressivement
3 : la LED rouge s'éteint progressivement en allumant la jaune .....

En tout j'ai 4 couleurs de LED. (j’hésite à en mettre 5 mais avant il faut que je trouve le code correct) :smiley:

voici le code que j'ai trouvé (et que j'ai essayé de modifier en vain :

int luminosite1 = 0;    // % de temps o� la LED est allum�e
int variation1 = 5;    // intervalle de variation de la luminosit�
int luminosite2 = 0;    // % de temps o� la LED est allum�e
int variation2 = 5;    // intervalle de variation de la luminosit�
int luminosite3 = 0;    // % de temps o� la LED est allum�e
int variation3 = 5;    // intervalle de variation de la luminosit�
int bleu = 9;
int rouge = 8;
int vert = 7;

void setup()  {
  // configure la broche 9 en SORTIE
  pinMode(bleu, OUTPUT);
  pinMode(rouge, OUTPUT);
  pinMode(vert, OUTPUT);
}

void loop()  {
  // applique une impulsion de largeur correspondant � la luminosit� sur la broche 9
  analogWrite(bleu, luminosite1);    

  // modifie la luminosit� pour le passage suivant dans la boucle loop()
  luminosite1 = luminosite1 + variation1;

  // inverse le sens de variation de la luminosit� quand on atteint les valeurs extremes 0 ou 255
  if (luminosite1 == 0 || luminosite1 == 255) {
    variation1 = -variation1 ;
  }    
  // pause de 30 millisecondes pour voir l'effet de variation    
  delay(100);      

    // applique une impulsion de largeur correspondant � la luminosit� sur la broche 9
  analogWrite(rouge, luminosite2);    

  // modifie la luminosit� pour le passage suivant dans la boucle loop()
  luminosite2 = luminosite2 + variation2;

  // inverse le sens de variation de la luminosit� quand on atteint les valeurs extremes 0 ou 255
  if (luminosite2 == 0 || luminosite2 == 255) {
    variation2 = -variation2 ;
  }    
  // pause de 30 millisecondes pour voir l'effet de variation    
  delay(100);

      // applique une impulsion de largeur correspondant � la luminosit� sur la broche 9
  analogWrite(vert, luminosite3);    

  // modifie la luminosit� pour le passage suivant dans la boucle loop()
  luminosite3 = luminosite3 + variation3;

  // inverse le sens de variation de la luminosit� quand on atteint les valeurs extremes 0 ou 255
  if (luminosite3 == 0 || luminosite3 == 255) {
    variation3 = -variation3 ;
  }    
  // pause de 30 millisecondes pour voir l'effet de variation    
  delay(100);
  
}

S'il vous plait aider moi car mon code est faux et je n'arrive pas à le modifier pour qu'il fonctionne

bonjour,
pourquoi faire trois fois le même code?
vu que tu prends les même valeurs, gardes juste

luminosite1 = luminosite1 + variation1;

on ne va pas rentrer dans la simplification extrème.

void loop()  {
  analogWrite(bleu, luminosite1);
  delay(100);
  analogWrite(rouge, luminosite1);
 delay(100);
analogWrite(vert, luminosite1);
delay(100);

if (luminosite1 == 0) luminosite1 = luminosite1 + variation1;
if ( luminosite1 == 255)luminosite1 = luminosite1 - variation1;

}

Après, tes leds ont besoin de quel voltage pour fonctionner?
As tu testé juste le code bleu avec les autres leds?
résistance sur les leds?

Bonjour,

J'ai essayé de mettre les conditions 1 fois pour les différentes LED mais ça ne fonctionnais pas alors j'ai essayé de répéter ce code pour chaque LED en vain.

Mes LED sont alimenté via l'arduino NANO qui lui est alimenté par une pile de 9V.
les LED sont en série avec une résistance de 220 ohm et j'ai essayé aussi avec 330 ohm.

Lorsque j'inverse les LED entre elle seul une fonctionne que je le voudrais (celle qui est sur la broche 9).

as tu regardé les symboles sur la carte?
pin 9 ~ =>pwm possible
pin 8 et 7 rien => digital donc high ou low ou 1 et 0
donc tu essaye de faire du pwm sur des pins digitales au lieu d'analogiques
change 7 et 8 par 10 et 11
mets aussi

const int bleu = 9;
const int rouge = 10;
const int vert = 11;

ou

#define bleu 9
#define rouge 10
#define vert 11

avec ca, ca devrait le faire

#define bleu 9
#define rouge 10
#define vert 11
int luminosite1 = 0;
int variation1 = 5;

void setup()  {
  // configure la broche 9 en SORTIE
  pinMode(bleu, OUTPUT);
  pinMode(rouge, OUTPUT);
  pinMode(vert, OUTPUT);
}

void loop()  {
  analogWrite(bleu, luminosite1);
  delay(100);
  analogWrite(rouge, luminosite1);
 delay(100);
analogWrite(vert, luminosite1);
delay(100);

if (luminosite1 == 0) luminosite1 = luminosite1 + variation1;
if ( luminosite1 == 255)luminosite1 = luminosite1 - variation1;

}

merci pour vos conseils.

J'ai essayé votre code mais il n'a pas fonctionné, en effet les led s'allume mais leur luminosité ne variaient pas.

mais grâce à vos conseils j'ai réussi à les faire varié.

Mon derniers problème c'est qu'elle varie en même temps en suivant se temps :

1/ toutes éteintes
2/ toutes s'allume progressivement
3/ toutes s'éteigne progressivement

auriez vous d'autres conseils pour qu'elle s'allume chacune après l'autre en suivant se temps:

1/ toutes éteintes
2/ la LED bleu s'allume puis s'éteint progressivement
3/la LED rouge ....

PS le code que j'ai mis est le suivant (en suivant tes consignes):

int luminosite = 0;    // % de temps où la LED est allumée
int variation = 5;    // intervalle de variation de la luminosité
const int bleu = 9;   // déclaration de la pin 9 pour la LED bleu
const int rouge = 10; //  déclaration de la pin 10 pour la LED rouge
const int vert = 11;  // déclaration de la pin 11 pour la LED verte

void setup()  {
  // configuration des broche en SORTIE
  pinMode(bleu, OUTPUT);
  pinMode(rouge, OUTPUT);
  pinMode(vert, OUTPUT);
}

void loop()  {
  // applique une impulsion de largeur correspondant à la luminosité
  analogWrite(bleu, luminosite);    
  analogWrite(rouge, luminosite);
  analogWrite(vert, luminosite);    

  // modifie la luminosité pour le passage suivant dans la boucle loop()
  luminosite = luminosite + variation;

  // inverse le sens de variation de la luminosité quand on atteint les valeurs extremes 0 ou 255
  if (luminosite == 0 || luminosite == 255) {
    variation = -variation ;
  }    
  // pause de 30 millisecondes pour voir l'effet de variation    
  delay(100);                            
}

pour faire varier les bleues, puis les rouges puis les vertes il faut ajouter une variable disons "couleur"
quand le cycle d'une couleur est terminé, on passe à la suivante ... et quand on est à la dernière on recommence ...

par exemple ce genre de code irait ... mais il y a mieux !

byte couleur = 0 ; //selection de la couleur : 0 = leds bleues, 1 = rouges 2 = vertes

//allume la voie couleur (0 1 ou 2 bleu rouge vert) en fonction de la luminosite
void set_sorties () {                    
  if (luminosite < 0) luminosite =0;           //cas d'erreur de valeur (0 à 255 seulement)
  if (luminosite > 255) luminosite = 255;    //cas d'erreur de valeur (0 à 255 seulement)
  if (couleur  > 2) couleur = 0;                                  //cas d'erreur de valeur (0 à 2    seulement)

  if (couleur == 0) {
      analogWrite(bleu, luminosite );   //allume le bleu
      analogWrite(rouge, 0); //eteint les autres
      analogWrite(vert, 0);
  } else if (couleur == 1) {
      analogWrite(rouge, luminosite ); //allume le rouge
       analogWrite(bleu, 0);              //eteint les autres       
      analogWrite(vert, 0);
  } else if (couleur == 2) {
      analogWrite(vert, luminosite ); //allume le vert
      analogWrite(bleu, 0);             //eteint les autres       
      analogWrite(rouge, 0);
  }
}

void loop() {
  // applique une impulsion de largeur correspondant à la luminosité
  set_sortie(couleur);

  // modifie la luminosité pour le passage suivant dans la boucle loop()
  luminosite = luminosite + variation;

  // inverse le sens de variation de la luminosité quand on atteint les valeurs extrêmes 0 ou 255
  if (luminosite <= 0 || luminosite >= 255) { //au cas ou ça dépasse les bornes sans avoir l'égalité
    variation = -variation ; //changement de sens
    if (luminosite <= 0)  {
         //on est a la fin d'une couleur
         couleur = couleur + 1; //passe à la couleur suivante (le retour à zero est géré dans set_sorties)
    }

  }   
  // pause de 100 millisecondes pour voir l'effet de variation   
  delay(100);                           
}

Merci pour vos conseils.

Maintenant que je vois la solution ça me parait logique.

Je suis déçus de ne pas y avoir pensé.

Par contre j'ai un petit message d'erreur et peut être que la solution est facile (et j'en doute pas) mais je ne sais pas comment la résoudre :

exit status 1
'set_sortie' was not declared in this scope

mais pour la déclarer dois-je juste l'écrire avant le void setup ?

non il y a juste une erreur :

  • la fonction s'appelle : void set_sorties ()
  • l'appel a la fonction : set_sortie();
    il faut donc mettre en concordance

Mea culpa !

En effet je n'avais pas vu.

Je suis surement embêtant mais il y a un autre message d'erreur:

exit status 1
too many arguments to function 'void set_sortie()'

j'ai vérifier l’orthographe de chaque ligne mais je n'ai rien vu

Oui effectivement ... est en forgeant qu'on devient forgeron ... regarde comment est déclarée la fonction et comment elle est appelée .. il y a un souci expliqué par le message d'erreur

Il faut appeler la fonction sans argument (au début je pensais que ce serait utile ...)

set_sorties();

jamais je n'aurais pensé à ça :astonished: en tout cas merci à vous tous pour tous ces conseils, indications et votre rapidité.
Vivement que je gère mieux pour à mon tour, aider les autres mais c'est pas encore pour demain :smiley:

Pour que ça puisse servir à d'autre je met le code complet :

int luminosite = 0;    // % de temps où la LED est allumée
int variation = 5;    // intervalle de variation de la luminosité
const int bleu = 9;   // déclaration de la pin 9 pour la LED bleu
const int rouge = 10; //  déclaration de la pin 10 pour la LED rouge
const int vert = 11;  // déclaration de la pin 11 pour la LED verte
byte couleur = 0 ; //selection de la couleur : 0 = leds bleues, 1 = rouges 2 = vertes

void setup()  {
  // configuration des broche en SORTIE
  pinMode(bleu, OUTPUT);
  pinMode(rouge, OUTPUT);
  pinMode(vert, OUTPUT);
}



//allume la voie couleur (0 1 ou 2 bleu rouge vert) en fonction de la luminosite
void set_sorties () {                    
  if (luminosite < 0) luminosite =0;           //cas d'erreur de valeur (0 à 255 seulement)
  if (luminosite > 255) luminosite = 255;    //cas d'erreur de valeur (0 à 255 seulement)
  if (couleur  > 2) couleur = 0;                                  //cas d'erreur de valeur (0 à 2    seulement)

  if (couleur == 0) {
      analogWrite(bleu, luminosite );   //allume le bleu
      analogWrite(rouge, 0); //eteint les autres
      analogWrite(vert, 0);
      delay(50);
      
  } else if (couleur == 1) {
      analogWrite(rouge, luminosite ); //allume le rouge
       analogWrite(bleu, 0);              //eteint les autres       
      analogWrite(vert, 0);
  } else if (couleur == 2) {
      analogWrite(vert, luminosite ); //allume le vert
      analogWrite(bleu, 0);             //eteint les autres       
      analogWrite(rouge, 0);
  }
}

void loop() {
  // applique une impulsion de largeur correspondant à la luminosité
   set_sorties();

  // modifie la luminosité pour le passage suivant dans la boucle loop()
  luminosite = luminosite + variation;

  // inverse le sens de variation de la luminosité quand on atteint les valeurs extrêmes 0 ou 255
  if (luminosite <= 0 || luminosite >= 255) { //au cas ou ça dépasse les bornes sans avoir l'égalité
    variation = -variation ; //changement de sens
    if (luminosite <= 0)  {
         //on est a la fin d'une couleur
         couleur = couleur + 1; //passe à la couleur suivante (le retour à zero est géré dans set_sorties)
    }

  }   
  // pause de 100 millisecondes pour voir l'effet de variation   
  delay(100);                           
}

L'inconvénient des projets arduino ... c'est qu'on peut toujours ajouter un truc ...

Tu pourrais faire varier les sorties en même temps, ou en décalé ou à des fréquences différentes ... ou les faire clignoter ... faire plusieurs effets que tu sélectionnes avec des boutons ...

Plein de trucs rigolo à faire et qui te permettront d'apprendre

oui on a prévu de faire des modifications mais pas facile quand on est débutant lol

mais ça nous apprend pas mal de chose

On va regarder ce que l'on va faire et je vous partagerais nos idées

je suis très preneur de conseil et merci à vous

On va regarder ce que l'on va faire et je vous partagerais nos idées

ca sent le projet exam

Voici des photos de mon projet.
Plus qu'à l'améliorer.

-->(ce n'est pas un projet d'exam, je suis en CDI dans une grande entreprise française)<--