interrupteur - rebond - Serial.begin - débutant

Bonjour,
je suis nouveau sur le forum et dans le monde Arduino. Je me permet de vous soumettre une question technique.

J'essais de monter une petite installation domestique toute bête avec des interrupteurs qui allument des éclairages de diodes par l'intermédiaire de relais. Mon prototype comprend un seul interrupteur (pin 21) et un seul relai (pin 12). Voici le code en intégralité.

const int APPUI=LOW; // constante état du BP - appui sur niveau bas
const int BP=21; //declaration constante de broche 
const int LEDS=12; //declaration constante de broche
int etatLED=0; // variable d'état de la LED
int BpEtat;
int BpDernierEtat=!APPUI; // dernier état du BP

void setup() {
  pinMode(LEDS, OUTPUT);
  pinMode(BP, INPUT); //met la broche en entree
  digitalWrite(BP, HIGH) ; // activation du pullup de la broche en entrée
  //Serial.begin(9600);
}

void loop() {
  BpEtat = digitalRead(BP);
  if (BpEtat == APPUI && BpEtat != BpDernierEtat){etatLED = !etatLED;}
  if (etatLED==1) {digitalWrite(LEDS,HIGH);} else {digitalWrite(LEDS,LOW);}
  //Serial.println(BpDernierEtat);
  BpDernierEtat = BpEtat;
}

Le truc bizarre, c'est que ça marche très bien quand j'enlève les "//" pour monitorer la valeur BpDernierEtat. Mais ça marche très mal avec: le relai ne s'ouvre pas, ou s'ouvre quand je relache l'interrupteur, ce genre de choses. D'ailleurs, le résultat empire quand je choisis des valeurs élevées du débit de communication: très bon en 9600 bauds, exécrable en 115200 bauds. On dirait que l'entrée Arduino de l'interrupteur échantillonne différemment lorsque je change ce débit, et qu'elle devient très sensible au rebond de l'interrupteur avec des valeurs élevées de débit.

Pourquoi ???

On dirait que l'entrée Arduino de l'interrupteur échantillonne différemment lorsque je change ce débit, et qu'elle devient très sensible au rebond de l'interrupteur avec des valeurs élevées de débit.

L'envoie d'information sur la liaison série "occupe" le processeur pendant un certain temps plus ou moins long suivant la vitesse de transmission et donc agit comme une temporisation plus ou moins longue.
Lorsque cette temporisation est (relativement) longue cela masque les rebonds de l'interrupteur.

Pour lire un interrupteur, il y a 2 ou 3 précautions à prendre:

  • lorsque tu détectes un changement d'état, déclencher une temporisation d'une dizaine de millisecondes et relire l'interrupteur pour confirmer l'état.
  • après confirmation de l'étape 1 et si tu as détecté un appui, attendre le relâché du bouton avant de reprendre la boucle sinon le programme voit des appuis multiples et le résultat est aléatoire.

Principe de gestion d'un poussoir

  1. lecture état
  2. delais
  3. confirmation de l'état (si confirmé on continue sinon retour à 1)
  4. action
  5. attente relâché
  6. retour à 1

Une librairie qui pourrais t'intéresser : Arduino Playground - HomePage

Par ailleurs j'ai un peu peur avec le "un seul relais". Comment le commandes-tu ? (hardwarement parlant)

Commande du relais:
tout simplement en branchant les bornes de sa bobine sur les pins de l'Arduino; GND pour l'une et n° quelconque pour l'autre.

Par ailleurs j'ai un peu peur avec le "un seul relais"

tout simplement en branchant les bornes de sa bobine sur les pins de l'Arduino; GND pour l'une et n° quelconque pour l'autre.

Peur justifiée.

Il faudrait envisager très sérieusement de mettre un transistor pour commander le relais et placer une diode de protection aux bornes du relais. Sinon l'arduino risque de ne pas survivre.

Rebonds :
Un informaticien te dira : mets un délai dans ton programme pour masquer les rebonds qui se voient de l'arduino.
Un électronicien te dira : mets un condensateur en parallèle de ton interrupteur, comme cela l'arduino ne verra pas les rebonds.
Un informaticien/électronicien te dira : le principe fondamental est d'éliminer les défauts le plus en amont possible donc comme le défaut est sur l'interrupteur commence par mettre un condensateur et si cela ne suffit pas joue avec les délais dans le programme.

Il n'y a pas si longtemps que ce sujet a été abordé :
http://arduino.cc/forum/index.php/topic,93760.0.html

Un informaticien te dira : mets un délai dans ton programme pour masquer les rebonds qui se voient de l'arduino.
Un électronicien te dira : mets un condensateur en parallèle de ton interrupteur, comme cela l'arduino ne verra pas les rebonds.

En fait c'est la même chose, dans les 2 cas c'est un filtrage temporel. Donc cela introduit du retard. Dans certains cas c'est gênant.
Le meilleur anti-rebond reste la bascule RS car il n'y a pas de retard sur la première transition. Mais il faut un poussoir (ou interrupteur) avec un contact repos et un contact travail.

Un petit traité sur le sujet.

En fait c'est la même chose, dans les 2 cas c'est un filtrage temporel

Oui et non.
Dans le post que je mentionne je suis intervenu pour bien faire la distinction entre les deux constantes de temps :

  • celle à la prise d'information qui est quasi nulle.
  • celle qui permet d'éliminer les rebonds et qui établie un temps mort entre deux prises d'information. Elle n'est plus négligeable, mais de part le principe elle reste généralement inférieure ou au pire égale à celle du filtrage "logiciel".

Dans le cas d'un filtrage "logiciel" la prise d'information n'est pas immédiate comme dans le cas d'un filtrage "électronique" ça peut avoir son importance.

Autre avantage de traiter le défaut "à la source" : les rebonds créent des impulsions qui génèrent des champs électromagnétiques, sources de polutions diverses. En fonction de la qualité du câblage ces champs peuvent être "promenés" là où il ne faudrait pas.

Alors autant ne pas commencer par se mettre des handicaps quand c'est si facile de l'éviter.