---Appui long sur bouton---

Coucou
j'ai une question toute bête... je voudrais pouvoir appuyer sur un bouton, au bout de 20 secondes d'appui, une sortie passe à l'état haut le temps de quelques secondes puis retombent à l'état bas.
Voilà c'est tout bête mais je bloque.
Merci d'avance

Studio88:
Coucou
j’ai une question toute bête… je voudrais pouvoir appuyer sur un bouton, au bout de 20 secondes d’appui, une sortie passe à l’état haut le temps de quelques secondes puis retombent à l’état bas.
Voilà c’est tout bête mais je bloque.
Merci d’avance

bonjour
Alors fait voir le code que surement tu aura déjà fait pour essayé de resoudre ton probleme :grin:

Hé bien justement je n'en ai pas vraiment fais, j'ai testé plusieurs morceaux de codes piochés à droite à gauche mais cela ne donne rien, je suis un peu perdu voilà pourquoi je voudrais reprendre tout à zéro.

Il faudrait regarder de ce cote http://arduino.cc/en/Reference/Millis
millis permet de faire des mesures de temps sans bloquer l’exécution du programme.
Donc ton loop pourrait ressembler à quelques chose comme ça:

attendre un appui sur le bouton
si le bouton est appuyé mémoriser le temps actuel
boucler
   lire l'état du bouton
   calculer le temps écoulé
tant (que temps écoulé<20s et bouton==appuyé)
si bouton appuyé
  allumer la LED
  attendre le temps nécessaire
éteindre la LED

En version simple, si l'arduino n'a rien d'autre à faire pendant ce temps-là, car cet exemple bloque le déroulement de loop pendant les attentes.

Pour des actions non-bloquantes c'est presque pareil sauf qu'il faut détecter les changement d'états des boutons, et sur un front montant mémoriser le temps courant, puis à chaque itération de loop si le bouton est toujours appuyé, comparer le temps courant avec ce qu'on a précédemment mémorisé.

C'est en gros comme ça que je procède, sauf que je mesure le temps en comptant le nombre d'exécutions de ma fonction loop() (car elle tourne lentement et que j'ai des actions qui s'exécutent toutes les x, y ou z itérations).

Merci de votre aide !
Alors en utilisant vos conseils et un sketch trouvé sur le net, j'ai plus ou moins réussi à obtenir ceci:

int temps_defini = 2000;   
int ledPin     = 6;       
int boutonPin  = 10;      

unsigned long debut_appui;
boolean variable = false;
int etat_bouton;
int dernier_etat_bouton = LOW;
int etat_led = LOW;

void setup() {
pinMode(ledPin, OUTPUT);      
pinMode(boutonPin, INPUT);    
}



void loop(){
  
   etat_bouton = digitalRead(boutonPin);            
  
   
   
   if (etat_bouton == HIGH && dernier_etat_bouton == LOW){      
   debut_appui = millis();                                      
   variable = true;                                           
   }
   
   
   if ( variable == true && etat_bouton == HIGH &&  dernier_etat_bouton == HIGH){    
                                                                                  
     if ((millis() - debut_appui) >= temps_defini){                                             
     etat_led = HIGH;                                                          
     
     if(etat_bouton == LOW && etat_led == HIGH && dernier_etat_bouton == HIGH){
     etat_led = LOW;
     variable = true;}}
                          
}
dernier_etat_bouton = etat_bouton;  
digitalWrite(ledPin, etat_led);
}

