problème code Kit émetteur-récepteur 433MHZ

Bonjour,
J’ai un petit problème de code :
J’utilise un émetteur et récepteur 433MHz.
Lorsque j’appuie sur le bouton pour faire clignoter les dels, les dels clignotent une fois mais ils s’arrêtent après. Pourtant j’ai relâché le bouton donc la condition if (strcmp((char*) message, CMD_BUTTON_B) == 0  && e == 1) ne devrait plus se faire

Pourquoi le while ne tourne pas ?
Voici le code

/**
   Exemple de code pour la bibliothèque VirtualWire – Télécommande DIY (récepteur)
*/

#include <VirtualWire.h>
#include "pitches.h"
/** Broches pour les LEDs */
const byte PIN_LED_A = 2;
const byte PIN_LED_B = 3;
const byte PIN_LED_C = 5;
const byte PIN_LED_D = 4;

/** Différents messages de commande */
const char* CMD_BUTTON_A = "BPA";
const char* CMD_BUTTON_B = "BPB";
const char* CMD_BUTTON_C = "CCC";
const char* CMD_BUTTON_D = "DDD";
int i = 0;
int e = 0;

int melody[] = {
  NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_C6
};




void setup() {
  Serial.begin(9600);

  /* Met les broches des LEDs en sortie et à LOW */
  pinMode(PIN_LED_A, OUTPUT);
  digitalWrite(PIN_LED_A, LOW);
  pinMode(PIN_LED_B, OUTPUT);
  digitalWrite(PIN_LED_B, LOW);
  pinMode(PIN_LED_C, OUTPUT);
  digitalWrite(PIN_LED_C, LOW);
  pinMode(PIN_LED_D, OUTPUT);
  digitalWrite(PIN_LED_D, LOW);
  // Initialisation de la bibliothèque VirtualWire
  // Vous pouvez changez les broches RX/TX/PTT avant vw_setup() si nécessaire
  vw_setup(2000);
  vw_rx_start(); // On peut maintenant recevoir des messages

  Serial.println("Go !");
}

void loop() {
  byte message[VW_MAX_MESSAGE_LEN];
  byte taille_message = VW_MAX_MESSAGE_LEN;
  // N.B. La constante VW_MAX_MESSAGE_LEN est fournie par la lib VirtualWire

  /*
    La variable "taille_message" doit impérativement être remise à
    la taille du buffer avant de pouvoir recevoir un message.
    Le plus simple est d'utiliser une variable locale pour ne pas
    avoir à réassigner la valeur à chaque début de loop().
  */

  // On attend de recevoir un message
  vw_wait_rx();
  Serial.println("teqs !");


  if (vw_get_message(message, &taille_message)) {
    // On copie le message, qu'il soit corrompu ou non

    if (strcmp((char*) message, CMD_BUTTON_A) == 0) {


      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_G5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_D5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(400);
      tone(PIN_LED_A, NOTE_F5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_D5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 500);
      delay(400);
    }

  }

//////////faire clignoter dels///////////////////////////////////////////////////

  if (strcmp((char*) message, CMD_BUTTON_B) == 0 && e == 0)
  {
    e = 1;
    delay(200);
    while (e = 1) //tant que (clignotement de la led jusqu'au prochain appui sur le btn)
    {
      digitalWrite(PIN_LED_B, HIGH);
      delay(1000);
      digitalWrite(PIN_LED_B, LOW);
      delay(1000);
      if (strcmp((char*) message, CMD_BUTTON_B) == 0  && e == 1) //si appui sur le btn
      {
        delay(200);
        digitalWrite(PIN_LED_B, LOW); // led éteinte
        e = 0;
        Serial.println(e);
        delay(2000);
        break; //interruption
      }
    }
  }


////////////////////////////////////////////////////////////////////

  if (strcmp((char*) message, CMD_BUTTON_C) == 0) {
    digitalWrite(PIN_LED_C, !digitalRead(PIN_LED_C));
    Serial.println("TOGGLE LED C");

  }

  else if (strcmp((char*) message, CMD_BUTTON_D) == 0) {
    digitalWrite(PIN_LED_D, !digitalRead(PIN_LED_D));
    Serial.println("TOGGLE LED D");
  }
}

Merci d’avance
Bonne journée

