Gestion de la Temporisation

a marqué ce sujet comme résolu.

Bonjour et merci d'être venu lire ce message! Je viens faire appel à vous car j'ai besoin de votre aide, j'aimerai savoir comment rajouter une temporisation avant qu'une LED s’éteigne sans pour autant mettre une pause et ainsi freeze le programme.

si j'appuie sur mes BP qui remplissent les conditions la led MCC reste alimentée 5 seconde avant de s'éteindre. j'ai essayé avec un delay(5000); mais mon programme freeze entièrement pendant ces 5 secondes. Après cela, j'aimerai ajouter qu'a chaque fois que la variable etatOBS est activée, on incrémente 5 secondes de plus à cette temporisation. Merci d'avance pour la personne qui pourra me guider

+0 -0

grosso modo :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
#define SEUIL 5000

long montemps = 0

void loop() {
    if(millis()-montemps > SEUIL) {
        // ici 5 secondes se sont ecoulees depuis
        // le dernier passage au meme endroit
        montemps = millis();
        // ici il faut mettre le truc qui doit tourner toutes les 5 secondes
    }
    // le programme qui doit tourner tout le temps
}

C'est un peu brut de fonderie mais l’idée est la ;)

+0 -0

admettons que j'ai ce code, mon code revient au même : 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
//le bouton est connecté à la broche 2 de la carte Adruino
const int bouton = 2;
//la LED à la broche 13
const int led = 13;

//variable qui enregistre l'état du bouton
int etatBouton;

void setup()
{
    pinMode(led, OUTPUT); //la led est une sortie
    pinMode(bouton, INPUT); //le bouton est une entrée
    etatBouton = HIGH; //on initialise l'état du bouton comme "relaché"
}

void loop()
{
    etatBouton = digitalRead(bouton); //Rappel : bouton = 2

    if(etatBouton == HIGH) //test si le bouton a un niveau logique HAUT
    {
        digitalWrite(led,HIGH); //la LED reste éteinte
    }
    else  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
    {
        digitalWrite(led,LOW); //le bouton est appuyé, la LED est allumée
    }
}

je veux que lorsque j'appuie sur mon bouton la led reste allumé 5sec même si je lache le bouton. cependant il ne faut pas utiliser la fonction delay puisque dans le reste du programme, certaines choses doivent se faire

+0 -0 
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
//le bouton est connecté à la broche 2 de la carte Adruino
const int bouton = 2;
//la LED à la broche 13
const int led = 13;

//variable qui enregistre l'état du bouton
int etatBouton;

#define SEUIL 5000

long montemps = 0;
void setup()
{
    pinMode(led, OUTPUT); //la led est une sortie
    pinMode(bouton, INPUT); //le bouton est une entrée
    etatBouton = HIGH; //on initialise l'état du bouton comme "relaché"
}

void loop()
{
    etatBouton = digitalRead(bouton); //Rappel : bouton = 2

    if(etatBouton == HIGH) //test si le bouton a un niveau logique HAUT
    {
        digitalWrite(led,HIGH); //la LED reste éteinte
    }
    else  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
    {
      if(millis()-montemps > SEUIL) {
        // ici 5 secondes se sont ecoulees depuis
        // le dernier passage au meme endroit
        montemps = millis();
        // ici il faut mettre le truc qui doit tourner toutes les 5 secondes
      digitalWrite(led,LOW);} //le bouton est appuyé, la LED est allumée
    }
}
+0 -0

j'aurais une petite question par rapport à ce sujet. J'aimerais mettre 2 led contrôlées par 2 boutons différents. Je parviens à les allumer indépendamment, mais lorsqu'elles s'éteignent, elle s'éteignent toujours au même moment, ce qui n'est pas voulu…

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
const int bouton = 2;
const int bouton2 = 8;
const int led = 13;
const int led2 = 3;

//variable qui enregistre l'état du bouton
int etatBouton;
int etatBouton2;

#define SEUIL 15000

long montemps = 0;
long montemps2 = 0;

void setup()
{
    pinMode(led, OUTPUT); //la led est une sortie
    pinMode(bouton, INPUT); //le bouton est une entrée
    etatBouton = HIGH; //on initialise l'état du bouton comme "relaché"
     pinMode(led2, OUTPUT); //la led2 est une sortie
    pinMode(bouton2, INPUT); //le bouton2 est une entrée
    etatBouton2 = HIGH; //on initialise l'état du bouton2 comme "relaché"
}

void loop()
{
    etatBouton = digitalRead(bouton); //Rappel : bouton = 2
     etatBouton2 = digitalRead(bouton2); //Rappel : bouton =8

    if(etatBouton == HIGH) //test si le bouton a un niveau logique HAUT
    {
        digitalWrite(led,HIGH); //la LED reste éteinte
    }
    if(etatBouton ==LOW)  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
    {
      if(millis()-montemps > SEUIL) {
        // ici 15 secondes se sont ecoulees depuis
        // le dernier passage au meme endroit
        montemps = millis();

      digitalWrite(led,LOW);} //le bouton est appuyé, la LED est allumée
    }
   if(etatBouton == HIGH) //test si le bouton a un niveau logique HAUT
    {
        digitalWrite(led,HIGH); //la LED reste éteinte
    }


    if(etatBouton2 == HIGH) //test si le bouton a un niveau logique HAUT
    {
        digitalWrite(led2,HIGH); //la LED reste éteinte
    }
    if(etatBouton2 ==LOW)  //test si le bouton a un niveau logique différent de HAUT (donc BAS)
    {
      if(millis()-montemps2 > SEUIL) {
        // ici 15 secondes se sont ecoulees depuis
        // le dernier passage au meme endroit
        montemps2 = millis();

      digitalWrite(led2,LOW);} //le bouton est appuyé, la LED est allumée
    } 

}
+0 -0

Tu peux rappeler ce que tu attends exactement ?

Si tu veux juste allumer les LED quand les boutons sont pressés, il suffit de faire

1
2
3
4
5
void loop()
{
    digitalWrite(led,digitalRead(bouton));
    digitalWrite(led2,digitalRead(bouton2));
}

Ce n'est probablement pas ce que tu comptes faire, puisque tu cherches à gérer une temporisation.

+0 -0

j'aimerais contrôler deux led avec deux boutons, lorsque j’appuie sur bouton alors led s'allumera durant 5 secondes et lorsque j'appuie sur bouton2 alors led 2 s'allumera durant 5 seconde elle aussi, mais je veux pouvoir allumer les deux en même temps en utilisant millis(). Mon problème n'est pas de les allumer, mon problème c'est lorsqu'elles s'éteignent, elle le font en même temps même si les tempo n'ont pas été lancées au même moment.. Je ne sais pas si je l'explique bien, faites le moi savoir. merci

+0 -0

Dans ton code, les deux tempo n'ont aucune raison d'être liées.
Par contre, tu n'as pas écrit exactement le même code pour les deux led
Par commodité, je vais le réécrire avec un tableau (ça m'épargne le copié collé)

Je vais le modifier sensiblement (commentaires, types de données, …), en effet, je ne comprends rien au code, et les commentaires expriment le contraire de ce que tu viens de me décrire. (Et ils ne me semblent pas cohérents avec le code)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
#define NB_LED 2

//les boutons sont connectés aux broche 2 et 8 de la carte Adruino
const int bouton[NB_LED] = {2, 8};
//les LED aux broches 13 et 3
const int led[NB_LED] = {13, 3};
//dernier instant où on a vu le bouton pressé
unsigned long pression[NB_LED] = {0};

#define SEUIL 5000

void setup()
{
    int i; //un itérateur pour appliquer la fonction à chaque bouton
    for(i=0; i<NB_LED; i++)
    {
        pinMode(led[i], OUTPUT); //la led est une sortie
        digitalWrite(led[i],HIGH);
        pinMode(bouton[i], INPUT); //le bouton est une entrée
    }
}

void loop()
{
    int etatBouton;
    int i; //un itérateur pour appliquer la fonction à chaque bouton

    //On fait donc le même travail pour chaque LED
    for(i=0; i<NB_LED; i++)
    {
        etatBouton = digitalRead(bouton[i]); //On lit le bouton
        if(etatBouton == HIGH) //Si le bouton est pressé
        {
            //On allume la LED
            digitalWrite(led[i],LOW);
            //Et on retient la de la pression sur le bouton
            pression[i] = millis();
        }
        else //Le bouton est relâché
        {
            //Si le bouton n'a pas été pressé depuis SEUIL
            if((millis()-pression[i])> SEUIL)
            {
                //On éteint la LED
                digitalWrite(led[i],HIGH);
            }
            //Et sinon, on laisse la diode allumée, ou éteinte si on vient de lancer le programme
        }
    }
}

Je pense que tes problèmes sont, entre autres, liés au fait que tu utilises un int pour enregistrer les résultats de millis(), ce qui va te poser des problèmes dès 32s après le démarrage de l'arduino (sachant que tes tempos sont de 15s, tu vas vite tomber dans ce cas).

Dans l'ensemble, cependant, je pense que tu ne comprends pas vraiment ce que fait le programme. Evite de commenter en parlant d'état logique haut et bas, c'est déjà ce qui est écrit dans le code. Ne décrit pas le code, explique ce qu'il fait. Dans mon code, j'ai par exemple if(etatBouton == HIGH) //Si le bouton est pressé, le code dit "état logique haut", et le commentaire dit "bouton pressé". Si je me suis trompé, que la pin est à l'état bas quand le bouton est pressé, on s'en rend compte facilement, et c'est facile à corriger; en plus de ça, on comprends beaucoup mieux le comportement attendu, les réactions aux pressions sur les boutons, etc…

+0 -0

ton code ne présente pas deux boutons contrôlant indépendamment deux led, bouton1 contrôle led1 et bouton2 contrôle led 2, Tout mon code fonctionne bien lorsque je le test, les tempo commence au bon moment et tout, la seul chose qui cloche c'est lorsqu'elle s'éteignent. Peu importe quand je lâche bouton1 et bouton2, led1 et led2 s'éteignent au même moment.. Je suis assez nouveau dans le langage arduino et parfois je ne comprend pas très vite alors pardonné moimon ignorance :(

+0 -0
Connectez-vous pour pouvoir poster un message.
Connexion

Pas encore membre ?

Créez un compte en une minute pour profiter pleinement de toutes les fonctionnalités de Zeste de Savoir. Ici, tout est gratuit et sans publicité.
Créer un compte