Problème dans la boucle if

Bonjour.

J'ai écrit un code pour allumer des LED ( lampes) en appuyant les boutons d'un clavier matriciel 4x4.

Lorsque je réalise une simulation sous le logiciel PROTEUS, les lampes ne fonctionnent pas comme je le souhaite ( elles ne s'allument pas).

En gros lorsque j'appuis le bouton '*', le système est sensé attendre que j'appuis un second bouton ( compris entre '1' et '5' ) pour allumer la lampe correspondante.

Mais lorsque j'appuis le bouton '*' et après j'appuis sur un autre ( '1' par exemple) , rien ne se produit, la lampe ne s'allume pas.

Svp quelqu'un peut-il me dire d'où peut venir ce problème ???
Merci d'avance.

Voici le code :

#include <Key.h>
#include <Keypad.h>


/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/
    const int ROW_NUM = 4; //four rows
    const int COLUMN_NUM = 4; //four columns
    
    char keys[ROW_NUM][COLUMN_NUM] = {
    
    {'1','2','3', 'A'},
    
    {'4','5','6', 'B'},
    
    {'7','8','9', 'C'},
    
    {'*','0','#', 'D'}
    
    };
        
    byte pin_rows[ROW_NUM] = {34, 36, 38, 40}; //connect to the row pinouts of the keypad{42, 44, 46, 48}{40, 38, 36, 34}
    byte pin_column[COLUMN_NUM] = {42, 44, 46, 48}; //connect to the column pinouts of the keypad{34, 36, 38, 40}{48, 46, 44, 42}
    Keypad clavier = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );
/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/


/*--------------------------------------declaration des Pins des lampes--------------------------------------*/
    int lampeSalon = 22;
    int lampeChambre = 24;
    int lampeCuisine = 26;
    int lampeGarage = 28;
    int lampeDouche = 30;
/*--------------------------------------declaration des Pins des lampes--------------------------------------*/


/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/

//------------variables des switch/case de la fonction éclairage
    int sal = 0 ;
    int cha = 0 ;
    int cui = 0 ;
    int gar = 0 ;
    int dou = 0 ;
//------------variables du switch/case de la fonction 'éclairage()'

//------------variables de gestion des états des lampes
    int state_Salon = 0 ;
    int state_Chambre = 0 ;
    int state_Cuisine = 0 ;
    int state_Garage = 0 ;
    int state_Douche = 0 ;

//------------variables de gestion des états des lampes
/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/

/*----------------------------------------Déclaration des fonctions---------------------------------------------*/
    int eclairage (int a, int b, int c, int d, int e ); // fontion de gestion de l'éclairage
   int gestion_clavier(); // fonction de gestion du clavier
/*----------------------------------------Déclaration des fonctions---------------------------------------------*/

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

/*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/ 
     pinMode(lampeSalon, OUTPUT);
     pinMode(lampeChambre, OUTPUT);
     pinMode(lampeCuisine, OUTPUT);
     pinMode(lampeGarage, OUTPUT);
     pinMode(lampeDouche, OUTPUT);
/*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/


/*-------------------------------------gestion du clavier-------------------------------------*/
    //keypad.setDebounceTime(50); // pour régler l'anti-rebon à 50ms
/*-------------------------------------gestion du clavier-------------------------------------*/
 
 }



void loop(){
    
    gestion_clavier();
    eclairage(sal, cha, cui, gar, dou) ;
}



/*----------------------------------fonction de reccupération des touches enfoncées du clavier-------------------------------------*/
int gestion_clavier(){

    char code = clavier.getKey();
    Serial.println(code);
    
  if (code != NO_KEY){ 
    
        if (code == '*'){
          
              switch (code){
                  
                      case '1' :
                       sal = 1 ;
                      break;
                      
                      case '2' :  
                       cha = 1 ;
                      break;
                      
                      case '3' :
                       cui = 1 ;
                      break;
                       
                      case '4' :
                       gar = 1 ;
                      break;
                      
                      case '5' :
                       dou = 1 ;
                      break;      
                  }
                }
              }
            } 
      
/*----------------------------------fonction  de reccupération des touches enfoncées du clavier-------------------------------------*/


