if pour les boutton

Bonjour
j’essaie de détecter l’appuie sur l'un des 5 boutons
et j'ai constater que a la fin ya que la dernière valeur qui est retenu
voici le code

  boolean etatBout1 = false;// b
  boolean etatBout2 = false;//b
  boolean etatBout3 = false;//b
  boolean etatBout4 = false;//b
  boolean etatBout5 = false;
  etatBout1 = digitalRead(boutB);// boutton Bas
  etatBout2 = digitalRead(boutD);//bouton de valeur
  etatBout3 = digitalRead(boutH);//bouton haut
  etatBout4 = digitalRead(boutG);//bouton valeur
  etatBout5 = digitalRead(boutM);

  if (etatBout1 || etatBout2 || etatBout3 || etatBout4|| etatBout5) { 

    if (etatBout1) {
      CodeCommande = 1;
      EnvoiCommande(CodeCommande);
      
    }
    
if (etatBout2) {
   CodeCommande = 2;
   EnvoiCommande(CodeCommande);
   

    }
     if (etatBout3) {
      CodeCommande = 3;
      EnvoiCommande(CodeCommande);
     

    }
     if (etatBout4) {
      CodeCommande = 4;
     EnvoiCommande(CodeCommande);

    }
  if (etatBout5) {
      CodeCommande = 5;// ya que celle la qui est renvoyer avec envoiCommande 
  EnvoiCommande(CodeCommande);

  }
  
  
  }

ca ne détecte pas l’appuie sur les autres boutons
merci pour votre aide

Ils sont câblés comment les boutons?

voila sur les ports A1,A2A3 A4 A5 de l’Arduino

const int boutB = A3; 
const int boutD = A5;
const int boutH = A1;
const int boutG = A4;
const int boutM = A2

c'est mieux de poster votre image directement

voici le code

ce n'est pas le code, c'est un bout du code..... et il est indenté n'importe comment.. c'est illisible

