Marche Arrêt de 5 LED

Bonjour, Alors je m'oppose à un problème sur mon projet, je m'explique je dois réaliser un montage qui comporte 5 LEDs et 5 boutons ( qui doivent se comporter comme des interrupteurs pour commander les LEDs) en étant un total débutant je galère comme pas possible. Mon problème, j'ai essayé un code mais il me permet seulement d'allumer les leds après un appui sur un bouton mais je souhaiterais pouvoir les éteindre suite un second appuie. Mais je n'arrive pas à trouver une solution si une âme charitable pourrait aider la brêle que je suis ça serait super XD

Mon code :

`// Les constantes
const int bpRouge=2;
const int bpVert=3;
const int bpJaune=4;
const int bpBleu=5;
const int bpBlanc=6;

const int ledRouge=9;
const int ledVert=10;
const int ledJaune=11;
const int ledBleu=12;
const int ledBlanc=13;

// Définition des états
void setup()
{
  pinMode(ledRouge,OUTPUT);
  pinMode(ledVert,OUTPUT);
  pinMode(ledJaune,OUTPUT);
  pinMode(ledBleu,OUTPUT);
  pinMode(ledBlanc,OUTPUT);

  pinMode(bpRouge,INPUT);
  pinMode(bpVert,INPUT);
  pinMode(bpJaune,INPUT);
  pinMode(bpBleu,INPUT);
  pinMode(bpBlanc,INPUT);

}


void loop()
{

  // Variables booléénes - Etat des boutons - false/true
  bool bpRougeEtat = digitalRead(bpRouge);
  bool bpVertEtat = digitalRead(bpVert);
  bool bpJauneEtat = digitalRead(bpJaune);
  bool bpBleuEtat = digitalRead(bpBleu);
  bool bpBlancEtat = digitalRead(bpBlanc);
  
  if (bpRougeEtat==true){     // Si bouton rouge est appuyé
    digitalWrite(ledRouge,1);  // l'état LED rouge est à true
  
  }
    
  if (bpVertEtat==true){        // Si bouton vert est appuyé
    digitalWrite(ledVert,1);  // l'état LED vert est à true
  
  }

  if (bpJauneEtat==true){        // Si bouton Jaune est appuyé
    digitalWrite(ledJaune,1);  // l'état LED Jaune est à true
 
    
  }

  if (bpBleuEtat==true){        // Si bouton Bleu est appuyé
    digitalWrite(ledBleu,1);  // l'état LED Bleu est à true
   
    
  }

  if (bpBlancEtat==true){        // Si bouton Blanc est appuyé
    digitalWrite(ledBlanc,1);  // l'état LED Blanc est à true
    
    
  }
}`   

Mon Schéma :

Je vous remercie d'avance pour les aides à venir :grinning:

Bonjour, une des manières serait de créer une variable de type bool qui contenait le statut de la led et par exemple pour la led verte le if pourrait être comme ça :

  if (bpVertEtat == true) {     // Si bouton vert est appuyé
    delay (150); // on met de l'anti-rebond
    EtatVert = ! EtatVert; // Changer l'état de la nouvelle variable
    digitalWrite(ledVert, EtatVert); //s'allume ou s'éteint selon l'état de la nouvelle variable.
  }

Les salutations.

Il vaut mieux commencer par une seule led, si cela fonctionne, on y met les autres.

La mémorisation de l'état de la led peut se faire par une variable (voir post #2) ou directement par digitalRead(pinDeLaLed). Cela peut alors faire:

if (???????){     // Si on vient d'appuyer sur le bouton rouge est appuyé
    if (digitalRead(ledRouge) == HIGH) // SI la led est allumée
       digitalWrite(ledRouge,LOW);  // On l'éteint
  else digitalWrite(ledRouge,HIGH);  // On l'allume
}

Les inters ont des rebonds. pendant quelques 20ms ils n'arrêtent pas de changer d'état. Pour éviter de prendre en compte ces états, insérer si on allume ou on éteint une led une petite attente genre delay(20); (20 millisecondes). On peut mettre plus.