En gros je veux:
Appuyer sur le bouton, au bout de X secondes la led s'allume (pour l'instant en continu, ( la tempo d'allumage sera gérée par la suite), et à tout moment dès que je relâche le bouton la led doit s'éteindre.

Pour l'instant, avec ce code, j'appuie...après X secondes la led s'allume mais quand je relâche le bouton la led ne s'éteint pas.

Je suis débutant dans la programmation Arduino, merci d'être indulgent et me dire ou je "merdouille".

Merci à vous.

La condition qui teste le relâché du bouton
if(etat_bouton == LOW && ....
se trouve elle même dans un if qui n'est activé que si le bouton est appuyé donc la condition n'est jamais remplie. Il faut déplacer ce bloc de code à l'extérieur du
if ( variable == true && etat_bouton == HIGH && dernier_etat_bouton == HIGH)

Je pense aussi qu'il faudrait mettre variable à false lorsque tu détectes le relâché le bouton.

J'ai déjà essayé et cela ne change rien, j'appui...la led s'allume mais ne s'éteint pas à la relâche du bouton.

Je viens d'essayer toutes les combinaisons possible... impossible je n'y arrive pas ca me rend marteau. La relache du bouton n'est pas prise en compte... moi pas comprendre.

Le code modifié !!

int temps_defini = 2000;
int ledPin = 6;
int boutonPin = 10;

unsigned long debut_appui;
boolean variable = false;
int etat_bouton;
int dernier_etat_bouton = LOW;
int etat_led = LOW;

void setup() {
pinMode(ledPin, OUTPUT);
pinMode(boutonPin, INPUT);
}

void loop(){

etat_bouton = digitalRead(boutonPin);

if (etat_bouton == HIGH && dernier_etat_bouton == LOW){
debut_appui = millis();
variable = true;
}

if ( variable == true && etat_bouton == HIGH && dernier_etat_bouton == HIGH){

if ((millis() - debut_appui) >= temps_defini){
etat_led = !etat_led;
delay(10);
if(etat_bouton!=dernier_etat_bouton){
etat_led=!etat_led;
}
}

}
dernier_etat_bouton = etat_bouton;
digitalWrite(ledPin, etat_led);
}

Voilà le code que j'ai plus ou moins reussi à obtenir au mieux.
Cela fonctionne, sauf que ... voilà ca qui se passe:

Bouton appuyé
...tempo 2sec...
LED alumée (bouton toujour appuyé)
puis 2 cas :
-relache bouton APRES 2sec d'allumage LED, la LED s'éteint
-relache bouton APRES 2sec d'allumage LED, la LED reste alumée (voir même s'allume plus fort).

On dirait que quand le bouton est appuyé il comptabilise les cycles de 2sec... 2 sec...2sec...etc.... et si je relâche le bouton entre 2 "bons" cycles cela fonctionne la LED s'éteint, sinon elle reste allumée.
Il faudrait pouvoir stopper le comptage du temp d'appui une fois la LED allumée.
J'espère me faire comprendre.

Bonjour,

je cherchais à faire presque la même chose et avec un ami nous avons fait ceci.
Cela fonctionne sous VBB et je crois qu'il faut remplacer "long debut_appui1" par "unsigned long debut_appui1" pour le passer sur une carte.

Je suis débutant et ne saurais dire la différence avec les codes présentés ci-dessus, mais je pense que ça peut répondre au pb.

D.

public class Class extends Arduino {

int temps_defini = 5000; //définition du temps de maintien désiré en ms
int ledPin1 = 13;
int boutonPin1 = 2;
long debut_appui1;
boolean variable1 = false;
int etat_bouton1;
int dernier_etat_bouton1 = LOW;
int etat_led1 = LOW;

public void setup() {

pinMode(ledPin1, OUTPUT);
pinMode(boutonPin1, INPUT);
}

public void loop() {

etat_bouton1 = digitalRead(boutonPin1); //lecture de l'état des boutons

if (etat_bouton1 == HIGH && dernier_etat_bouton1 == LOW){ //détection de l'appui sur le bouton 1
debut_appui1 = millis(); //initialisation du compteur 1
variable1 = true; //enregistrement du changement d'état du bouton 1
}

if ( variable1 == true && etat_bouton1 == HIGH && dernier_etat_bouton1 == HIGH){ //le bouton 1 était et est toujours appuyé

if ((millis() - debut_appui1) >= temps_defini){ //est-ce que le temps choisi est écoulé ?
etat_led1 = HIGH; //déclaration d'allumage de la led 1

}
}

if (etat_bouton1 == LOW){ //extinction de la led 1 si le bouton est relaché
etat_led1 = LOW;
}

dernier_etat_bouton1 = etat_bouton1; //actualisation de l'état du bouton
digitalWrite(ledPin1, etat_led1); //allumage physique de la led

}
}

yop yop, je pense que le pote de Droopaille c'est moi,

pour le charger sur un arduino le code est:
Droopaille test sur emulateur donc son code n'est pas tout à fait le meme, il ne faut pas ecrire public avant un void, si tu veux changer le temps que ta led reste allumer il faut modifier le delay.

 int temps_defini = 5000;   //définition du temps de maintien désiré en ms
   int ledPin1 = 6;       
   int boutonPin1 = 2;
   long debut_appui1;
   boolean variable1 = false;
   int etat_bouton1;
   int dernier_etat_bouton1 = LOW;
   int etat_led1 = LOW;


   void setup()   {   
   
      pinMode(ledPin1, OUTPUT);     
      pinMode(boutonPin1, INPUT);
   }

   
   void loop()   {

      etat_bouton1 = digitalRead(boutonPin1);                        //lecture de l'état des boutons
         
      if (etat_bouton1 == HIGH && dernier_etat_bouton1 == LOW){      //détection de l'appui sur le bouton 1
         debut_appui1 = millis();                                   //initialisation du compteur 1
         variable1 = true;                                          //enregistrement du changement d'état du bouton 1
      }
   
   
      if ( variable1 == true && etat_bouton1 == HIGH && dernier_etat_bouton1 == HIGH){    //le bouton 1 était et est toujours appuyé
                                                                                 
         if ((millis() - debut_appui1) >= temps_defini){             //est-ce que le temps choisi est écoulé ?                                 
            etat_led1 = HIGH;                              //déclaration d'allumage de la led 1 
            delay(2000);
         }             
      }
      
      if (etat_bouton1 == LOW){                              //extinction de la led 1 si le bouton est relaché
         etat_led1 = LOW;
      }
      
      dernier_etat_bouton1 = etat_bouton1;                       //actualisation de l'état du bouton
      digitalWrite(ledPin1, etat_led1);                        //allumage physique de la led
 
   }