Faire clignoter 3 LED avec 3 boutons poussoirs

Bonjour à tous,

Je suis débutant avec Arduino et je dois réaliser un projet avec une carte Arduino Uno avec un Shield. J’ai 3 LED et 3 boutons poussoirs qui sont respectivement en positions D2, D3, D4 et A0, A1, A2. J’ai réussi à faire un code qui permet de les allumer lors de la pression et l’éteindre lors d’une deuxième pression. Mais ce n’est pas suffisant, il faudrait les faire clignoter, j’ai essayer d’utiliser une IA pour avoir un code fonctionnel et cela rendait des led qui clignotaient toute seule qui bugaient.

Je voudrais avoir de l’aide svp,

Voici mon code actuel :

//Définition des pins de la LED et du bouton poussoir
int ledPinG = 4;
int ledPinM = 3;
int ledPinD = 2;
int buttonPinG = A0;
int buttonPinM = A1;
int buttonPinD = A2;


//Variable pour stocker l'état précédent du bouton poussoir
int previousStateG = LOW;
int previousStateM = LOW;
int previousStateD = LOW;

//Variable pour stocker l'état actuel du bouton poussoir
int buttonStateG = 0;
int buttonStateM = 0;
int buttonStateD = 0;

//Variable pour stocker l'état de la LED
int ledStateG = LOW;
int ledStateM = LOW;
int ledStateD = LOW;

void setup() {
  //Initialisation des pins de la LED et du bouton poussoir
  pinMode(ledPinG, OUTPUT);
  pinMode(ledPinM, OUTPUT);
  pinMode(ledPinD, OUTPUT);
  
  pinMode(buttonPinG, INPUT);
  pinMode(buttonPinM, INPUT);
  pinMode(buttonPinD, INPUT);
}

void loop() {
  // - DÉBUT BOUTON GAUCHE -
  buttonStateG = digitalRead(buttonPinG);

  if (buttonStateG == HIGH && previousStateG == LOW) {
    ledStateG = !ledStateG; //Inversion de l'état de la LED
  }

  if (ledStateG == HIGH) {
    digitalWrite(ledPinG, HIGH);
  } else {
    digitalWrite(ledPinG, LOW);
  }
  previousStateG = buttonStateG;

  // - FIN BOUTON GAUCHE - 
  // - DÉBUT BOUTON MILIEU -
  
  buttonStateM = digitalRead(buttonPinM);

  if (buttonStateM == HIGH && previousStateM == LOW) {
    ledStateM = !ledStateM; //Inversion de l'état de la LED
  }

  if (ledStateM == HIGH) {
    digitalWrite(ledPinM, HIGH);
  } else {
    digitalWrite(ledPinM, LOW);
  }
  previousStateM = buttonStateM;

  // - FIN BOUTON MILIEU - 
  // - DÉBUT BOUTON DROIT -
  buttonStateD = digitalRead(buttonPinD);

  if (buttonStateD == HIGH && previousStateD == LOW) {
    ledStateD = !ledStateD; //Inversion de l'état de la LED
  }

  if (ledStateD == HIGH) {
    digitalWrite(ledPinD, HIGH);
  } else {
    digitalWrite(ledPinD, LOW);
  }
  previousStateD = buttonStateD;
}
  // - FIN BOUTON DROIT -

Merci d’avance pour vos réponses :slight_smile:

Au lieu de demander à une IA, formez vous.

C’est typiquement une définition de programme qui se prête bien à la programmation par machine à états (cf mon tuto éventuellement)

Si tu veux faire clignoter une LED, il faut que ton programme, dise à la LED de s'éteindre et s'allumer à un intervalle régulier.

Tu sais déjà allumer une LED et l'éteindre, tu n'a pas qu'a faire en sorte d'enchainer ces deux partie à intervalle régulier.
Essaye d'ajouter cela à ton programme et dis nous ou tu bloque.

Le problème des IA, c'est qu'elle ne peut pas deviner ce que tu veux faire, il faut donc déjà savoir ce que tu veux vraiment, pour lui poser la bonne question :frowning:

ChatGPT (et autres) est très pratique pour retrouver un truc que l'on a déjà vu et que l'on a oublié... à condition d'avoir les connaissances pour :

  • cibler précisément sa demande
  • avoir une idée précise de la forme que cela doit prendre
  • corriger ses énormes erreurs

Mais c'est parfois très pratique :wink:

C’est typiquement une définition de programme qui se prête bien à la programmation par interruption avec MTobjects.
Pour faire clignoter ou pas une seule led avec un bouton par interruption, un exemple de programme est donné dans les exemples:

// Ce programme fait clignoter une led avec un bouton marche arrêt

#include "MTsoftPWM.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects
#include "MTcheckButton.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects

const uint8_t PIN_BUTTON = A0; // Bouton câblé entre GND et A0


MTsoftPWM Clignotant(LED_BUILTIN, impulsions_de 500000 micro_secondes, periodes_de 1000000 micro_secondes, on_commence_par LOW, MT_INFINI, PAS_D_ACTION, MT_OFF);


void allume(void)
{
  Clignotant.start();
}

void eteint(void)
{
  Clignotant.stop();
  digitalWrite(LED_BUILTIN, LOW); // On ne sait pas quand on l'arrête
}

MTcheckButton Bouton(A0, allume, eteint);


void setup(){}

void loop(){}

Pour faire pareil avec 3 leds et 3 boutons, il suffit d'écrire 3 fois ce code en indiçant différamment les noms des variables et des fonctions:

#include "MTsoftPWM.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects
#include "MTcheckButton.h" // V1.0.0 Voir http://arduino.dansetrad.fr/MTobjects

const byte LED_1 = 2;
const byte LED_2 = 3;
const byte LED_3 = 4;
const byte BOUTON_1 = A0;
const byte BOUTON_2 = A1;
const byte BOUTON_3 = A2;


MTsoftPWM Clignotant1(LED_1, impulsions_de 500000 micro_secondes, periodes_de 1000000 micro_secondes, on_commence_par LOW, MT_INFINI, PAS_D_ACTION, MT_OFF);
MTsoftPWM Clignotant2(LED_2, impulsions_de 500000 micro_secondes, periodes_de 1000000 micro_secondes, on_commence_par LOW, MT_INFINI, PAS_D_ACTION, MT_OFF);
MTsoftPWM Clignotant3(LED_3, impulsions_de 500000 micro_secondes, periodes_de 1000000 micro_secondes, on_commence_par LOW, MT_INFINI, PAS_D_ACTION, MT_OFF);


void allume1(void)
{
  Clignotant1.start();
}
void allume2(void)
{
  Clignotant2.start();
}
void allume3(void)
{
  Clignotant3.start();
}


void eteint1(void)
{
  Clignotant1.stop();
  digitalWrite(LED_1, LOW); // On ne sait pas quand on l'arrête
}
void eteint2(void)
{
  Clignotant2.stop();
  digitalWrite(LED_2, LOW); // On ne sait pas quand on l'arrête
}
void eteint3(void)
{
  Clignotant3.stop();
  digitalWrite(LED_3, LOW); // On ne sait pas quand on l'arrête
}


MTcheckButton Bouton1(BOUTON_1, allume1, eteint1);
MTcheckButton Bouton2(BOUTON_2, allume2, eteint2);
MTcheckButton Bouton3(BOUTON_3, allume3, eteint3);


void setup(){}

void loop(){}

Si on veut que les clignotements soient synchrones, il suffit quand on allume une des led de réinitialiser les autres si elles étaient en marche:

void allume1(void)
{
  Clignotant1.start();
  if (Clignotant2.getActive()) Clignotant2.start();
  if (Clignotant3.getActive()) Clignotant3.start();
}
void allume2(void)
{
  Clignotant2.start();
  if (Clignotant1.getActive()) Clignotant1.start();
  if (Clignotant3.getActive()) Clignotant3.start();
}
void allume3(void)
{
  Clignotant3.start();
  if (Clignotant1.getActive()) Clignotant1.start();
  if (Clignotant2.getActive()) Clignotant2.start();
}

la formule me rappelle quelque chose. :wink:

(mais c'est vrai aussi)

Pourquoi réinventer la roue?

pour apprendre :wink: