problème de sécance avec un bouton poussoir

bonjour, voila j'ai besoin d'un programme qui en poussant sur le bouton allume une série de leds donc led1,led2 ensuit un delay puis led3 encore un delay et led4 . ensuit quand je repousse sur le bouton les leds doivent s'éteindre dans le sens inverse . j'ai déjà essayer plusieurs programmes et ce programme si est déjà pas loin du résultat sauf que je n'arrive pas a maitre un delay pour la sécance d'allumage des leds donc toutes les leds sont on ou off et j'ai besoin que la led 1et 2 s'allument ensemble puis un delay de ... ensuit led3 puis le delay et puis led 4 pour éteindre il faut que la led 4 s'éteint puis un delay puis donc la led3 ensuite un delay puis la led1et 2 voici le programme si vous avez des idées je suis ouvert a tout tant que ça marche ;)

// constants won't change. They're used here to // set pin numbers: const int buttonPin = 6; // the number of the pushbutton pin const int ledPin = 2; // the number of the LED pin const int ledPin2= 3; const int ledPin3= 4; const int ledPin4= 5;

// Variables will change: int ledState = LOW; // the current state of the output pin int ledState2= LOW; int ledState3= LOW; int ledState4= LOW; int buttonState; // the current reading from the input pin int lastButtonState = LOW; // the previous reading from the input pin

// the following variables are long's because the time, measured in miliseconds, // will quickly become a bigger number than can be stored in an int. long lastDebounceTime = 0; // the last time the output pin was toggled long debounceDelay = 10; // the debounce time; increase if the output flickers

void setup() { pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); pinMode(ledPin2, OUTPUT); pinMode(ledPin3, OUTPUT); pinMode(ledPin4, OUTPUT);

// set initial LED state digitalWrite(ledPin, ledState); digitalWrite(ledPin2, ledState2); digitalWrite(ledPin3, ledState3); digitalWrite(ledPin4, ledState4); }

void loop() { // read the state of the switch into a local variable: int reading = digitalRead(buttonPin);

// check to see if you just pressed the button // (i.e. the input went from LOW to HIGH), and you've waited // long enough since the last press to ignore any noise:

// If the switch changed, due to noise or pressing: if (reading != lastButtonState) { // reset the debouncing timer lastDebounceTime = millis(); }

if ((millis() - lastDebounceTime) > debounceDelay) { // whatever the reading is at, it's been there for longer // than the debounce delay, so take it as the actual current state:

// if the button state has changed: if (reading != buttonState) { buttonState = reading;

// only toggle the LED if the new button state is HIGH if (buttonState == HIGH) { ledState = !ledState; ledState2 = !ledState2; ledState3 = !ledState3; ledState4 = !ledState4; } } }

// set the LED: digitalWrite(ledPin, ledState); digitalWrite(ledPin2, ledState2); digitalWrite(ledPin3, ledState3); digitalWrite(ledPin4, ledState4);

// save the reading. Next time through the loop, // it'll be the lastButtonState: lastButtonState = reading; }

Hum, pour que l’on puisse t’aider, ce serait chouette que l’on comprenne exactement ce que tu veux faire.

Raphav:
bonjour, voila j’ai besoin d’un programme qui en poussant sur le bouton allume une série de leds donc led1,led2 ensuit un delay puis led3 encore un delay et led4 . ensuit quand je repousse sur le bouton les leds doivent s’éteindre dans le sens inverse . j’ai déjà essayer plusieurs programmes et ce programme si est déjà pas loin du résultat sauf que je n’arrive pas a maitre un delay pour la sécance d’allumage des leds
donc toutes les leds sont on ou off et j’ai besoin que la led 1et 2 s’allument ensemble puis un delay de … ensuit led3 puis le delay et puis led 4 pour éteindre il faut que la led 4 s’éteint puis un delay puis donc la led3 ensuite un delay puis la led1et 2 voici le programme si vous avez des idées je suis ouvert a tout tant que ça marche :wink:

Prochaine fois, mets ton code entre les balises ( au dessus </>), essaye de soigner un minimum tes phrases aussi. Je suis malheureusement pas un grand adepte des devinettes ou des hiéroglyphes :p.

En résumé, si j’ai bien compris, tu veux
→ Appui sur le bouton

  • allumer L1 et L2 en même temps
  • ajouter un délai de X1 mS
  • allumer L3
  • ajouter un délai de X2 mS
  • allumer L4

→ Appui une deuxième fois sur le bouton

  • éteindre L4
  • ajouter un délai de X2 mS
  • éteindre L3
  • ajouter un délai de X1 mS
  • éteindre L1 et L2

C’est quand même plus facile pour comprendre non ?

bonjour, tout d'abord merci d'avoir répondue ci rapidement . je m'excuse j'ai 16 ans et je vais à l'école en flandres c'est la première fois que je met un sujet sur un forum. merci pour le conseil j'y ferai attention la prochaine fois.

votre réponse correspond à ma demande .

Pas de soucis, je n’ai rien à dire étant donné que je ne sais aligner deux mots de néerlandais …

As tu déjà vu la fonction delay du arduino ? https://www.arduino.cc/en/Reference/Delay
Cela pourrais correspondre à tes besoins.
Sauf si tu souhaites piloter quelque chose d’autre pendant le contrôle de tes leds. Dès lors tu devras passer par la fonction millis comme tu fais.

D’ailleurs, tu ne devrais pas voir trop de soucis à implémenter un décalage sur base de ce que tu as déjà fait avec la fonction millis :wink:

Je pense que la fonction milli est mieux vue que en réalité ce sont des relais. Le problème est que je ne sais pas ou placer cette fonction dans le code j'ai déjà essayé plusieurs places mais il n'y a pas de changement quand le programme est exécuté.

Est-ce que vous avez une idée? j'aimerai continuer mon montage ce weekend si possible evidement.

Merci encore ;)

hello veux tu tester

// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 6;    // the number of the pushbutton pin
const int ledPin = 2;       // the number of the LED pin
const int ledPin2 = 3;
const int ledPin3 = 4;
const int ledPin4 = 5;
int delai1 = 1000;
int delai2 = 1000;
int delai3 = 1000;

// Variables will change:
int ledState = LOW;  // the current state of the output pin
int ledState2 = LOW;
int ledState3 = LOW;
int ledState4 = LOW;
int buttonState;             // the current reading from the input pin
int lastButtonState = LOW;   // the previous reading from the input pin

// the following variables are long's because the time, measured in miliseconds,
// will quickly become a bigger number than can be stored in an int.
long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 10;    // the debounce time; increase if the output flickers

void setup() 
{
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);

  // set initial LED state
  digitalWrite(ledPin, ledState);
  digitalWrite(ledPin2, ledState2);
  digitalWrite(ledPin3, ledState3);
  digitalWrite(ledPin4, ledState4);
}

void loop() 
{
  // read the state of the switch into a local variable:
  int reading = digitalRead(buttonPin);

  // check to see if you just pressed the button
  // (i.e. the input went from LOW to HIGH),  and you've waited
  // long enough since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:
  if (reading != lastButtonState) 
  {
    // reset the debouncing timer
    lastDebounceTime = millis();
  }

  if ((millis() - lastDebounceTime) > debounceDelay)
  {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != buttonState)
    {
      buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if (buttonState == HIGH)
      {
        ledState = !ledState;
        ledState2 = !ledState2;
        ledState3 = !ledState3;
        ledState4 = !ledState4;
      }
      if (ledState == 0)
      {
         delai1 = 0;
         delai2 = 1000;
         delai3 = 1000;
        extinction_leds(delai1, delai2, delai3);
      }
      else {
           delai1 = 0;
           delai2 = 1000;
           delai3 = 1000;
          allumage_leds(delai1, delai2, delai3);
        }
    }
      // it'll be the lastButtonState:
      lastButtonState = reading;
    }
}
    void allumage_leds( int del1,  int del2,  int del3)
    {
      digitalWrite(ledPin, ledState);
      delay(del1);
      digitalWrite(ledPin2, ledState2);
      delay(del2);
      digitalWrite(ledPin3, ledState3);
      delay(del3);
      digitalWrite(ledPin4, ledState4);
    }
    void extinction_leds(int del1, int del2, int del3)
    {
      digitalWrite(ledPin4, ledState4);
      delay(del1);
      digitalWrite(ledPin3, ledState3);
      delay(del2);
      digitalWrite(ledPin2, ledState2);
      delay(del3);
      digitalWrite(ledPin, ledState);
    }

merci pour le programme mais il ne marche pas j'ai aucune led qui s'allume mais merci encore ;)

hello, ton prg ne tournait pas j'avais juste revu les tempos voici une version qui tourne. pour tester, j'ai utilisé le shield lcd et l'entrée analogique A0 et le BP "gauche" j'ai noté les lignes que tu dois re-modifier pour que ca tourne chez toi

// set pin numbers:
const int buttonPin = A0;    // *********************************
//const int buttonPin = 6;    // **********************************
const int ledPin = 2;       
const int ledPin2 = 3;
//const int ledPin3 = 4;// **********************************
//const int ledPin4 = 5;// **********************************
const int ledPin3 = 10;// **********************************
const int ledPin4 = 11;// **********************************
int delai1 = 1000;
int delai2 = 1000;
int delai3 = 1000;

// Variables will change:
int ledState = LOW;  // the current state of the output pin
int ledState2 = LOW;
int ledState3 = LOW;
int ledState4 = LOW;
boolean buttonState = true;           // the current reading from the input pin
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 100;    // **********************************

void setup()
{
  Serial.begin(57600);
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);

  // set initial LED state
  digitalWrite(ledPin, ledState);
  digitalWrite(ledPin2, ledState2);
  digitalWrite(ledPin3, ledState3);
  digitalWrite(ledPin4, ledState4);
}

void loop()
{
  //int reading = digitalRead(buttonPin);
  int reading = analogRead(buttonPin);//**********************************************
  if (reading > 1000) {reading = 1;} else {reading = 0;}//****************************


  if (reading == 0) //si reading==0, alors il y a eu appui
  {
    lastDebounceTime = millis(); //on memorise le temps au début de l'appui
    while ((millis() - lastDebounceTime) > debounceDelay){} //on attend 100ms
    {
      buttonState = !buttonState;
      if (buttonState == 1)
      {
        Serial.print(" si buttonState = 1 "); Serial.println(buttonState);
        ledState = !ledState;
        ledState2 = !ledState2;
        ledState3 = !ledState3;
        ledState4 = !ledState4;
        delai1 = 0;
        delai2 = 1000;
        delai3 = 1000;
        allumage_leds(delai1, delai2, delai3);
      }
      if (buttonState == 0)
      {
        Serial.print(" si ledState == 0 "); Serial.println(ledState);
        ledState = !ledState;
        ledState2 = !ledState2;
        ledState3 = !ledState3;
        ledState4 = !ledState4;
        delai1 = 0;
        delai2 = 1000;
        delai3 = 1000;
        extinction_leds(delai1, delai2, delai3);
      }
    }
  }
}
void allumage_leds( int del1,  int del2,  int del3)
{
  Serial.println(" __________________________________allumage des leds ");
  digitalWrite(ledPin, ledState);
  delay(del1);
  digitalWrite(ledPin2, ledState2);
  delay(del2);
  digitalWrite(ledPin3, ledState3);
  delay(del3);
  digitalWrite(ledPin4, ledState4);
}
void extinction_leds(int del1, int del2, int del3)
{
  Serial.println("************************************* extinction des leds ");
  digitalWrite(ledPin4, ledState4);
  delay(del1);
  digitalWrite(ledPin3, ledState3);
  delay(del2);
  digitalWrite(ledPin2, ledState2);
  delay(del3);
  digitalWrite(ledPin, ledState);
}

merci pour le code mais les leds s'allument et s'éteignent sans que je dois appuyer sur le bouton ... je comprend pas comment changer les lignes j'ai essayer plusieurs choses mais rien ne change .. le code est bon juste que si je pousse sur le bouton ou que je pousse pas les leds s'allument et s'éteignent toute seule ...