à quoi sert

  if (etatBout1 || etatBout2 || etatBout3 || etatBout4 || etatBout5) {

si de toutes façons ensuite vous testez chaque bouton?

à quoi sert d'initialiser les booléens

  boolean etatBout1 = false;// b
  boolean etatBout2 = false;//b
  boolean etatBout3 = false;//b
  boolean etatBout4 = false;//b
  boolean etatBout5 = false;

si la première chose que vous faites ensuite c'est les initialiser avec une autre valeur

  etatBout1 = digitalRead(boutB);// boutton Bas
  etatBout2 = digitalRead(boutD);//bouton de valeur
  etatBout3 = digitalRead(boutH);//bouton haut
  etatBout4 = digitalRead(boutG);//bouton valeur
  etatBout5 = digitalRead(boutM);

(qui en plus n'a rien à voir conceptuellment avec un booléen puisque c'est HIGH ou LOW et en plus avec un PULLUP la logique serait inversée, ce qui doit vous jouer un sale tour)

Avez vous bien pensé à déclarer les INPUT_PULLUP?

à quoi ça sert d'initialiser CodeCommande si c'est juste pour le passer en paramètre?

      CodeCommande = 1;
      EnvoiCommande(CodeCommande);

autant faire      EnvoiCommande(1);

Pourquoi les mémoriser d'ailleurs si vous ne vous en servez pas? autant écrire

    if (digitalRead(boutB)) EnvoiCommande(1); // ou ne serait-ce pas if (digitalRead(boutB) == LOW) EnvoiCommande(1); puisqu'en input pullup?
    if (digitalRead(boutD)) EnvoiCommande(2); // idem
    if (digitalRead(boutH)) EnvoiCommande(3); // idem
    if (digitalRead(boutG)) EnvoiCommande(4); // idem
    if (digitalRead(boutM)) EnvoiCommande(5); // idem

Ce serait bien de mettre le code complet pour éviter d'itérer 50 fois.

Cela dit, à la vue du schéma on est en droit de supposer que les boutons sont actif à 0.
Donc au repos, tous les boutons sont à 1 et donc toutes les variables etatBoutx sont à 1 aussi (donc vrai) et donc tous les if sont vérifiés à la suite.

Même s'ils sont équivalents, je milite fortement pour l'usage de HIGH et LOW lorsqu'on utilise digitalRead(), plutôt que true et false, au moins on sait de quel état on parle.

merci pour votre reponse
alors

 if (etatBout1 || etatBout2 || etatBout3 || etatBout4 || etatBout5) {

c'est pour vérifier si un des bouton est pressé
c'est vrai pour

 EnvoiCommande(1);

je vais tester votre code et voir si ça marche
merci

c'est pour vérifier si un des bouton est pressé

bof - ça sert à rien puisque vous testez à nouveau les boutons... un par un ensuite...

Avez vous bien pensé à déclarer les INPUT_PULLUP?

fdufnews:
Même s'ils sont équivalents, je milite fortement pour l'usage de HIGH et LOW lorsqu'on utilise digitalRead(), plutôt que true et false, au moins on sait de quel état on parle.

Moi j'ai une petite tête qui a du mal à raisonner en logique négative :smiley: . Donc je fais:
Pour les entrées actives à l'état haut:

  bool etat=digitalRead(bouton);

Pour les entrées actives à l'état bas:

  bool etat=!digitalRead(bouton);

kamill:
Moi j'ai une petite tête qui a du mal à raisonner en logique négative

ou un

#define ACTIF LOW // pour les petites têtes :)
...
if (digitalRead(bouton) == ACTIF) {...}

désolé pour le retard
voila le code complet
émetteur

#include <SPI.h>      // Pour la communication via le port SPI
#include <Mirf.h>     // Pour la gestion de la communication
#include <nRF24L01.h> // Pour les définitions des registres du nRF24L01
#include <MirfHardwareSpiDriver.h> // Pour la communication SPI
int CodeCommande = 0;
const int boutB = A3;
const int boutD = A5; 
const int boutH = A1;
const int boutG = A4;
const int boutM = A2;
typedef struct {
  int commande;
  int valeur;
} MaStructure;

void setup() {
  Serial.begin(9600);
  pinMode(boutB, INPUT_PULLUP);//navigation menu bouton BAS
  pinMode(boutD, INPUT_PULLUP);//Changement valeur
  pinMode(boutH, INPUT_PULLUP);// bouton Haut
  pinMode(boutG, INPUT_PULLUP);
  pinMode(boutM, INPUT_PULLUP);

  Mirf.cePin = 9; // Broche CE sur D9
  Mirf.csnPin = 10; // Broche CSN sur D10
  Mirf.spi = &MirfHardwareSpi; // On veut utiliser le port SPI hardware
  Mirf.init(); // Initialise la bibliothèque

  Mirf.channel = 116; // Choix du canal de communication (128 canaux disponibles, de 0 à 127)
  Mirf.payload = sizeof(MaStructure); // Taille d'un message (maximum 32 octets)
  Mirf.config(); // Sauvegarde la configuration dans le module radio

  Mirf.setTADDR((byte *) "nrf02"); // Adresse de transmission
  Mirf.setRADDR((byte *) "nrf01"); // Adresse de réception

  Serial.println("Go !");
}
void EnvoiCommande(int TypeCommande) {
  MaStructure message;

  message.commande = TypeCommande;
  message.valeur = 116;
  Mirf.send((byte*) &message); // On envoie le message
  while (Mirf.isSending()); // On attend la fin de l'envoi
}
void loop() {

  if (digitalRead(boutB)== LOW){ EnvoiCommande(1);} // ou ne serait-ce pas if (digitalRead(boutB) == LOW) EnvoiCommande(1); puisqu'en input pullup?
  if (digitalRead(boutD)== LOW){ EnvoiCommande(2);}
  if (digitalRead(boutH)== LOW) {EnvoiCommande(3);}
  if (digitalRead(boutG)== LOW) {EnvoiCommande(4);}
  if (digitalRead(boutM)== LOW) {EnvoiCommande(5);}


}

et le récepteur

/**
   Exemple de code pour la bibliothèque Mirf – Sonnette DIY (récepteur)
*/
#include <SPI.h>      // Pour la communication via le port SPI
#include <Mirf.h>     // Pour la gestion de la communication
#include <nRF24L01.h> // Pour les définitions des registres du nRF24L01
#include <MirfHardwareSpiDriver.h> // Pour la communication SPI
int DS_pin = 3;
int STCP_pin = 4;
int SHCP_pin = 5;
typedef struct {
  int commande;
  int valeur;
} MaStructure;
int desplay[10][7] = {
  {1, 1, 1, 1, 1, 1, 0}, //0
  {0, 1, 1, 0, 0, 0, 0}, //1
  {1, 1, 0, 1, 1, 0, 1}, //2
  {1, 1, 1, 1, 0, 0, 1}, //3
  {0, 1, 1, 0, 0, 1, 1}, //4
  {1, 0, 1, 1, 0, 1, 1}, //5
  {1, 0, 1, 1, 1, 1, 1}, //6
  {1, 1, 1, 0, 0, 0, 0}, //7
  {1, 1, 1, 1, 1, 1, 1}, //8
  {1, 1, 1, 1, 0, 1, 1} //9
};


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

  pinMode(DS_pin, OUTPUT);
  pinMode(STCP_pin, OUTPUT);
  pinMode(SHCP_pin, OUTPUT);


  Mirf.cePin = 9; // Broche CE sur D9
  Mirf.csnPin = 10; // Broche CSN sur D10
  Mirf.spi = &MirfHardwareSpi; // On veut utiliser le port SPI hardware
  Mirf.init(); // Initialise la bibliothèque

  Mirf.channel = 116; // Choix du canal de communication (128 canaux disponibles, de 0 à 127)
  Mirf.payload = sizeof(MaStructure);  // Taille d'un message (maximum 32 octets)
  Mirf.config(); // Sauvegarde la configuration dans le module radio

  Mirf.setTADDR((byte *) "nrf01"); // Adresse de transmission
  Mirf.setRADDR((byte *) "nrf02"); // Adresse de réception
  Serial.println("Go !");

}
boolean registers[8];

void writereg()
{
  digitalWrite(STCP_pin, LOW);
  for (int i = 7; i >= 0; i--)
  {
    digitalWrite(SHCP_pin, LOW);
    digitalWrite(DS_pin, registers[i] );
    digitalWrite(SHCP_pin, HIGH);
  }
  digitalWrite(STCP_pin, HIGH);
}
void loop() {
  MaStructure message;
  //  for (int j = 0; j<  9 ; j++){
  //  for (int i = 0; i < 7; i++) {
  //registers[i] = desplay[j][i];
  //  }
  //     delay(1000); writereg();
  //  }


  if (Mirf.dataReady()) {
   
    Mirf.getData((byte*) &message);

    switch (message.commande) {
      case 1:
        {

          for (int i = 0; i < 7; i++) {
            registers[i] = desplay[1][i];
          }
          delay(1000); writereg();
          break;
        }
      case 2:
        {

          for (int i = 0; i < 7; i++) {
            registers[i] = desplay[2][i];
          }
          delay(1000); writereg();
          break;
        }
      case 3:
        {

          for (int i = 0; i < 7; i++) {
            registers[i] = desplay[3][i];
          }
          delay(1000); writereg();
          break;
        }
      case 4:
        {

          for (int i = 0; i < 7; i++) {
            registers[i] = desplay[4][i];
          }
          delay(1000); writereg();
          break;
        }
      case 5:
        {

          for (int i = 0; i < 7; i++) {
            registers[i] = desplay[5][i];
          }
          delay(1000); writereg();

          //break;
        }
      case 6:
        {

          for (int i = 0; i < 7; i++) {
            registers[i] = desplay[6][i];
          }
          delay(1000); writereg();
          break;
        }
      case 7:
        {

          for (int i = 0; i < 7; i++) {
            registers[i] = desplay[7][i];
          }
          delay(1000); writereg();
          break;
        }
    }
  }
}

et ca ne marche toujours pas

vous utlilisez quel arduino? et quelles broches sont utilisées pour la communication SPI?
votre carte ressemble à cela?

ou

La bibliothèque Mirf est très ancienne (6 ans sans mise à jour !!) il est peut-être opportun de regarder d'autres bibliothèques comme la TMRH20 RF24 ou RadioHead et lire ce tuto

bedji:
et ca ne marche toujours pas

OK ça on a compris sinon tu ne serais pas là.
Mais qu'est-ce qui ne marche pas?
L'émission?
La réception?

As-tu placé quelques print dans ton code pour vérifier ce qui est envoyé/reçu?

  Mirf.csnPin = 10; // Broche CSN sur D10 --> vous êtes bien sur un UNO?