/*-----------------------------fonction gestion de l'éclairage à partir des requetes obtenues précédemment--------------------*/
int eclairage (int a, int b, int c, int d, int e){

          switch (a){
            
            case 1 :
              digitalWrite(lampeSalon, HIGH);
              state_Salon = 1 ;
              a = 0 ;
            break;

            case 2 :
              digitalWrite(lampeSalon, LOW); 
              state_Salon = 0 ;
              a = 0 ;
            break; 

         }


          switch (b){
            
            case 1 :
              digitalWrite(lampeChambre, HIGH);
              state_Chambre = 1 ;
              b = 0 ;
            break;

            case 2 :
              digitalWrite(lampeChambre, LOW);
              state_Chambre = 0 ; 
              b = 0 ;
            break;

         }

          
          switch (c){
            
            case 1 :
              digitalWrite(lampeCuisine, HIGH);
              state_Cuisine = 1 ; 
              c = 0 ;
            break;

            case 2 :
              digitalWrite(lampeCuisine, LOW);
              state_Cuisine = 0 ; 
              c = 0 ;
            break; 

         } 


          switch (d){
            
            case 1 :
              digitalWrite(lampeGarage, HIGH);
              state_Garage = 1 ;
              d = 0 ;
            break;

            case 2 :
              digitalWrite(lampeGarage, LOW);
              state_Garage = 0 ; 
              d = 0 ;
            break;  

         } 


          switch (e){
            
            case 1 :
              digitalWrite(lampeDouche, HIGH);
              state_Douche = 1 ;
              e = 0 ;
            break;

            case 2 :
              digitalWrite(lampeDouche, LOW);
              state_Douche = 0 ;
              e = 0 ;
            break;  

         }    

}
/*-----------------fonction gestion de l'éclairage à partir des requetes obtenues précédemment--------------------*/

hello

tu scrutes le keyboard, tu lis "*" et tu regardes si c'est "1" ou ...

essaye en rajoutant une lecture du keyboard juste avant le swich