regardez où se ferme l'accolade du

  if (vw_get_message(message, &taille_message)) {

Merci,
j’ai rectifié mais cela ne change rien, il ne clignote qu’une fois

/**
   Exemple de code pour la bibliothèque VirtualWire – Télécommande DIY (récepteur)
*/

#include <VirtualWire.h>
#include "pitches.h"
/** Broches pour les LEDs */
const byte PIN_LED_A = 2;
const byte PIN_LED_B = 3;
const byte PIN_LED_C = 5;
const byte PIN_LED_D = 4;

/** Différents messages de commande */
const char* CMD_BUTTON_A = "BPA";
const char* CMD_BUTTON_B = "BPB";
const char* CMD_BUTTON_C = "CCC";
const char* CMD_BUTTON_D = "DDD";
int i = 0;
int e = 0;

int melody[] = {
  NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_C6
};




void setup() {
  Serial.begin(9600);

  /* Met les broches des LEDs en sortie et à LOW */
  pinMode(PIN_LED_A, OUTPUT);
  digitalWrite(PIN_LED_A, LOW);
  pinMode(PIN_LED_B, OUTPUT);
  digitalWrite(PIN_LED_B, LOW);
  pinMode(PIN_LED_C, OUTPUT);
  digitalWrite(PIN_LED_C, LOW);
  pinMode(PIN_LED_D, OUTPUT);
  digitalWrite(PIN_LED_D, LOW);
  // Initialisation de la bibliothèque VirtualWire
  // Vous pouvez changez les broches RX/TX/PTT avant vw_setup() si nécessaire
  vw_setup(2000);
  vw_rx_start(); // On peut maintenant recevoir des messages

  Serial.println("Go !");
}

void loop() {
  byte message[VW_MAX_MESSAGE_LEN];
  byte taille_message = VW_MAX_MESSAGE_LEN;
  // N.B. La constante VW_MAX_MESSAGE_LEN est fournie par la lib VirtualWire

  /*
    La variable "taille_message" doit impérativement être remise à
    la taille du buffer avant de pouvoir recevoir un message.
    Le plus simple est d'utiliser une variable locale pour ne pas
    avoir à réassigner la valeur à chaque début de loop().
  */

  // On attend de recevoir un message
  vw_wait_rx();
  Serial.println("teqs !");


  if (vw_get_message(message, &taille_message)) {
    // On copie le message, qu'il soit corrompu ou non

    if (strcmp((char*) message, CMD_BUTTON_A) == 0) {


      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_G5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_D5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(400);
      tone(PIN_LED_A, NOTE_F5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_D5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 500);
      delay(400);
    }

  

//////////faire clignoter dels///////////////////////////////////////////////////

  if (strcmp((char*) message, CMD_BUTTON_B) == 0 && e == 0)
  {
    e = 1;
    delay(200);
    while (e = 1) //tant que (clignotement de la led jusqu'au prochain appui sur le btn)
    {
      digitalWrite(PIN_LED_B, HIGH);
      delay(1000);
      digitalWrite(PIN_LED_B, LOW);
      delay(1000);
      if (strcmp((char*) message, CMD_BUTTON_B) == 0  && e == 1) //si appui sur le btn
      {
        delay(200);
        digitalWrite(PIN_LED_B, LOW); // led éteinte
        e = 0;
        Serial.println(e);
        delay(2000);
        break; //interruption
      }
    }
  }


////////////////////////////////////////////////////////////////////

  if (strcmp((char*) message, CMD_BUTTON_C) == 0) {
    digitalWrite(PIN_LED_C, !digitalRead(PIN_LED_C));
    Serial.println("TOGGLE LED C");

  }

  else if (strcmp((char*) message, CMD_BUTTON_D) == 0) {
    digitalWrite(PIN_LED_D, !digitalRead(PIN_LED_D));
    Serial.println("TOGGLE LED D");
  }
}}

Sauriez-vous pourquoi ?

Postez les 2 codes

Mais une fois les message reçu et traité pourquoi ça clignoterait ?

 // On attend de recevoir un message
  vw_wait_rx();

J’aimerai que lorsque j’appuis une fois sur le bouton le while s’exécute, c’est à dire que les leds clignotent puis lorsque je rappuie sur bouton pour la deuxième fois elle cessent clignoter.

Je ne sais pas si j’ai été assez clair,
merci pour votre aide

ci joint le code pour l’émetteur :

/**
   Exemple de code pour la bibliothèque VirtualWire – Télécommande DIY (émetteur)
*/

#include <VirtualWire.h>

/** Broches pour les boutons */
const byte PIN_BUTTON_A = 2;
const byte PIN_BUTTON_B = 3;
const byte PIN_BUTTON_C = 6;
const byte PIN_BUTTON_D = 7;

/** Différents messages de commande */
const char* CMD_BUTTON_A = "BPA";
const char* CMD_BUTTON_B = "BPB";
const char* CMD_BUTTON_C = "CCC";
const char* CMD_BUTTON_D = "DDD";

void setup() {
  Serial.begin(9600);

  /* Met les broches des boutons en entrées avec pull-up */
  pinMode(PIN_BUTTON_A, INPUT_PULLUP);
  pinMode(PIN_BUTTON_B, INPUT_PULLUP);
  pinMode(PIN_BUTTON_C, INPUT_PULLUP);
  pinMode(PIN_BUTTON_D, INPUT_PULLUP);

  // Initialisation de la bibliothèque VirtualWire
  // Vous pouvez changez les broches RX/TX/PTT avant vw_setup() si nécessaire
  vw_setup(2000);

  Serial.println("Go !");
}

void loop() {
  byte message[VW_MAX_MESSAGE_LEN];
  // N.B. La constante VW_MAX_MESSAGE_LEN est fournie par la lib VirtualWire

  /* Envoi la commande adéquate */
  if (digitalRead(PIN_BUTTON_A) == LOW ) {

    vw_send((byte*) CMD_BUTTON_A, strlen(CMD_BUTTON_A) + 1); // On envoie le message
    vw_wait_tx(); // On attend la fin de l'envoi

    delay(50); // Attend que le bouton soit relâché
    while (digitalRead(PIN_BUTTON_A) == LOW);
    delay(50);
  }

  if (digitalRead(PIN_BUTTON_B) == LOW ) {

    vw_send((byte*) CMD_BUTTON_B, strlen(CMD_BUTTON_B) + 1); // On envoie le message
    vw_wait_tx(); // On attend la fin de l'envoi

    delay(50); // Attend que le bouton soit relâché
    while (digitalRead(PIN_BUTTON_B) == LOW);
    delay(50);

  }

  if (digitalRead(PIN_BUTTON_C) == LOW ) {

    vw_send((byte*) CMD_BUTTON_C, strlen(CMD_BUTTON_C) + 1); // On envoie le message
    vw_wait_tx(); // On attend la fin de l'envoi

    delay(50); // Attend que le bouton soit relâché
    while (digitalRead(PIN_BUTTON_C) == LOW);
    delay(50);

  }

  else if (digitalRead(PIN_BUTTON_D) == LOW) {

    vw_send((byte*) CMD_BUTTON_D, strlen(CMD_BUTTON_D) + 1); // On envoie le message
    vw_wait_tx(); // On attend la fin de l'envoi

    delay(50); // Attend que le bouton soit relâché
    while (digitalRead(PIN_BUTTON_D) == LOW);
    delay(50);
  }
}

il faut enregistrer dans une variable d'état si vous êtes en mode clignotement ou pas et ensuite utiliser la technique de blink-without-delay pour ne pas bloquer la loop() et revenir tester souvent si vous avez reçu un message

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

Merci ! je vais regarder cela

j’ai utilisé cette fois ci un millis
J’arrive à éteindre et a allumer les dels mais elles ne clignotent pas

/**
   Exemple de code pour la bibliothèque VirtualWire – Télécommande DIY (récepteur)
*/

#include <VirtualWire.h>
#include "pitches.h"
/** Broches pour les LEDs */
const byte PIN_LED_A = 2;
const byte PIN_LED_B = 3;
const byte PIN_LED_C = 5;
const byte PIN_LED_D = 4;

/** Différents messages de commande */
const char* CMD_BUTTON_A = "BPA";
const char* CMD_BUTTON_B = "BPB";
const char* CMD_BUTTON_C = "CCC";
const char* CMD_BUTTON_D = "DDD";
int i = 0;
int e = 0;


int melody[] = {
  NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_C6
};


unsigned long previousMillis = 0;
int ledState = LOW;

void setup() {
  Serial.begin(9600);

  /* Met les broches des LEDs en sortie et à LOW */
  pinMode(PIN_LED_A, OUTPUT);
  digitalWrite(PIN_LED_A, LOW);
  pinMode(PIN_LED_B, OUTPUT);
  digitalWrite(PIN_LED_B, LOW);
  pinMode(PIN_LED_C, OUTPUT);
  digitalWrite(PIN_LED_C, LOW);
  pinMode(PIN_LED_D, OUTPUT);
  digitalWrite(PIN_LED_D, LOW);
  // Initialisation de la bibliothèque VirtualWire
  // Vous pouvez changez les broches RX/TX/PTT avant vw_setup() si nécessaire
  vw_setup(2000);
  vw_rx_start(); // On peut maintenant recevoir des messages

  Serial.println("Go !");
}

void loop() {






  byte message[VW_MAX_MESSAGE_LEN];
  byte taille_message = VW_MAX_MESSAGE_LEN;
  // N.B. La constante VW_MAX_MESSAGE_LEN est fournie par la lib VirtualWire

  /*
    La variable "taille_message" doit impérativement être remise à
    la taille du buffer avant de pouvoir recevoir un message.
    Le plus simple est d'utiliser une variable locale pour ne pas
    avoir à réassigner la valeur à chaque début de loop().
  */

  // On attend de recevoir un message
  vw_wait_rx();
  Serial.println("teqs !");


  if (vw_get_message(message, &taille_message)) {
    // On copie le message, qu'il soit corrompu ou non

    if (strcmp((char*) message, CMD_BUTTON_A) == 0) {


      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_G5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_D5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(400);
      tone(PIN_LED_A, NOTE_F5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_D5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 500);
      delay(400);
    }



    //////////faire clignoter dels///////////////////////////////////////////////////

    if (strcmp((char*) message, CMD_BUTTON_B) == 0)
    {
      e = 1;

      while (e = 1) {

        unsigned long currentMillis = millis();
        Serial.print(currentMillis);

        if (currentMillis - previousMillis >= 1000) {
          previousMillis = currentMillis;

          if (ledState == LOW) {
            ledState = HIGH;
          } else {
            ledState = LOW;
          }
          digitalWrite(PIN_LED_B, ledState);
        }
      
      if (strcmp((char*) message, CMD_BUTTON_B) == 0) {
        e = 0;
        Serial.print("         ");
      }
      }

    }




    ////////////////////////////////////////////////////////////////////

    if (strcmp((char*) message, CMD_BUTTON_C) == 0) {
      digitalWrite(PIN_LED_C, !digitalRead(PIN_LED_C));
      Serial.println("TOGGLE LED C");

    }

    else if (strcmp((char*) message, CMD_BUTTON_D) == 0) {
      digitalWrite(PIN_LED_D, !digitalRead(PIN_LED_D));
      Serial.println("TOGGLE LED D");
    }
  }
}

la structure de votre programme n’est pas bonne car vous bloquer la loop() en attendant un message. La structure devrait ressembler à cela (tapé ici donc je ne sais pas si ça compile, mais c’est pour l’idée):

#include <VirtualWire.h>

unsigned long chrono;
const unsigned long demiPeriode = 500ul;

enum : byte {REPOS, CLIGNOTE} etat;

void setup() {
  vw_setup(2000);
  vw_rx_start(); // On peut maintenant recevoir des messages
  chrono = millis();
  etat = REPOS;
}

void loop() {
  byte message[VW_MAX_MESSAGE_LEN];
  byte taille_message = VW_MAX_MESSAGE_LEN;

  if (vw_have_message()) { // IL NE FAUT PAS BLOQUER LA loop()
    if (vw_get_message(message, &taille_message)) {

      // >>>>>>>>> GERER LE MESSAGE ET CHANGER etat <<<<<<<<<<<<
      // >>>>>>>>>  et effectuer un chrono = millis(); si on est en etat == CLIGNOTE <<<<<<<<<<<<
    }
  }

  if (etat == CLIGNOTE) {
    if (millis - chrono >= demiPeriode) {

      // >>>>>>>>> FAIRE CLIGNOTER <<<<<<<<<<<<

      chrono +=  demiPeriode;
    }
  }
}

Merci pour votre patience
On y est presque :wink:
voila ce que j’ai fait mais la led ne clignote plus pourtant on est dans la partie clignote, donc le problème doit venir de millis

/**
   Exemple de code pour la bibliothèque VirtualWire – Télécommande DIY (récepteur)
*/

#include <VirtualWire.h>
#include "pitches.h"
/** Broches pour les LEDs */
const byte PIN_LED_A = 2;
const byte PIN_LED_B = 3;
const byte PIN_LED_C = 5;
const byte PIN_LED_D = 4;

/** Différents messages de commande */
const char* CMD_BUTTON_A = "BPA";
const char* CMD_BUTTON_B = "BPB";
const char* CMD_BUTTON_C = "CCC";
const char* CMD_BUTTON_D = "DDD";
int i = 0;



int melody[] = {
  NOTE_C5, NOTE_D5, NOTE_E5, NOTE_F5, NOTE_G5, NOTE_A5, NOTE_B5, NOTE_C6
};

int ledState = LOW;

unsigned long previousMillis = 0;

enum : byte {REPOS, CLIGNOTE} etat;


unsigned long chrono;
const unsigned long demiPeriode = 500ul;


void setup() {
  Serial.begin(9600);

  /* Met les broches des LEDs en sortie et à LOW */
  pinMode(PIN_LED_A, OUTPUT);
  digitalWrite(PIN_LED_A, LOW);
  pinMode(PIN_LED_B, OUTPUT);
  digitalWrite(PIN_LED_B, LOW);
  pinMode(PIN_LED_C, OUTPUT);
  digitalWrite(PIN_LED_C, LOW);
  pinMode(PIN_LED_D, OUTPUT);
  digitalWrite(PIN_LED_D, LOW);
  // Initialisation de la bibliothèque VirtualWire
  // Vous pouvez changez les broches RX/TX/PTT avant vw_setup() si nécessaire

  vw_setup(2000);
  vw_rx_start(); // On peut maintenant recevoir des messages
  chrono = millis();
  etat = REPOS;


  Serial.println("Go !");
}

void loop() {



  byte message[VW_MAX_MESSAGE_LEN];
  byte taille_message = VW_MAX_MESSAGE_LEN;
  // N.B. La constante VW_MAX_MESSAGE_LEN est fournie par la lib VirtualWire


  // On attend de recevoir un message
  vw_wait_rx();
  Serial.println("teqs !");


  if (vw_get_message(message, &taille_message)) {
    // On copie le message, qu'il soit corrompu ou non

    if (strcmp((char*) message, CMD_BUTTON_A) == 0) {


      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_G5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_D5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(400);
      tone(PIN_LED_A, NOTE_F5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_D5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 500);
      delay(400);
    }



    ////////////////////////////////////////////////////////////////////

    if (strcmp((char*) message, CMD_BUTTON_C) == 0) {
      digitalWrite(PIN_LED_C, !digitalRead(PIN_LED_C));
      Serial.println("TOGGLE LED C");

    }

    else if (strcmp((char*) message, CMD_BUTTON_D) == 0) {
      digitalWrite(PIN_LED_D, !digitalRead(PIN_LED_D));
      Serial.println("TOGGLE LED D");
    }


    if (strcmp((char*) message, CMD_BUTTON_B) == 0)
    {
      Serial.println("TOGGLE LED B");
      if (etat == CLIGNOTE) {
        etat = REPOS;
        Serial.println("clignote =REPOS");
      }
      else {
        etat = CLIGNOTE;
        Serial.println("clignote");
      }
    }


  }///recevoir message


  if (etat == CLIGNOTE) {

  unsigned long currentMillis = millis();
    Serial.println("...");
    if ( millis - chrono >= demiPeriode) {

      chrono =  demiPeriode;
          
      // >>>>>>>>> FAIRE CLIGNOTER <<<<<<<<<<<<
      if (ledState == LOW) {
        ledState = HIGH;
      } else {
        ledState = LOW;
      }
      digitalWrite(PIN_LED_B, ledState);


    }
  }



}///loop

qu'est-ce que je vous ai dit sur ce bout de code?

 // On attend de recevoir un message
  vw_wait_rx();
  Serial.println("teqs !");

Vous avez regardé la structure de code que je vous ai proposée?

et cette partie

      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_G5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_F5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_D5 , 650);
      delay(220);
      tone(PIN_LED_A, NOTE_E5 , 650);
      delay(400);
      tone(PIN_LED_A, NOTE_F5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_D5 , 300);
      delay(120);
      tone(PIN_LED_A, NOTE_E5 , 500);
      delay(400);

faut peut-être la traité aussi avec millis() car vous bloquez tout pendant environ 2 secondes (et je ne vois pas pourquoi vous mettez des durées et des pauses qui sont moins longues que ces durées dans tone() )

Oups, je n'avais pas vu Merci maintenant ça marche J'avais laissé tone avec des delay car cela ne me dérangé pour ce que je voulais en faire, mais bon c'est vrai que ce n'est pas très propre. Sinon pourquoi avez-vous mit chrono+=...(pourquoi +)

Sinon pourquoi avez-vous mit chrono+=...(pourquoi +)

Une fois qu'on a fait l'action il faut savoir quand on va faire la prochaine action, donc on mémorise normalement le moment présent et on peut faire chrono = millis(); L'inconvénient de cette approche c'est que si le reste du code a une durée variable et que vous passez parfois plus longtemps que la demi période dans l'exécution du reste du code, alors vous ne restez pas synchronisé sur cette demie période; en augmentant chrono de la demi période seulement (si tout va bien ça nous emmène à millis() ) ça permet de gommer cet aléa