tu as bien remis en place les lignes qui sont repérées comme devant l'etre ?

je confirme que la version que je t'ai passée fonctionne chez moi tests faits avec le shield lcd et ses BP, et visu des textes par serial sur le moniteur.

voici une version avec ton parametrage, j'espere ne pas en avoir oublié

// set pin numbers:
//const int buttonPin = A0;    // *********************************
const int buttonPin = 6;    // **********************************
const int ledPin = 2;       
const int ledPin2 = 3;
const int ledPin3 = 4;// **********************************
const int ledPin4 = 5;// **********************************
//const int ledPin3 = 10;// **********************************
//const int ledPin4 = 11;// **********************************
int delai1 = 1000;
int delai2 = 1000;
int delai3 = 1000;

// Variables will change:
int ledState = LOW;  // the current state of the output pin
int ledState2 = LOW;
int ledState3 = LOW;
int ledState4 = LOW;
boolean buttonState = true;           // the current reading from the input pin
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 100;    // **********************************

void setup()
{
  Serial.begin(57600);
  pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);

  // set initial LED state
  digitalWrite(ledPin, ledState);
  digitalWrite(ledPin2, ledState2);
  digitalWrite(ledPin3, ledState3);
  digitalWrite(ledPin4, ledState4);
}

void loop()
{
  int reading = digitalRead(buttonPin);
  //int reading = analogRead(buttonPin);//**********************************************
  //if (reading > 1000) {reading = 1;} else {reading = 0;}//****************************


  if (reading == 0) //si reading==0, alors il y a eu appui
  {
    lastDebounceTime = millis(); //on memorise le temps au début de l'appui
    while ((millis() - lastDebounceTime) > debounceDelay){} //on attend 100ms
    {
      buttonState = !buttonState;
      if (buttonState == 1)
      {
        Serial.print(" si buttonState = 1 "); Serial.println(buttonState);
        ledState = !ledState;
        ledState2 = !ledState2;
        ledState3 = !ledState3;
        ledState4 = !ledState4;
        delai1 = 0;
        delai2 = 1000;
        delai3 = 1000;
        allumage_leds(delai1, delai2, delai3);
      }
      if (buttonState == 0)
      {
        Serial.print(" si ledState == 0 "); Serial.println(ledState);
        ledState = !ledState;
        ledState2 = !ledState2;
        ledState3 = !ledState3;
        ledState4 = !ledState4;
        delai1 = 0;
        delai2 = 1000;
        delai3 = 1000;
        extinction_leds(delai1, delai2, delai3);
      }
    }
  }
}
void allumage_leds( int del1,  int del2,  int del3)
{
  Serial.println(" __________________________________allumage des leds ");
  digitalWrite(ledPin, ledState);
  delay(del1);
  digitalWrite(ledPin2, ledState2);
  delay(del2);
  digitalWrite(ledPin3, ledState3);
  delay(del3);
  digitalWrite(ledPin4, ledState4);
}
void extinction_leds(int del1, int del2, int del3)
{
  Serial.println("************************************* extinction des leds ");
  digitalWrite(ledPin4, ledState4);
  delay(del1);
  digitalWrite(ledPin3, ledState3);
  delay(del2);
  digitalWrite(ledPin2, ledState2);
  delay(del3);
  digitalWrite(ledPin, ledState);
}

Raphav: le code est bon juste que si je pousse sur le bouton ou que je pousse pas les leds s'allument et s'éteignent toute seule ...

Ton bouton est câblé entre l'entrée et le 5V (dans ce cas il faut une résistance de pull down) ou entre l'entrée et la masse (dans ce cas il faut un pull up externe ou interne et inverser le signal)?

ton BP: sur appui doit établir un contact entre la pinoche 6 et la masse une résistance de pull-up doit être entre le 5 V et la pinoche 6.

si tu ne veux pas mettre de résistance de pull up en externe, tu peux, dans le set up utiliser l'instruction:

pinMode(6, INPUT_PULLUP);

qui le fera en interne

j’ai fait mais pin 6 c’est le bouton et j’ai un message d’erreur sur le pc comme quoi il ne connait pas cette pin …

et avec un autre code ça ne marcherait pas mieux ? parce-que j'ai tout regarder et tout verrifier mais les leds continuent tousjours de s'allumer et s'eiteindre en boucle ...

[u]ce code fonctionne correctement chez moi[/u]

voici la même version avec la modif faite pour pull up

si tu pars en boucle, c'est que tu lis que le BP est appuyé ton BP est relié à la masse et il établit un contact à la fermeture entre la pin 6 et la masse

// set pin numbers:
//const int buttonPin = A0;    // *********************************
const int buttonPin = 6;    // **********************************
const int ledPin = 2;       
const int ledPin2 = 3;
const int ledPin3 = 4;// **********************************
const int ledPin4 = 5;// **********************************
//const int ledPin3 = 10;// **********************************
//const int ledPin4 = 11;// **********************************
int delai1 = 1000;
int delai2 = 1000;
int delai3 = 1000;

// Variables will change:
int ledState = LOW;  // the current state of the output pin
int ledState2 = LOW;
int ledState3 = LOW;
int ledState4 = LOW;
boolean buttonState = true;           // the current reading from the input pin
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 100;    // **********************************

void setup()
{
  Serial.begin(57600);
  pinMode(buttonPin, INPUT_PULLUP);
  //pinMode(buttonPin, INPUT);
  pinMode(ledPin, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);

  // set initial LED state
  digitalWrite(ledPin, ledState);
  digitalWrite(ledPin2, ledState2);
  digitalWrite(ledPin3, ledState3);
  digitalWrite(ledPin4, ledState4);
}

void loop()
{
  int reading = digitalRead(buttonPin);
  //int reading = analogRead(buttonPin);//**********************************************
  //if (reading > 1000) {reading = 1;} else {reading = 0;}//****************************


  if (reading == 0) //si reading==0, alors il y a eu appui
  {
    lastDebounceTime = millis(); //on memorise le temps au début de l'appui
    while ((millis() - lastDebounceTime) > debounceDelay){} //on attend 100ms
    {
      buttonState = !buttonState;
      if (buttonState == 1)
      {
        Serial.print(" si buttonState = 1 "); Serial.println(buttonState);
        ledState = !ledState;
        ledState2 = !ledState2;
        ledState3 = !ledState3;
        ledState4 = !ledState4;
        delai1 = 0;
        delai2 = 1000;
        delai3 = 1000;
        allumage_leds(delai1, delai2, delai3);
      }
      if (buttonState == 0)
      {
        Serial.print(" si ledState == 0 "); Serial.println(ledState);
        ledState = !ledState;
        ledState2 = !ledState2;
        ledState3 = !ledState3;
        ledState4 = !ledState4;
        delai1 = 0;
        delai2 = 1000;
        delai3 = 1000;
        extinction_leds(delai1, delai2, delai3);
      }
    }
  }
}
void allumage_leds( int del1,  int del2,  int del3)
{
  Serial.println(" __________________________________allumage des leds ");
  digitalWrite(ledPin, ledState);
  delay(del1);
  digitalWrite(ledPin2, ledState2);
  delay(del2);
  digitalWrite(ledPin3, ledState3);
  delay(del3);
  digitalWrite(ledPin4, ledState4);
}
void extinction_leds(int del1, int del2, int del3)
{
  Serial.println("************************************* extinction des leds ");
  digitalWrite(ledPin4, ledState4);
  delay(del1);
  digitalWrite(ledPin3, ledState3);
  delay(del2);
  digitalWrite(ledPin2, ledState2);
  delay(del3);
  digitalWrite(ledPin, ledState);
}

et donc je dois changer les ***** et mettre mes phrases de mon arduino alors ?

oui, bien sur qu'un autre code pourrait fonctionner. il y a de nombreuses façon de coder. Mais tel qu'il est là, le code est bon et tu n'as rien a y modifier.

