Télécommande sans fil et boutons du LCD Keypad shield dans la même séquence

Bonjour à tous,

J’ai commencé à monter un déclencheur pour appareil photo, mais je me heurte à un problème.

J’ai dans mon programme une séquence où je change des paramètres grâce aux boutons du lcd keypad shield et j’aimerais pouvoir lancer une action en activant un bouton de ma télécommande sans fil.
Les boutons du lcd me changent le retard et le temps de pose de la photo, ceux de la commande feraient la mise au point et le déclenchement/

Pour le matériel, voici la télécommande et le LCD

J’arrive à naviguer dans les menus avec les boutons du LCD, mais je n’ai pas de réaction lorsque j’utilise la télécommande.
En faisant un test avec serialprint, j’arrive à voir que le fait d’actionner les boutons de la télécommande fait passer l’état de 0 à 1 donc elle semble fonctionner.

S’il vous faut plus de précisions, n’hésitez pas à demander.

Merci d’avance pour l’aide.

Voici mon code actuel:

#include <LiquidCrystal.h>              //on définit la librairie LCD

LiquidCrystal lcd(8, 9, 4, 5, 6, 7); // on définit les broches du LCD

int lcd_key1    = 0;   
int lcd_key2    = 0;
int adc_key_in1  = 0;
int adc_key_in2  = 0;
int val_boutona;
int val_boutonb;
int mode = 0;  
int mode2 = 0;
int relais1 = 12;
int relais2 = 11;
int retard1 = 0;
int pose = 1000;
int cdeclencheur;
int cintervallometre;
int cbulb;

unsigned long last_affichage;

#define btnRIGHT1  1
#define btnUP1     2
#define btnDOWN1   3
#define btnLEFT1   4
#define btnSELECT1 5
#define btnNONE1   6

#define btnRIGHT2  10
#define btnUP2     11
#define btnDOWN2   12
#define btnLEFT2   13
#define btnSELECT2 14
#define btnNONE2   15

#define boutona_on 16
#define boutona_off 17
#define boutonb_on 18
#define boutonb_off 19

int read_LCD_buttons1()
{
  adc_key_in1 = analogRead(0);      
  if (adc_key_in1 > 1000) return btnNONE1; //1000
  if (adc_key_in1 < 100)   return btnRIGHT1;  //50
  if (adc_key_in1 < 200)  return btnUP1; //250
  if (adc_key_in1 < 380)  return btnDOWN1; //380
  if (adc_key_in1 < 555)  return btnLEFT1; //555
  if (adc_key_in1 < 790)  return btnSELECT1;    //790
}

int read_LCD_buttons2()
{
  adc_key_in2 = analogRead(0);      
  if (adc_key_in2 > 1000) return btnNONE2; 
  if (adc_key_in2 < 100)   return btnRIGHT2;  
  if (adc_key_in2 < 200)  return btnUP2; 
  if (adc_key_in2 < 380)  return btnDOWN2; 
  if (adc_key_in2 < 555)  return btnLEFT2; 
  if (adc_key_in2 < 790)  return btnSELECT2; 
  
  val_boutona = digitalRead(A1);  
  if (val_boutona = HIGH) return boutona_on;
  if (val_boutona = LOW) return boutona_off;  
  
  val_boutonb = digitalRead(A2);  
  if (val_boutona = HIGH) return boutonb_on;
  if (val_boutona = LOW) return boutonb_off;
}


int actionbulb()         //Si A est actionné, le relais 1 est ouvert pendant 6 secondes (voir temps pour mise au point)
{                        // Si B est actionné, on déclenche le relais 2 avec le retard et le temps de pose prédéfinis
      lcd.clear();
      lcd.print ("Photo en cours");
      delay(retard1);
      digitalWrite(relais1, HIGH); 
      delay(pose);
      digitalWrite(relais1, LOW);
     
}                       

int actionintervallometre()     // Si A est actionné, le relais 1 est ouvert pendant 6 secondes (voir temps pour mise au point)
{}                              // Si B est actionné, on déclenche le relais 2 autant de fois que prédéfini avec temps de pose et de délai entre les photos définis


int bulb()       // ce qui se passe quand le choix est declencheur
{    
 while (cbulb == 1)
  {
    if ( millis() - last_affichage > 1000) {
      lcd.clear();
      lcd.setCursor (0,0);
      lcd.print ("Retard:");
      lcd.setCursor (8,0);
      lcd.print (retard1/1000) ;
      lcd.setCursor (12,0);
      lcd.print ("sec.");
      lcd.setCursor (0,1);
      lcd.print ("Pose:");
      lcd.setCursor (8,1);
      lcd.print (pose/1000) ;
      lcd.setCursor (12,1);
      lcd.print ("sec.");
     last_affichage = millis();
    } 
     
    {   
      lcd_key2 = read_LCD_buttons2() ;
      switch (lcd_key2)  {
      case btnSELECT2:    
        { 
         actionbulb();
         break;
        }

      case btnUP2:
        {
          pose = pose+1000;
          delay(200);
          break;
        }

      case btnDOWN2:
        {   
          pose = pose-1000;
          delay(200);
          break;  
        }

      case btnLEFT2:
        {
          retard1 = retard1-1000;
          delay(200);
          break;
        }

      case btnRIGHT2:
        {
          retard1 = retard1+1000;
          delay(200);
          break;
        }
      case boutona_on:    
        { 
         actionbulb();
         break;
        }  
      case boutonb_on:    
        { 
      digitalWrite(relais2, HIGH); 
      delay(5000);
      digitalWrite(relais2, LOW);
       break;
        }
        
      };
    }
  }  
}
        
