Problème logique "ou" sur prog. " télérupteur"

Bonjour à tous,

Je débute en Arduino et je commence une programmation afin de gérer l'éclairage de mon habitation en bouton poussoir géré façon télérupteur.

Je me suis calqué sur l'exemple "debonce" de l'IDE.

Tout fonctionne sauf quand je veux gérer 2 boutons poussoir...

J'ai essayé plusieurs forme mais le résultat obtenu et un "et" malgré la mise en place de "||"...

Pourriez vous me dire mon erreur svp?

En gros je voudrais faire une variable qui soit la résultante d'un calcule bouléen:

int bp=bp1 || bp2;

N'est ce pas possible?

Merci d'avance!

bonjour le plus simple pour simuler un telerupteur avec plusieurs boutons est de cabler les boutons en // d'incrementer une variable lors d'un appui sur un des boutons et de calculer le modulo 2 le resultat sera soit 0 soit 1

Bonjour,

Bien qu'il soit plus simple de faire comme le suggère Artouste, il ne devrait pas y avoir de problème à faire bp1||bp2. Peux tu mettre ton code.

Bonjour et merci pour vos réponses,

Artouste, j'aimerais garder la modularité sans toucher au câblage à chaque changement...

Kamill, le voici:

const int Lum = 3; //Sortie lumiére//
const int BP1 = 2; //entrée bouton 1//
const int BP2 = 4; //entrée bouton 2//
int EtatLum=LOW;   //etat de la lumiére//  
int EtatBP;        //etat des boutons poussoirs calculé//    
int EtatBPAnt=LOW; //etat des boutons poussoirs antérieur//
long RebStart = 0; //démarrage tempo anti-rebond//
long Reb = 50;     //durée anti-rebond//

void setup() {
  pinMode (BP1,INPUT_PULLUP);
  pinMode (BP2,INPUT_PULLUP);
  pinMode (Lum,OUTPUT);
  Serial.begin(9600);
digitalWrite(Lum,EtatLed);
}

void loop() {
  int bp1=digitalRead (BP1);
  int bp2=digitalRead (BP2);
  int sbp=bp1 || bp2;
 int Lecture = sbp ;
   if (Lecture != EtatBPAnt) {
    
    RebStart = millis();
   }
   if ((millis() - RebStart) >= Reb)  {
     if (Lecture != EtatBP) {
      EtatBP = Lecture ;
      if (EtatBP ==HIGH)  {
        EtatLed = !EtatLed;
      }
     }
  }
  digitalWrite(Lum,EtatLed);
  EtatBPAnt= Lecture;
  }

Merci.

Tu utilises INPUT_PULLUP, donc tes boutons sont en logique négative (enfoncés à 0). Donc soit tu changes la logique de ton programme pour raisonner en logique inversée, soit ce que je te conseille c'est d'inverser l'état à la lecture:

 int bp1=!digitalRead (BP1);
 int bp2=!digitalRead (BP2);

comme ça tu n'as rien d'autre à changer dans ton programme.

Julienduino: Bonjour et merci pour vos réponses,

Artouste, j'aimerais garder la modularité sans toucher au câblage à chaque changement...

l'option de //lisation hard etait simplement pour exposer une solution

apres que tu fasse si bp1 appuyé = compteur + 1 si bp2 " " = compteur +1 si bpx " " +1 et qu'en sortie tu verifie simplement etat = valeur compteur modulo 2 ça ne changera rien à l'etat final de ton telerupteur quelque soit le nombre de points de sollicitations ;)

  int sbp=bp1 || bp2;

Je ne suis pas sûr du tout qu'Arduino comprenne cela de la manière dont on aimerait qu'il le comprenne. En l'occurrence, je pense que tu mélanges le OU logique || et le OU bit à bit |. Le premier sert à tester une condition, par exemple:

if((spb == pb1) || (spb == pb2)){
  ...
}

Le deuxième serait plus adapté à ce que tu cherches, il permet de faire des opérations bit à bit. Par exemple, 0011 | 0101 == 0111 Dans ton cas puisque tu cherches à comparer les états de deux boutons poussoir, il n'y a pas besoin de déclarer des int, le format boolean suffirait. Et l'opérateur | donnerait le résultat escompté. ;)

Kamill:
Excelent!..merci…ça fonctionne!

Par contre je t’avoue avoir le cerveau qui bug sur cette fonction, je t’explique:

Selon tous ce que j’ai pu lire, effectivement le raisonnement est inversé, alors j’ai fait un petit essai:

void setup() {
  pinMode (BP, INPUT_PULLUP);
  pinMode (LED, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  if (digitalRead (BP)==LOW) 
  {
  digitalWrite (LED,HIGH);
  delay (100);
  }
   if (digitalRead (BP)==HIGH) 
   {
  digitalWrite (LED,LOW);
  delay(100);
   }
}

Normalement lors de l’appui du BP la led s’allume et s’éteint lorsqu’on relâche, c’est bien ça?

Et bien non…c’est l’inverse…

Artouste:

Ok, autant pour moi, effectivement je vais m’y pencher…

Troisiemetype:

C’est aussi une piste que je vais regarder…je vais essayer…

Merci pour vos solution!

Julienduino: Normalement lors de l'appui du BP la led s'allume et s’éteint lorsqu’on relâche, c'est bien ça? Et bien non...c'est l'inverse...

Ca dépend comment est branchée ta led. Si elle est connectée au 5V (bien sur avec une résistance) elle s'alumera quand la sortie sera à 0, si elle est connectée au 0V, elle s'allumera quand la sortie est à 1

C'est une platine relais que j'ai derrière,qui s’enclenche au niveau bas de mémoire. Donc sa serait logique.

Pourtant l'inversion des lectures des BP à bien résolut le problème...et j'aimerais bien comprendre pourquoi!;-)

Artouste: Effectivement pour certaines lumières qui vont être commandées par 4 ou 5 inter ça prend tout son sens!

Troisiemetype: si j'ai bien fait le boulot, après être passé en boolean, même résultat...

Julienduino: si j'ai bien fait le boulot, après être passé en boolean, même résultat...

C'est normal. Le C++ n'est pas un langage très typé, on peut remplacer un booléen par un entier et qu'on utilise des booléens ou des entiers ça donnera le même résultat. Conceptuellement, et peut être pour des questions de performance il vaut mieux utiliser des bool pour les opérations logiques.

pepe: Le langage C++ est en général très typé, mais il a été conçu pour être au maximum compatible avec le langage C dans lequel type booléen (bool) n'existe pas.

Je persiste à dire que le C++ n'est pas un langage très typé. Par exemple on peut affecter à un entier un booléen, un caractère, un unsigned et même un enum.

 bool bVal=true;
 int iVal=bVal;

 char cVal='A';
 iVal=cVal;

 unsigned uVal=1;
 iVal=uVal;

 enum EVal {A,B,C} eVal=A;
 iVal=eVal;

Essaies de faire ça en pascal pour voir.

... ou en ADA ! :D

Ca existe encore des compilateurs ADA? :)

kamill:
Ca existe encore des compilateurs ADA? :slight_smile:

Oui !

Ce langage est toujours utilisé dans les cursus de formation, pour ses vertus pédagogiques induites par la rigueur de programmation qu’il impose.
Déjà à l’époque, mes profs me disaient : apprenez à développer en ada et ensuite vous aurez de bonnes habitudes pour programmer en C.

Dans le milieu professionnel on le trouve encore, là où la fiabilité des programmes est primordiale (avionique, spacial, militaire, etc.).