char code = clavier.getKey();
    Serial.println(code);
    
  if (code != NO_KEY){ 
    
        if (code == '*'){
          code = clavier.getKey();
 if (code != NO_KEY){ 
              switch (code){
                  
                      case '1' :
                       sal = 1 ;
                      break;

sans oublier de rajouter un "}" à la fin du if

Je l'ai fait mais ça n'a pas résolu le problème.

Voici le nouveau code :

#include <Key.h>
#include <Keypad.h>


/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/
    const int ROW_NUM = 4; //four rows
    const int COLUMN_NUM = 4; //four columns
    
    char keys[ROW_NUM][COLUMN_NUM] = {
    
    {'1','2','3', 'A'},
    
    {'4','5','6', 'B'},
    
    {'7','8','9', 'C'},
    
    {'*','0','#', 'D'}
    
    };
        
    byte pin_rows[ROW_NUM] = {34, 36, 38, 40}; //connect to the row pinouts of the keypad{42, 44, 46, 48}{40, 38, 36, 34}
    byte pin_column[COLUMN_NUM] = {42, 44, 46, 48}; //connect to the column pinouts of the keypad{34, 36, 38, 40}{48, 46, 44, 42}
    Keypad clavier = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );
/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/


/*--------------------------------------declaration des Pins des lampes--------------------------------------*/
    int lampeSalon = 22;
    int lampeChambre = 24;
    int lampeCuisine = 26;
    int lampeGarage = 28;
    int lampeDouche = 30;
/*--------------------------------------declaration des Pins des lampes--------------------------------------*/


/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/

//------------variables des switch/case de la fonction éclairage
    int sal = 0 ;
    int cha = 0 ;
    int cui = 0 ;
    int gar = 0 ;
    int dou = 0 ;
//------------variables du switch/case de la fonction 'éclairage()'

//------------variables de gestion des états des lampes
    int state_Salon = 0 ;
    int state_Chambre = 0 ;
    int state_Cuisine = 0 ;
    int state_Garage = 0 ;
    int state_Douche = 0 ;  
//------------variables de gestion des états des lampes
/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/

/*----------------------------------------Déclaration des fonctions---------------------------------------------*/
    int eclairage (int a, int b, int c, int d, int e ); // fontion de gestion de l'éclairage
   int gestion_clavier(); // fonction de gestion du clavier
/*----------------------------------------Déclaration des fonctions---------------------------------------------*/

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

/*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/ 
     pinMode(lampeSalon, OUTPUT);
     pinMode(lampeChambre, OUTPUT);
     pinMode(lampeCuisine, OUTPUT);
     pinMode(lampeGarage, OUTPUT);
     pinMode(lampeDouche, OUTPUT);
/*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/


/*-------------------------------------gestion du clavier-------------------------------------*/
    //keypad.setDebounceTime(50); // pour régler l'anti-rebon à 50ms
/*-------------------------------------gestion du clavier-------------------------------------*/
 
 }



void loop(){
    
    gestion_clavier();
    eclairage(sal, cha, cui, gar, dou) ;
}



/*----------------------------------fonction de reccupération des touches enfoncées du clavier-------------------------------------*/
int gestion_clavier(){

    char code = clavier.getKey();
    Serial.print("code : ");
    Serial.println(code);
    
 if (code != NO_KEY){ 
  if (code == '*'){ 
    
     code = clavier.getKey(); 
     
      if (code != NO_KEY){
        
             switch (code){
          
              case '1' :
               sal = 1 ;
              break;
              
              case '2' :  
               cha = 1 ;
              break;
              
              case '3' :
               cui = 1 ;
              break;
               
              case '4' :
               gar = 1 ;
              break;
              
              case '5' :
               dou = 1 ;
              break; 
              
            }
          }
        }         
      }
    }
      
/*----------------------------------fonction  de reccupération des touches enfoncées du clavier-------------------------------------*/


/*-----------------------------fonction gestion de l'éclairage à partir des requetes obtenues précédemment--------------------*/
int eclairage (int a, int b, int c, int d, int e){

          switch (a){
            
            case 1 :
              digitalWrite(lampeSalon, HIGH);
              state_Salon = 1 ;
              a = 0 ;
            break;

            case 2 :
              digitalWrite(lampeSalon, LOW); 
              state_Salon = 0 ;
              a = 0 ;
            break; 

             //return state_Salon;
         }


          switch (b){
            
            case 1 :
              digitalWrite(lampeChambre, HIGH);
              state_Chambre = 1 ;
              b = 0 ;
            break;

            case 2 :
              digitalWrite(lampeChambre, LOW);
              state_Chambre = 0 ; 
              b = 0 ;
            break;

              //return state_Chambre;
         }

          
          switch (c){
            
            case 1 :
              digitalWrite(lampeCuisine, HIGH);
              state_Cuisine = 1 ; 
              c = 0 ;
            break;

            case 2 :
              digitalWrite(lampeCuisine, LOW);
              state_Cuisine = 0 ; 
              c = 0 ;
            break; 

            // return state_Cuisine;
         } 


          switch (d){
            
            case 1 :
              digitalWrite(lampeGarage, HIGH);
              state_Garage = 1 ;
              d = 0 ;
            break;

            case 2 :
              digitalWrite(lampeGarage, LOW);
              state_Garage = 0 ; 
              d = 0 ;
            break;  

           // return state_Garage;
         } 


          switch (e){
            
            case 1 :
              digitalWrite(lampeDouche, HIGH);
              state_Douche = 1 ;
              e = 0 ;
            break;

            case 2 :
              digitalWrite(lampeDouche, LOW);
              state_Douche = 0 ;
              e = 0 ;
            break;  

           // return state_Douche;
         }    


}
/*-----------------fonction gestion de l'éclairage à partir des requetes obtenues précédemment--------------------*/

Salut

Alors d'accord, les lumières ne s'allument pas.

Mais est-ce que l'appui sur le clavier fonctionne ? En regardant le moniteur série qu'y a-t-il dedans ?

L'appui sur le clavier fonctionne car le bouton appuyé apparaît sur le moniteur série.

hello
ce code fonctionne

int gestion_clavier()
{
  char code = clavier.getKey();
  if (code != NO_KEY) {
    Serial.print("1er code : "); Serial.println(code);
    if (code == '*') {
      code = NO_KEY;
      while (code == NO_KEY) {
        code = clavier.getKey();
      }
      Serial.print("2ème code : "); Serial.println(code);

      switch (code) {

        case '1' :
          sal = 1 ;
          break;

hello
ton code ne fonctionnait pas
voici une version opérationnelle
il faudra enlever les serial.print
attention, en 115200 bauds

#include <Key.h>
#include <Keypad.h>
/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/
const int ROW_NUM = 4; //four rows
const int COLUMN_NUM = 4; //four columns
char keys[ROW_NUM][COLUMN_NUM] = {

  {'1', '2', '3', 'A'},

  {'4', '5', '6', 'B'},

  {'7', '8', '9', 'C'},

  {'*', '0', '#', 'D'}

};

byte pin_rows[ROW_NUM] = {34, 36, 38, 40}; //connect to the row pinouts of the keypad{42, 44, 46, 48}{40, 38, 36, 34}
byte pin_column[COLUMN_NUM] = {42, 44, 46, 48}; //connect to the column pinouts of the keypad{34, 36, 38, 40}{48, 46, 44, 42}
Keypad clavier = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );
/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/


/*--------------------------------------declaration des Pins des lampes--------------------------------------*/
int lampeSalon = 22;
int lampeChambre = 24;
int lampeCuisine = 26;
int lampeGarage = 28;
int lampeDouche = 30;
/*--------------------------------------declaration des Pins des lampes--------------------------------------*/


/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/

//------------variables des switch/case de la fonction éclairage
int sal = 0 ;
int cha = 0 ;
int cui = 0 ;
int gar = 0 ;
int dou = 0 ;
//------------variables du switch/case de la fonction 'éclairage()'

//------------variables de gestion des états des lampes
int state_Salon = 0 ;
int state_Chambre = 0 ;
int state_Cuisine = 0 ;
int state_Garage = 0 ;
int state_Douche = 0 ;
//------------variables de gestion des états des lampes
/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/

/*----------------------------------------Déclaration des fonctions---------------------------------------------*/
int eclairage (int a, int b, int c, int d, int e ); // fontion de gestion de l'éclairage
int gestion_clavier(); // fonction de gestion du clavier
/*----------------------------------------Déclaration des fonctions---------------------------------------------*/

void setup() {

  Serial.begin(115200);

  /*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/
  pinMode(lampeSalon, OUTPUT);
  pinMode(lampeChambre, OUTPUT);
  pinMode(lampeCuisine, OUTPUT);
  pinMode(lampeGarage, OUTPUT);
  pinMode(lampeDouche, OUTPUT);
  /*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/


  /*-------------------------------------gestion du clavier-------------------------------------*/
  //keypad.setDebounceTime(50); // pour régler l'anti-rebon à 50ms
  /*-------------------------------------gestion du clavier-------------------------------------*/

}



void loop()
{
  gestion_clavier();
  eclairage(sal, cha, cui, gar, dou) ;
}
int gestion_clavier()
{
  char code = clavier.getKey();
  if (code != NO_KEY) {
    Serial.print("1er code : "); Serial.println(code);
    if (code == '*') {
      code = NO_KEY;
      while (code == NO_KEY) {
        code = clavier.getKey();
      }
      Serial.print("2ème code : "); Serial.println(code);

      switch (code) {
        case '1' :
          sal = !sal ; Serial.print("sal : "); Serial.println(sal);
          break;

        case '2' :
          cha = !cha ; Serial.print("cha : "); Serial.println(cha);
          break;

        case '3' :
          cui = !cui ; Serial.print("cui : "); Serial.println(cui);
          break;

        case '4' :
          gar = !gar ; Serial.print("gar : "); Serial.println(gar);
          break;

        case '5' :
          dou = !dou ; Serial.print("dou : "); Serial.println(dou);
          break;
      }
    }
  }
}

int eclairage (int a, int b, int c, int d, int e)
{
  switch (a) {

    case 1 :
      digitalWrite(lampeSalon, HIGH);
      state_Salon = 1 ; Serial.print("dans eclairage, etat salon : "); Serial.println(state_Salon);
      a = 0 ;
      break;

    case 0 :
      digitalWrite(lampeSalon, LOW);
      state_Salon = 0 ; Serial.print("dans eclairage, etat salon : "); Serial.println(state_Salon);
      a = 0 ;
      break;
  }


  switch (b) {

    case 1 :
      digitalWrite(lampeChambre, HIGH);
      state_Chambre = 1 ; Serial.print("dans eclairage, etat chambre : "); Serial.println(state_Chambre);
      b = 0 ;
      break;

    case 2 :
      digitalWrite(lampeChambre, LOW);
      state_Chambre = 0 ; Serial.print("dans eclairage, etat chambre : "); Serial.println(state_Chambre);
      b = 0 ;
      break;
  }


  switch (c) {
    case 1 :
      digitalWrite(lampeCuisine, HIGH);
      state_Cuisine = 1 ; Serial.print("dans eclairage, etat cuisine : "); Serial.println(state_Cuisine);
      c = 0 ;
      break;

    case 0 :
      digitalWrite(lampeCuisine, LOW);
      state_Cuisine = 0 ; Serial.print("dans eclairage, etat cuisine : "); Serial.println(state_Cuisine);
      c = 0 ;
      break;
  }


  switch (d) {

    case 1 :
      digitalWrite(lampeGarage, HIGH);
      state_Garage = 1 ; Serial.print("dans eclairage, etat garage : "); Serial.println(state_Garage);
      d = 0 ;
      break;

    case 0 :
      digitalWrite(lampeGarage, LOW);
      state_Garage = 0 ; Serial.print("dans eclairage, etat garage : "); Serial.println(state_Garage);
      d = 0 ;
      break;
  }

  switch (e) {
    case 1 :
      digitalWrite(lampeDouche, HIGH);
      state_Douche = 1 ; Serial.print("dans eclairage, etat douche : "); Serial.println(state_Douche);
      e = 0 ;
      break;

    case 2 :
      digitalWrite(lampeDouche, LOW);
      state_Douche = 0 ; Serial.print("dans eclairage, etat douche : "); Serial.println(state_Douche);
      e = 0 ;
      break;
  }
}
/*-----------------fonction gestion de l'éclairage à partir des requetes obtenues précédemment-------

il ne sert à rien de remettre les arguments a, b, c, d, e à zéro dans eclairage(). Les variables globales sal, cha... etc ne sont pas modifiées (le C fait des passages de paramètres par valeurs). Donc ces variables globales ne sont jamais remises à zéro.

De plus, puisque ce sont des variables globales (je parle de sal, cha, ..., dou ) , pourquoi les passer en argument à la fonction éclairage ? Tu t'embrouilles tout seul !

Et puis pourquoi utiliser Switch case alors que digitalWrite(lampeSalon, sal) suffirait ?

(Il faudra aussi modifier le reste du code)

Pour stocker un état avec deux possibilités, on utilise une variable de type boolean.

Et on y met true ou false au lieu de 0 ou 1. Bien plus pratique comme ça on évite d'avoir des mauvaises valeurs, des comparaisons et des conditions à foison, simplement car on peut considérer que false signifie que la lampe est éteinte.

hello
je suis au courant de vos remarques, j'ai simplement voulu rester dans "l'esprit" de codage du demandeur.

1 Like

Bonjour dfgh

Excellent :+1:

Cordialement
jpbbricole

Tout en espérant apprendre à @fullproject comment mieux programmer.
Car quand l'on commence à développer ses projets, je ne vous dit pas la catastrophe !

Merci pour votre apport.

J'ai essayé le code que vous me proposez et il me semble qu'il fonctionne plutôt bien.

Cependant lorsque j'appuis '*' ou '#' le moniteur série reste figé jusqu'à ce que j'appuis un deuxième bouton.

Ainsi tant que je n'appuis pas un deuxième bouton, mon système reste bloqué, ce qui n'est pas bon pour moi car je compte compléter ce code pour en faire un projet de domotique.

Ce bout code n'est qu'une partie ďu code d'un projet de domotique que je compte réaliser. Les lampes seront commandées par deux éléments (une page web et un clavier matriciel), c'est la raison pour laquelle j'utilise des variables intermédiaires ( sal, cha,...,dou) pour allumer les lampes.

Je dois avouer que je ne suis pas très bon en programmation ( je suis débutant ) donc s'il vous plait veuillez m'éclairer concernant l'utilisation des variables globales en argument.

Vous venez de me donner une bonne idée, je vais changer le type des variables (sal, cha,..,dou) en boolean.

une variable globale est "visible" et donc paramétrable n’importe ou dans le programme
une variable locale n'est "visible" et donc paramétrable que dans la fonction ou elle est crée. elle est inconnue du reste du prog.
edit, je ne comprends pas trop le prob d'attente. lorsque tu appuies sur *, c'est que tu veux taper 1,2,3,4 après. si j'imagine faire la manip, il doit y avoir 1/4 de seconde entre les deux touches.
tu veux que le programme fasse autre chose pendant le 1/4 de seconde ?

C'est vrai que 1/4 de seconde est suffisant pour faire la manip mais imaginez quelqu'un qui appuis par inadvertance sur la touche '*', le système se bloque.

L'utilisateur pourrait, sans le vouloir, appuyer sur '*' sans jamais appuyer sur une seconde touche.

Comme je l'ai dit plus haut, ce code n'est qu'une partie du programme d'un prototype de maison intelligente que je souhaite concevoir.

Ci-dessous voici un code que j'ai écrit.

J'ai fais la simulation et à première vue il marche plutôt bien.

S'il vous plaît j'aimerai avoir vos avis concernant ce nouveau code que j'ai écrit.

#include <Key.h>
#include <Keypad.h>


/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/
    const int ROW_NUM = 4; //four rows
    const int COLUMN_NUM = 4; //four columns
    
    char keys[ROW_NUM][COLUMN_NUM] = {
    
    {'1','2','3', 'A'},
    
    {'4','5','6', 'B'},
    
    {'7','8','9', 'C'},
    
    {'*','0','#', 'D'}
    
    };
        
    byte pin_rows[ROW_NUM] = {34, 36, 38, 40}; //connect to the row pinouts of the keypad{42, 44, 46, 48}{40, 38, 36, 34}
    byte pin_column[COLUMN_NUM] = {42, 44, 46, 48}; //connect to the column pinouts of the keypad{34, 36, 38, 40}{48, 46, 44, 42}
    Keypad clavier = Keypad( makeKeymap(keys), pin_rows, pin_column, ROW_NUM, COLUMN_NUM );
/*-----------------------------déclaration des variables de gestion du clavier-------------------------------*/


/*--------------------------------------declaration des Pins des lampes--------------------------------------*/
    int lampeSalon = 22;
    int lampeChambre = 24;
    int lampeCuisine = 26;
    int lampeGarage = 28;
    int lampeDouche = 30;
/*--------------------------------------declaration des Pins des lampes--------------------------------------*/


/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/

//------------variables des switch/case de la fonction éclairage
    int sal = 0 ;
    int cha = 0 ;
    int cui = 0 ;
    int gar = 0 ;
    int dou = 0 ;
//------------variables du switch/case de la fonction 'éclairage()'

//------------variables de gestion des états des lampes
    int state_Salon = 0 ;
    int state_Chambre = 0 ;
    int state_Cuisine = 0 ;
    int state_Garage = 0 ;
    int state_Douche = 0 ;  
//------------variables de gestion des états des lampes

//------------variables de gestion du clavier
    bool etat_button_etoile = false;
    bool etat_button_dieze = false;
 //------------variables de gestion du clavier
/*--------------------------------------------------declaration des des variables pour la gestion de l'éclairage-------------------------*/

/*----------------------------------------Déclaration des fonctions---------------------------------------------*/
    int eclairage (int a, int b, int c, int d, int e ); // fontion de gestion de l'éclairage
   int gestion_clavier(); // fonction de gestion du clavier
/*----------------------------------------Déclaration des fonctions---------------------------------------------*/

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

/*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/ 
     pinMode(lampeSalon, OUTPUT);
     pinMode(lampeChambre, OUTPUT);
     pinMode(lampeCuisine, OUTPUT);
     pinMode(lampeGarage, OUTPUT);
     pinMode(lampeDouche, OUTPUT);
/*--------------------------------------configuration des Pins en entrée/sortie--------------------------------------*/


/*-------------------------------------gestion du clavier-------------------------------------*/
    keypad.setDebounceTime(50); // pour régler l'anti-rebon à 50ms
/*-------------------------------------gestion du clavier-------------------------------------*/
 
 }



void loop(){
    
    gestion_clavier();
    eclairage(sal, cha, cui, gar, dou) ;
}



/*----------------------------------fonction de reccupération des touches enfoncées du clavier-------------------------------------*/
int gestion_clavier(){

    char code = clavier.getKey();
    Serial.println(code);
     Serial.print("etoile : ");
      Serial.println(etat_button_etoile);
      Serial.print("dieze : ");
      Serial.println(etat_button_dieze);
 if (code != NO_KEY){ 
    if (code == '*'){ 
      etat_button_dieze = false;
      etat_button_etoile = true; 
      }
    else if (code == '#'){ 
      etat_button_etoile = false;
      etat_button_dieze = true; 
      }

  else if (etat_button_etoile == true){

             switch (code){
          
              case '1' :
               sal = 1 ;
              break;
              
              case '2' :  
               cha = 1 ;
              break;
              
              case '3' :
               cui = 1 ;
              break;
               
              case '4' :
               gar = 1 ;
              break;
              
              case '5' :
               dou = 1 ;
              break;             
        }
    etat_button_etoile = false ;
  }

   else if (etat_button_dieze == true){

             switch (code){
          
              case '1' :
               sal = 2 ;
              break;
              
              case '2' :  
               cha = 2 ;
              break;
              
              case '3' :
               cui = 2 ;
              break;
               
              case '4' :
               gar = 2 ;
              break;
              
              case '5' :
               dou = 2 ;
              break;            
        }
    etat_button_dieze = false ;
  }
           
         }
        }
      
/*----------------------------------fonction  de reccupération des touches enfoncées du clavier-------------------------------------*/


/*-----------------------------fonction gestion de l'éclairage à partir des requetes obtenues précédemment--------------------*/
int eclairage (int a, int b, int c, int d, int e){

          switch (a){
            
            case 1 :
              digitalWrite(lampeSalon, HIGH);
              state_Salon = 1 ;
              a = 0 ;
            break;

            case 2 :
              digitalWrite(lampeSalon, LOW); 
              state_Salon = 0 ;
              a = 0 ;
            break; 

         }


          switch (b){
            
            case 1 :
              digitalWrite(lampeChambre, HIGH);
              state_Chambre = 1 ;
              b = 0 ;
            break;

            case 2 :
              digitalWrite(lampeChambre, LOW);
              state_Chambre = 0 ; 
              b = 0 ;
            break;

         }

          
          switch (c){
            
            case 1 :
              digitalWrite(lampeCuisine, HIGH);
              state_Cuisine = 1 ; 
              c = 0 ;
            break;

            case 2 :
              digitalWrite(lampeCuisine, LOW);
              state_Cuisine = 0 ; 
              c = 0 ;
            break; 

         } 


          switch (d){
            
            case 1 :
              digitalWrite(lampeGarage, HIGH);
              state_Garage = 1 ;
              d = 0 ;
            break;

            case 2 :
              digitalWrite(lampeGarage, LOW);
              state_Garage = 0 ; 
              d = 0 ;
            break;  

         } 


          switch (e){
            
            case 1 :
              digitalWrite(lampeDouche, HIGH);
              state_Douche = 1 ;
              e = 0 ;
            break;

            case 2 :
              digitalWrite(lampeDouche, LOW);
              state_Douche = 0 ;
              e = 0 ;
            break;  

         }    
}
/*-----------------fonction gestion de l'éclairage à partir des requetes obtenues précédemment--------------------*/

Je vais changer le type des variables intermédiaires ( sal, cha,..., dou) en boolean , ultérieurement.

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.