Bonsoir.
Je cherche à faire un truc bizarre : je souhaite une formule magique ou un tuto concernant l'utilisation d'un BP.
J'explique:
J'appuie sur le bouton la LED s'allume et reste allumée même si je réappuie sur le BP, elle ne peut s'éteindre que via un reset manuel.
Je trouve une foultitude de scripts sur le toggle mais rien sur mon système, j'avoue que je ne sais pas comment faire.
Si vous avez une astuce ou un tuto, il est le bienvenue.
Ce systeme sera utilisé pour une alarme ou l'orsqu'une alarme se déclenche une led s'allume et reste allumée même alarme terminée, seul un reset (arret alarme) manuel peut l'éteindre.
// En global ou alors en variable static si dans une fonction
bool alarme = false;
// dans ta loop()
alarme = alarme || (digitalRead(MA_PIN_ENTREE_ALARME) == ETAT_ACTIF)
alarme restera true tant que tu ne forceras pas la variable à false et que MA_PIN_ENTREE_ALARME sera dans l'état ETAT_ACTIF.
Si MA_PIN_ENTREE_ALARME n'est que fugitivement dans ETAT_ACTIF cet état sera mémorisé.
Par contre, ce serait bien de poster les questions dans la racine du forum francophone. Le sous-forum "Tutoriels et Cours" est réservé aux "Tutoriels et Cours".
Fil de discussion déplacé au bon endroit
int etat_alarme = 0; // variable pour l'état de l'alarme 0 - pas d'alarme 1 - allarme declancher
int BP = 2; // bouton poussoir de l'alarme
int reset = 3; // bouton poussoir de reset
int LED = 4; // LED de l'alarme
void setup() {
pinMode(BP, INPUT_PULLUP); // BP est en entrée
pinMode(reset, INPUT_PULLUP); // reset est en entrée
pinMode(LED, OUTPUT); // la LED est en sortie
}
void loop() {
if( digitalRead(BP) == LOW ){ // si la valeur de BP est de LOW alors :
etat_alarme = 1; // activer l'alarme
}
if( digitalRead(reset) == LOW ){ // si la valeur de reset est LOW alors
etat_alarme = 0; // couper l'alarme
}
digitalWrite(LED, etat_alarme); // mettre la LED a l'état de l'alarme
}
Dans ce code, quand vous appuyez sur le bouton de l'alarme, l'alarme s'active, et la led s'allume.
L'alarme et donc la led reste allumé jusqu'à ce que vous appuyez sur le bouton reset.
Pour être complet, il faudrait aussi respecter HIGH et LOW pour le digitalWrite
digitalWrite(LED, etat_alarme == 0 ? LOW : HIGH); // mettre la LED a l'état de l'alarme
L'approche proposée par @guillaume_lrt est ce qu'on appelle une machine à état.
Vous vous souvenez de l'état dans lequel vous êtes (ici par la variable etat_alarme) et vous avez des commandes et changement d'état qui sont déclenchées sur certains évènements (appui sur les boutons, détection, ...)
c'est une approche qu'il convient de maîtriser car elle est très utile pour de nombreux projets, cf mon tuto éventuellement.
PS/
c'est plus cosmétique qu'autre chose mais le code de @guillaume_lrt gagnerait en lisibilité en utilisant un peu plus les types en C++, un nommage en camelCase, et en effectuant l'action uniquement lors de la réception de l'évènement plutôt qu'à chaque tour de loop.
Avec l'approche de mon tuto, ça donnerait un truc comme cela (tapé ici donc il y a peut être des typos)
const byte brocheBP = 2; // broche du bouton poussoir de l'alarme
const byte brocheReset = 3; // broche du bouton poussoir de reset
const byte brocheLED = 4; // broche de la LED de l'alarme
enum : byte {ALARME_OFF, ALARME_ON} etatAlarme = ALARME_OFF; // variable pour l'état de l'alarme
void setup() {
pinMode(brocheBP, INPUT_PULLUP); // BP est en entrée
pinMode(brocheReset, INPUT_PULLUP); // reset est en entrée
pinMode(brocheLED, OUTPUT); // la LED est en sortie
}
void loop() {
switch (etatAlarme) {
case ALARME_OFF: // l'alarme est désactivée, on regarde si elle s'active
if ( digitalRead(brocheBP) == LOW ) { // si déclenchement
digitalWrite(brocheLED, HIGH); // on allume la LED
etatAlarme = ALARME_ON;
}
break;
case ALARME_ON: // l'alarme est activée, on regarde si reset est appuyé
if ( digitalRead(brocheReset) == LOW ) { // si on désarme
digitalWrite(brocheLED, LOW); // on éteint la led
etatAlarme = ALARME_OFF;
}
break;
}
}
qui est sans doute plus extensible et (je trouve) plus facile à lire car on voit bien le traitement effectué en fonction de l'état en cours.