fonctionnement du prg: le code lit l'entrée du bouton et [u]si[/u] le bouton est appuyé, il regarde s'il doit allumer ou éteindre les leds.

iSi le programme allume et éteint les leds de façon répétitive, c'est parce que le programme lit que tu appui sur le Bp.

fonctionnement du BP: l'entrée étant en pull up, elle est toujours à HIGH, sauf lorsque tu appuies sur le BP, alors là l'entrée passe LOW .

pour avoir un fonctionnement correct, le BP doit être entre GND et l'entrée 6.

et le BP doit être à contact "ouvert au repos", c'est à dire que sur un appui, il établi un contact.

donc lorsque tu appuies , le BP devient un fil qui amène le O Volt ( GND) directement à la l'entrée 6.

voici le code débarrassé des commentaires qui te signalaient ou j'avais du modifier les paramètres pour pouvoir tester le bon fonctionnement du code chez moi

// set pin numbers:
const int buttonPin = 6;    
const int ledPin = 2;       
const int ledPin2 = 3;
const int ledPin3 = 4;
const int ledPin4 = 5;
int delai1 = 1000;
int delai2 = 1000;
int delai3 = 1000;

// Variables will change:
int ledState = LOW;  // the current state of the output pin
int ledState2 = LOW;
int ledState3 = LOW;
int ledState4 = LOW;
boolean buttonState = true;           // the current reading from the input pin
unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
long debounceDelay = 100;    

void setup()
{
  Serial.begin(57600);
  pinMode(buttonPin, INPUT_PULLUP);
  pinMode(ledPin, OUTPUT);
  pinMode(ledPin2, OUTPUT);
  pinMode(ledPin3, OUTPUT);
  pinMode(ledPin4, OUTPUT);

  // set initial LED state
  digitalWrite(ledPin, ledState);
  digitalWrite(ledPin2, ledState2);
  digitalWrite(ledPin3, ledState3);
  digitalWrite(ledPin4, ledState4);
}

void loop()
{
  int reading = digitalRead(buttonPin);

  if (reading == 0) //si reading==0, alors il y a eu appui
  {
    lastDebounceTime = millis(); //on memorise le temps au début de l'appui
    while ((millis() - lastDebounceTime) > debounceDelay){} //on attend 100ms
    {
      buttonState = !buttonState;
      if (buttonState == 1)
      {
        Serial.print(" si buttonState = 1 "); Serial.println(buttonState);
        ledState = !ledState;
        ledState2 = !ledState2;
        ledState3 = !ledState3;
        ledState4 = !ledState4;
        delai1 = 0;
        delai2 = 1000;
        delai3 = 1000;
        allumage_leds(delai1, delai2, delai3);
      }
      if (buttonState == 0)
      {
        Serial.print(" si ledState == 0 "); Serial.println(ledState);
        ledState = !ledState;
        ledState2 = !ledState2;
        ledState3 = !ledState3;
        ledState4 = !ledState4;
        delai1 = 0;
        delai2 = 1000;
        delai3 = 1000;
        extinction_leds(delai1, delai2, delai3);
      }
    }
  }
}
void allumage_leds( int del1,  int del2,  int del3)
{
  Serial.println(" __________________________________allumage des leds ");
  digitalWrite(ledPin, ledState);
  delay(del1);
  digitalWrite(ledPin2, ledState2);
  delay(del2);
  digitalWrite(ledPin3, ledState3);
  delay(del3);
  digitalWrite(ledPin4, ledState4);
}
void extinction_leds(int del1, int del2, int del3)
{
  Serial.println("************************************* extinction des leds ");
  digitalWrite(ledPin4, ledState4);
  delay(del1);
  digitalWrite(ledPin3, ledState3);
  delay(del2);
  digitalWrite(ledPin2, ledState2);
  delay(del3);
  digitalWrite(ledPin, ledState);
}

bonjour, le code que vous m'avez donné marche parfaitement . je vous remercie mille fois pour le temps passé dessus et les explications très claires .

j'espère que vous pourrez aider d'autres personnes comme vous m'avez aidé.

à très bientôt .