"Si on vient d'appuyer sur le bouton rouge" veut dire qu'il était à LOW et qu'il passe à HIGH, il faut donc se rappeler si il était à LOW ou à HIGH.
boolean etatBoutonRouge = LOW // Au départ du programme les boutons ne sont pas appuyés
Puis on va dire:

if (bpRougeEtat == HIGH) {
  if ( (ancienEtatBoutonRouge == LOW) {
    <code pour inverser l'état de la led + délai>
    ancienEtatBoutonRouge = HIGH; // On mémorise que le bouton est appuyé
  }
else { // (bpRougeEtat == LOW)
  ancienEtatBoutonRouge = LOW;  // On mémorise que le bouton est relâché
}

Cher @vileroi, vous m'avez rappelé que vous pouviez lire une broche déclarée en sortie, avec cela, nous simplifions davantage le problème.

   if (digitalRead(bpVert)) { // Si bouton vert est appuyé
   digitalWrite(ledVert, !digitalRead(ledVert));
   delay (150); // on met de l'anti-rebond
  }

Les salutations.

Formulation typique d'un devoir scolaire.
Il est demander de l'annoncer dès le premier message.

Rappel : chacun fait comme il veut mais pour les travaux scolaires il y a un concensus qui est de ne pas faire le travail à la place de l'élève, ce serait de la triche.

Par contre on peut les guider en les mettant sur la voie pour les aider à trouver la solution.
Ces élèves ne sont pas considérés comme des débutants anonymes, ils ont des cours de programation.

Dans l'intérêt des élèves il est préférable d'éviter de leur proposer des astuces de programation qui dépassent leur niveau.
Le professeur n'aura aucun doute sur le coté "copié" du travail..

S-SI ou STI-2D ?

Bonjour thomas00000

Concernant ton montage, tu peux le simplifier en supprimer les résistances de PULL_DOWN, en initialisant tes entrées boutons par pinMode(bpRouge,INPUT_PULLUP) et en les lisant par if (bpRougeEtat==LOW)
Dans ton projet, comme tu as beaucoup d'objets à traiter, entrées et sorties, il est plus aisé de les mettre en tableaux, regardes ici.

Cordialement
jpbbricole

Bonjour,

oui c'est devoir scolaire mais la seule chose et le fait que dans ma formation ( BAC Pro Sn option SSIHT ) nous n'avons pas de cours de programmation et devons apprendre nous-mêmes à faire ce montage et code, les seul aide donné par nos professeurs sont les erreurs à revoir dans notre code ou câblage, d'où ma venue sur le forum pour pouvoir sortir de cette impasse et apprendre par la même occasion.

Cordialement et merci de ton indication

Mon détecteur est encore fonctionnel :grinning:,
Ta réponse est très bien, les choses sont claires, c'est une très bonne habitude à prendre.

Je ne vais pas polémiquer sur le niveau des "cours" de programmation.
Je t'indique qu'il existe une fantastique documentation sur Arduino : les tutos d'Eskimon

Le grand intérêt du travail d'Eskimon est qu'il traite autant de la programmation que de la mise en œuvre du matériel ce qui est assez rare.
Cerise sur le gâteau tout est en français.

Je pense qu'un puriste te dirait de ne pas faire comme cela, même si cela fonctionne.

Pourquoi cela fonctionne ?
Parce que, quand une entrée est au niveau HAUT, par convention, le registre de l'entrée renvoie "1" (et "0" si état BAS)
Quant au variable booléennes, toujours par convention, on attribue la valeur "1" à l'état "true" et la valeur "0" à l'état false.
Une convention est arbitraire et si elle avait été différente, cela n'aurait pas fonctionné.

Tu as pu le voir dans des exemples parce que souvent les personnes, qui maîtrisent et qui savent ce qu'elles font, prennent des libertés avec la rigueur.
Par contre, c'est déconseillé quand on débute.

D'autant que le conseil qui t'a été donné d'utiliser une variable booléenne pour garder l'état de la diode est très bon, mais il faut que ces variables ne reçoivent que les mots clé "true" ou "false".
La compréhension et la mise au point sera plus facile.

Autres points : Usage de setup() et loop() et Portée des variables.
Les noms des fonctions setup() et loop() sont donnés par convention.

setup() est une fonction qui se déroule une seule et unique fois au lancement du programme.
Elle sert généralement pour les configurations ou initialisation.

loop() est une fonction qui se déroule dans une boucle faite volontairement pour ne pas pouvoir en sortir. A peine le programme sort de loop() qu'il y re-entre.
L'IDE qui fait ce travail manque de documentation sur ce sujet.

Portée des variables :
Une variable définie en tête de programme (c’est-à-dire hors de toute fonction) à une durée de vie infinie et est accessible de n'importe quelle fonction.
Une variable définie dans une fonction est créée à l'entrée dans la fonction, elle n'est accessible que de la fonction où elle a été créée, elle est détruite à la sortie de la fonction (ce n'est pas toujours vrai, mais cela demande une meilleure connaissance de la programmation -> c'est pour plus tard :grinning:).

Conséquence : les variables que tu définis au début la fonction loop() seront réinitialisée à chaque entrée dans la fonction.

Il faut que tu poses la question : est-ce que c'est gênant pour ce que je veux faire ou pas ?
Faut-il les définir en début du programme ?
Je ne réponds pas à la question, je te laisse réfléchir.

Re bonjour, je tiens à vous remercier pour vos conseils, j'ai fait un autre code qui cette fois-ci fonctionne sur le papier mais une chose me chagrine, je m'explique sur mes anciens codes la LED s'allumer et s'éteins presque automatiquement après l'appui sur le bouton . Mais voilà que sur mon code actuel les LEDS s'allument et s'éteignent très lentement et je n'arrive pas à trouver de solution, j'ai essayé avec un delay(100) mais sans résultats.
Si vous pouviez m'aider je ne dirais pas non
Cordialement

Code :

// Les constantes
const int bpRouge=2;
const int bpVert=3;
const int bpJaune=4;
const int bpBleu=5;
const int bpBlanc=6;

const int ledRouge=9;
const int ledVert=10;
const int ledJaune=11;
const int ledBleu=12;
const int ledBlanc=13;

bool interrupteurRouge = false;		//
bool toggleRouge = false;	        //FAUT INITIALISER TES VARIABLES AU DEBUT
bool interrupteurVert = false;		//
bool toggleVert = false;	        //FAUT INITIALISER TES VARIABLES
bool interrupteurJaune = false;		//
bool toggleJaune = false;	        //FAUT INITIALISER TES VARIABLES
bool interrupteurBleu = false;		//
bool toggleBleu = false;	        //FAUT INITIALISER TES VARIABLES
bool interrupteurBlanc = false;		//
bool toggleBlanc = false;	        //FAUT INITIALISER TES VARIABLES


  // Variables booléénes - Etat des boutons - false/true
  bool bpRougeEtat = false;         
  bool bpVertEtat = false;            
  bool bpJauneEtat = false;          
  bool bpBleuEtat = false;            
  bool bpBlancEtat = false;  

// Définition des états
void setup()
{
  pinMode(ledRouge,OUTPUT);
  pinMode(ledVert,OUTPUT);
  pinMode(ledJaune,OUTPUT);
  pinMode(ledBleu,OUTPUT);
  pinMode(ledBlanc,OUTPUT);

  pinMode(bpRouge,INPUT);
  pinMode(bpVert,INPUT);
  pinMode(bpJaune,INPUT);
  pinMode(bpBleu,INPUT);
  pinMode(bpBlanc,INPUT);

}


void loop()
{

  // Lecture de l'état du bouton
   bpRougeEtat = digitalRead(bpRouge);          //Variables booléénes - Etat des boutons ET Lecture état bouton rouge
   bpVertEtat = digitalRead(bpVert);            //Variables booléénes - Etat des boutons ET Lecture état bouton vert
   bpJauneEtat = digitalRead(bpJaune);          //Variables booléénes - Etat des boutons ET Lecture état bouton jaune
   bpBleuEtat = digitalRead(bpBleu);            //Variables booléénes - Etat des boutons ET Lecture état bouton bleu
   bpBlancEtat = digitalRead(bpBlanc);          //Variables booléénes - Etat des boutons ET Lecture état bouton blanc
 
    /*------------------------------------ROUGE----------------------------------------------------*/
  //On regarde si le bouton rouge est pressé
  if (bpRougeEtat == true) {    
    //on regarde si il y a un changement d'état
    if (toggleRouge == true) {
      // on change l'état du bouton rouge
      interrupteurRouge=!interrupteurRouge;
      // on reinitialise le toggle
      toggleRouge=false;
      // on affiche l'état de l'interupteur virtuel sur la led rouge
      digitalWrite(ledRouge, interrupteurRouge); 
    }                
  }
  else {
    //le bouton rouge n'est pas pressé, on active le toggle
    toggleRouge=true;    
  }
    /*------------------------------------VERT----------------------------------------------------*/
    //On regarde si le bouton vert est pressé
  if (bpVertEtat == true) {    
    //on regarde si il y a un changement d'état
    if (toggleVert == true) {
      // on change l'état du bouton vert
      interrupteurVert=!interrupteurVert;
      // on reinitialise le toggle
      toggleVert=false;
      // on affiche l'état de l'interupteur virtuel sur la led vert
      digitalWrite(ledVert, interrupteurVert); 
    }                
  }
  else {
    //le bouton vert n'est pas pressé, on active le toggle
    toggleVert=true;    
  }
      /*------------------------------------JAUNE----------------------------------------------------*/
    //On regarde si le bouton jaune est pressé
  if (bpJauneEtat == true) {    
    //on regarde si il y a un changement d'état
    if (toggleJaune == true) {
      // on change l'état du bouton jaune
      interrupteurJaune=!interrupteurJaune;
      // on reinitialise le toggle
      toggleJaune=false;
      // on affiche l'état de l'interupteur virtuel sur la led jaune
      digitalWrite(ledJaune, interrupteurJaune); 
    }                
  }
  else {
    //le bouton jaune n'est pas pressé, on active le toggle
    toggleJaune=true;    
  }
      /*------------------------------------BLEU----------------------------------------------------*/
    //On regarde si le bouton bleu est pressé
  if (bpBleuEtat == true) {    
    //on regarde si il y a un changement d'état
    if (toggleBleu == true) {
      // on change l'état du bouton bleu
      interrupteurBleu=!interrupteurBleu;
      // on reinitialise le toggle
      toggleBleu=false;
      // on affiche l'état de l'interupteur virtuel sur la led bleu
      digitalWrite(ledBleu, interrupteurBleu); 
    }                
  }
  else {
    //le bouton bleu n'est pas pressé, on active le toggle
    toggleBleu=true;    
  }
      /*------------------------------------BLANC----------------------------------------------------*/
    //On regarde si le bouton blanc est pressé
  if (bpBlancEtat == true) {    
    //on regarde si il y a un changement d'état
    if (toggleBlanc == true) {
      // on change l'état du bouton blanc
      interrupteurBlanc=!interrupteurBlanc;
      // on reinitialise le toggle
      toggleBlanc=false;
      // on affiche l'état de l'interupteur virtuel sur la led blanc
      digitalWrite(ledBlanc, interrupteurBlanc); 
    }                
  }
  else {
    //le bouton blanc n'est pas pressé, on active le toggle
    toggleBlanc=true;    
  }
}

Le schéma :


Lien tinkercad : Tinkercad | From mind to design in minutes

Merci d'avance !!

Bonjour,

C'est tinkercad qui fait cet effet (pour faire joli).

Pourtant avec d'autre code toujours sur tinkercad ce n'était pas comme ça

Essaie avec simplement une led et un interrupteur en série.