int intervallometre()  // ce qui se passe quand le choix est intervallometre
{
lcd.clear() ; 
}        


int reglages()   //ce qui va se passer quand on appuie sur select dans le menu de choix du mode
{ 
  switch(mode)   {
  case 1:          
    {
     cbulb = 1; 
     delay(200); 
     bulb();
     break;
    } 
               
case 2:          
    {
    cintervallometre = 1;
    delay(200);
    intervallometre();
    break;
    } 
  }}

int menumode()                                    // Menu de démarrage choix du mode
{ 
  
  lcd.setCursor (1,0);
  lcd.print ("Declencheur");
  lcd.setCursor (1,1);
  lcd.print ("Intervallometre");  

  lcd_key1 = read_LCD_buttons1() ;
  switch (lcd_key1)  {
  case btnSELECT1:    
    { 
      reglages();
      break;
    }

  case btnUP1:
    {
      lcd.clear();     
      lcd.setCursor (1,0);
      lcd.print ("Declencheur");
      lcd.setCursor (1,1);
      lcd.print ("Intervallometre"); 
      mode= 1;     
      Serial.println(mode);
      lcd.setCursor (0,0);
      lcd.print ((char)126);
      lcd.setCursor (0,1);
      lcd.print (' ');
      break;
    }

  case btnDOWN1:
    {  
      lcd.clear() ;    
      lcd.setCursor (1,0);
      lcd.print ("Declencheur");
      lcd.setCursor (1,1);
      lcd.print ("Intervallometre"); 
      mode= 2;    
      Serial.println(mode);
      lcd.setCursor (0,1);
      lcd.print ((char)126);
      lcd.setCursor (0,0);
      lcd.print (' ');
      break;  
    }
  };
}




void setup()
{
  pinMode(relais1, OUTPUT);  
  pinMode(relais2, OUTPUT);
  pinMode (boutona, INPUT);
  pinMode (boutonb, INPUT);
  digitalWrite(10, HIGH);  //Eclairage de l'écran
    
  Serial.begin(115200);   
  lcd.begin(16, 2); 
  lcd.clear();
}


void loop()
  {
    menumode();
  }

Bonjour,

Mets ton code entre balises code

Tu utilises l'opérateur d'affectation = au lieu de l'opérateur de comparaison ==

  val_boutona = digitalRead(A1);  
  if (val_boutona = HIGH) return boutona_on;
  if (val_boutona = LOW) return boutona_off;  
  
  val_boutonb = digitalRead(A2);  
  if (val_boutona = HIGH) return boutonb_on;
  if (val_boutona = LOW) return boutonb_off;

à remplacer par

  val_boutona = digitalRead(A1);  
  if (val_boutona == HIGH) return boutona_on;
  if (val_boutona == LOW) return boutona_off;  
  
  val_boutonb = digitalRead(A2);  
  if (val_boutona == HIGH) return boutonb_on;
  if (val_boutona == LOW) return boutonb_off;

à la place de tester 2 fois tu peux utiliser else

Il y a aussi un problème de logique, tu ne vas jamais tester boutonb puisque une des conditions sur boutona est forcément vraie.

Merci pour ta réponse.

Je testerai la modification.

Si je comprends bien, boutona ne sera pas testé non plus puisqu'on teste adc_key_in2.

Comment faire pour que la télécommande soit utilisable en même temps que les bouton du shield lcd?

Effectivement si un bouton du keypad est appuyé ça va retourner le code du bouton et le test boutona ne sera pas fait e si aucun bouton n'est appuyé ça va retourner boutonNone et le test ne sera pas fait non plus.

Il faut supprimer le test boutonNone au début et retournet boutonNone à la fin si aucun bouton du keypad ou de la télécommande n'est appuyé.

Comme ça?

int read_LCD_buttons2()
{
  adc_key_in2 = analogRead(0);      
  
  if (adc_key_in2 < 100)   return btnRIGHT2;  
  if (adc_key_in2 < 200)  return btnUP2; 
  if (adc_key_in2 < 380)  return btnDOWN2; 
  if (adc_key_in2 < 555)  return btnLEFT2; 
  if (adc_key_in2 < 790)  return btnSELECT2; 
  
  val_boutona = digitalRead(A1);  
  if (val_boutona = HIGH) return boutona_on;
  if (val_boutona = LOW) return boutona_off;  
  
  val_boutonb = digitalRead(A2);  
  if (val_boutona = HIGH) return boutonb_on;
  if (val_boutona = LOW) return boutonb_off;

  if (adc_key_in2 > 1000) return btnNONE2; 
}

Il ne faut pas qu’un appui sur le bouton A de la télécommande empêche le bouton B de fonctionner.
Ne devrais-je pas mettre ceci:

 val_boutona = digitalRead(A1);  
  if (val_boutona = HIGH) return boutona_on;
  if (val_boutona = LOW) return btnNONE2;  
  
  val_boutonb = digitalRead(A2);  
  if (val_boutona = HIGH) return boutonb_on;
  if (val_boutona = LOW) return btnNONE2;

Attention tu n’a pas corrigé le = à la place du ==

Pour la logique ce serait plutot ceci

val_boutona = digitalRead(A1);  
 if (val_boutona == HIGH) return boutona_on;
 
 val_boutonb = digitalRead(A2);  
 if (val_boutona == HIGH) return boutonb_on;

 return btnNONE2;

Merci, je vais modifier ça et je testerai tout à l'heure, je n'ai pas la carte avec moi pour le moment.

Ca a l'air de fonctionner, merci. :wink:

Maintenant, finir le code pour la section "intervalomètre", mais ça devrait aller.