Probleme avec la fonction millis()

Bonsoir à vous. Comment peut on mémoriser le temp actuel suite à l'appui d'un BP et passer à une Condition fausse si l'on ne reappui pas dans les 20sec suivante ? Merci d'avance

Avec millis() et une petite machine à état et la la librairie simpleBouton de @bricoleau
:slight_smile:

if (bouton) {
  chrono = millis();
  etat = ATTENTE;
}
if (conditionMagique) etat = REPOS;
if ((etat == ATTENTE) && (millis()-chrono >= 20000ul)) {
  // bingo déclencher 
  etat = REPOS;
}

Lis le tuto d'Eskimon tu devrai y trouver la réponse.
Le lien vers le tuto est dans le message épinglé "Règles du forum francophone"

Il y a aussi l'exemple arduino Blink without delay.

C'est une question assez classique, tu trouveras plein de tutos sur le sujet des codes non bloquants. Voici le principe

  • tu déclares une variable "chrono" par exemple. Comme elle stockera le contenu de millis() autant la déclarer de type unsigned long
  • tu déclares ton bouton, tu peux le faire en INPUT_PULLUP pour éviter d'ajouter une résistance. Dans ce cas, il renverra un LOW s'il est appuyé
  • tu lis l'état du bouton, dès que tu lis un LOW :
  • tu initialises la variable chrono avec millis(), c'est à dire que tu lances le chrono
  • tu "débounces" avec un delay(30); ça permet d'attendre la fin des rebonds du ressort du bouton qu'il ne faut pas prendre pour d'autres appuis
  • tant que le chrono est inférieur à ta durée (20000 pour ton cas), tu lis l'état du bouton
  • si l'état passe à LOW ta condition est vraie tu sors de cette boucle
  • si à la fin du temps l'état est resté HIGH, ta condition est fausse
    Je pense que le plus simple serait de mettre les étapes 3 à 8 dans une fonction qui renvoie un booléen (la condition true ou false) ce qui te permet de sortir de la boucle directement avec un return

Si ton objectif est de faire d'autres choses pendant l'attente de 20 secondes, tu peux les faire aussi par un ou des appels de fonction(s), mais il faut faire attention que ces fonctions ne durent pas trop longtemps elles-mêmes pour ne pas empêcher de détecter l'appui sur le bouton.

Commence déjà par coder ça...

EDIT : Damned! grillé par J-M-L et 68tjs...

On lui a tous répondu la même chose en gros :slight_smile:

allez, à mon tour de proposer la même chose :stuck_out_tongue:

#include "yasm.h"
#include "btn.h"

const byte pinBouton = 5; //bouton poussoir entre la broche 5 et le GND
const byte pinLed = 13; //il y a deja une led sur la carte sur cette broche

BTN bouton;
YASM temporisation;

void setup()
{
  pinMode(pinBouton, INPUT_PULLUP);
  pinMode(pinLed, OUTPUT);

  temporisation.next(tempo_attente);
}

void loop()
{
  bouton.update(!digitalRead(pinBouton));
  temporisation.run();
}

//états de la machine "temporisation"
void tempo_attente()
{
  if (bouton.state(BTN_CLICK))
    //si le bouton est appuyé, on rentre dans la temporisation :
    temporisation.next(tempo_chrono);
}

void tempo_chrono()
{
  if (bouton.state(BTN_CLICK))
  {
    //si le bouton est apppuyé dans les 20s, on change l'état de la led :
    digitalWrite(pinLed, !digitalRead(pinLed));
    //et on retrourne en attente :
    temporisation.next(tempo_attente);
  }

  if (temporisation.elapsed(20000))
    //si 20 secondes se sont écoulées, on retourne en attente
    temporisation.next(tempo_attente);
}

avec la librairie yasm

const int moteur1 = 53;     //moteur BONUS
const int resetPin = 12;    //pin reset apres BONUS
const int led1 = 22;    //vert             pin led BONUS
const int led2 = 23;    
const int led3 = 24;    
const int led4 = 25;    
const int led5 = 26;    
const int led6 = 27;    
const int led7 = 28;    
const int led8 = 29;    
const int led9 = 30;    
const int led10 = 31;   
const int led11 = 32;   
const int led12 = 33;   
const int led13 = 34;   
const int led14 = 35;
const int led15 = 36;
const int led16 = 37;
const int led17 = 38;
const int led18 = 39;   //bleu
const int led19 = 40;   //blanc
const int led20 = 41;
const int led21 = 42;
const int led22 = 43;
const int led23 = 44;
const int led24 = 45;   //blanc
const int led25 = 46;   //rouge
const int led26 = 47;
const int led27 = 48;
const int led28 = 49;
const int led29 = 50;
const int led30 = 51;   //rouge

const int btn_plus = 13;      //capteur piece inserer

int memoire_plus = LOW;       //memoire insertion piece
int nombre_led = 0;           //constante nombre led
int etat_bouton;              //constante etat capteur piece
long tempsReference;
long tempsActuel;

void setup() {
  tempsActuel = millis();
  pinMode(moteur1, OUTPUT);   //moteur en pin sortie
  pinMode(resetPin, OUTPUT);  //reset en pin sortie
  pinMode(led1, OUTPUT);      //led en pin sortie
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);      //led en pin sortie
  pinMode(led5, OUTPUT);
  pinMode(led6, OUTPUT);
  pinMode(led7, OUTPUT);      //led en pin sortie
  pinMode(led8, OUTPUT);
  pinMode(led9, OUTPUT);
  pinMode(led10, OUTPUT);      //led en pin sortie
  pinMode(led11, OUTPUT);
  pinMode(led12, OUTPUT);
  pinMode(led13, OUTPUT);      //led en pin sortie
  pinMode(led14, OUTPUT);
  pinMode(led15, OUTPUT);
  pinMode(led16, OUTPUT);      //led en pin sortie
  pinMode(led17, OUTPUT);
  pinMode(led18, OUTPUT);
  pinMode(led19, OUTPUT);      //led en pin sortie
  pinMode(led20, OUTPUT);
  pinMode(led21, OUTPUT);
  pinMode(led22, OUTPUT);      //led en pin sortie
  pinMode(led23, OUTPUT);
  pinMode(led24, OUTPUT);
  pinMode(led25, OUTPUT);      //led en pin sortie
  pinMode(led26, OUTPUT);
  pinMode(led27, OUTPUT);
  pinMode(led28, OUTPUT);      //led en pin sortie
  pinMode(led29, OUTPUT);
  pinMode(led30, OUTPUT);


  pinMode(btn_plus, INPUT);   //capteur piece en pin sortie
}

void loop() {


  etat_bouton = digitalRead(btn_plus);                                //lecture etat capteur piece


  if ((etat_bouton != memoire_plus) && (etat_bouton == LOW))           // condition si etat capteur different ET etat capteur bas
  { nombre_led++;                                                     //on allume une led
    delay(100);                                                       //delai 100ms
    tempsActuel - 10000;
  }
  if (etat_bouton, HIGH) {
    (tempsActuel = millis());
  }
  if (millis() >= 10000) {
    digitalWrite(resetPin, HIGH);
  }

  memoire_plus = etat_bouton;
  if (nombre_led == 30) {                                              //si nombre led et egale a 30
    delay(50);
**chenillard**dsl code trop long
  if (valeur_recue >= 1) {
    digitalWrite(led1, HIGH);
  }

  if (valeur_recue >= 2) { 
    digitalWrite(led2, HIGH);
  }

  if (valeur_recue >= 3) {
    digitalWrite(led3, HIGH);
  }

  if (valeur_recue >= 4) {
    digitalWrite(led4, HIGH);

  }

  if (valeur_recue >= 5) {
    digitalWrite(led5, HIGH);
  }

  if (valeur_recue >= 6) {
    digitalWrite(led6, HIGH);
  }

  if (valeur_recue >= 7) {
    digitalWrite(led7, HIGH);
  }

  if (valeur_recue >= 8) {

    digitalWrite(led8, HIGH);
  }

  if (valeur_recue >= 9) {

    digitalWrite(led9, HIGH);
  }

  if (valeur_recue >= 10) {

    digitalWrite(led10, HIGH);
  }

  if (valeur_recue >= 11) {

    digitalWrite(led11, HIGH);
  }

  if (valeur_recue >= 12) {

    digitalWrite(led12, HIGH);
  }
  if (valeur_recue >= 13) {

    digitalWrite(led13, HIGH);
  }

  if (valeur_recue >= 14) {

    digitalWrite(led14, HIGH);
  }

  if (valeur_recue >= 15) {

    digitalWrite(led15, HIGH);
  }

  if (valeur_recue >= 16) {

    digitalWrite(led16, HIGH);
  }

  if (valeur_recue >= 17) {

    digitalWrite(led17, HIGH);
  }

  if (valeur_recue >= 18) {

    digitalWrite(led18, HIGH);
  }

  if (valeur_recue >= 19) {

    digitalWrite(led19, HIGH);
  }

  if (valeur_recue >= 20) {

    digitalWrite(led20, HIGH);
  }

  if (valeur_recue >= 21) {

    digitalWrite(led21, HIGH);
  }

  if (valeur_recue >= 22) {

    digitalWrite(led22, HIGH);
  }

  if (valeur_recue >= 23) {

    digitalWrite(led23, HIGH);
  }

  if (valeur_recue >= 24) {

    digitalWrite(led24, HIGH);
  }
  if (valeur_recue >= 25) {

    digitalWrite(led25, HIGH);
  }

  if (valeur_recue >= 26) {

    digitalWrite(led26, HIGH);
  }

  if (valeur_recue >= 27) {

    digitalWrite(led27, HIGH);
  }

  if (valeur_recue >= 28) {

    digitalWrite(led28, HIGH);
  }

  if (valeur_recue >= 29) {

    digitalWrite(led29, HIGH);
  }

  if (valeur_recue >= 30) {
    digitalWrite(led30, HIGH);
  }
}

merci a vous tous
en fait j’ai deja essayer au moins 500 solutions mdr
je vous ai mis le code afin d’essayer de me comprendre, bon c’est un code de debutant je ne vous dit pas la galere et tous se que vous allez me repprocher mdr
si vous arrivez a me decrypter je souhaiterais que a chaque pression du bp je retourne avec un temps de 10secondes sinon les 30 led s’eteigne.

j’ai essayer en vain depuis 3 jours mais plus j’essaye plus je me perd… je deviens fou :o :o mdr

Des trucs comme cela, ça n’est pas super.

  if (etat_bouton, HIGH) {
    (tempsActuel = millis());
  }
  if (millis() >= 10000) {
    digitalWrite(resetPin, HIGH);
  }

et on ne sais pas ce qu’est valeur_recue…

On dirait que vous tapez un peu n’importe quoi au petit bonheur… (c’est pas une critique personnelle, on a tous commencé quelque part)

si vous commenciez par le commencement: Que cherchez vous à faire comme projet ?

j'ai fait un coin pusher et souhaite ajouter un bonus apres avoir inserer 30 pieces.
donc j'ai bien mon barregraph qui fonctionne correctement ainsi que le reset de la carte Arduino commander par relais connecter au pin 12. par contre je souhaiterais mettre une condition que si une piece n'est pas inserer dans un delai de 20secondes apres la precedente on retoune a zero. j'espere que vous comprendrez mon charabiat :slight_smile: :slight_smile:
j'avous que quelques lignes vont etre a supprimer j'ai essayer de prendre exemple sur plusieurs tuto mais impossible de reussir ...

Il faut que tu te renseignes sur les boucles for et sur les tableaux. ça te permettra de vraiment simplifier ton code.

Par exemple, ceci

const int led1 = 22;    //vert             pin led BONUS
const int led2 = 23;    
const int led3 = 24;    
const int led4 = 25;    
const int led5 = 26;    
const int led6 = 27;    
const int led7 = 28;    
const int led8 = 29;    
const int led9 = 30;    
const int led10 = 31;   
const int led11 = 32;   
const int led12 = 33;   
const int led13 = 34;   
const int led14 = 35;
const int led15 = 36;
const int led16 = 37;
const int led17 = 38;
const int led18 = 39;   //bleu
const int led19 = 40;   //blanc
const int led20 = 41;
const int led21 = 42;
const int led22 = 43;
const int led23 = 44;
const int led24 = 45;   //blanc
const int led25 = 46;   //rouge
const int led26 = 47;
const int led27 = 48;
const int led28 = 49;
const int led29 = 50;
const int led30 = 51;   //rouge

...

  pinMode(led1, OUTPUT);      //led en pin sortie
  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);
  pinMode(led4, OUTPUT);      //led en pin sortie
  pinMode(led5, OUTPUT);
  pinMode(led6, OUTPUT);
  pinMode(led7, OUTPUT);      //led en pin sortie
  pinMode(led8, OUTPUT);
  pinMode(led9, OUTPUT);
  pinMode(led10, OUTPUT);      //led en pin sortie
  pinMode(led11, OUTPUT);
  pinMode(led12, OUTPUT);
  pinMode(led13, OUTPUT);      //led en pin sortie
  pinMode(led14, OUTPUT);
  pinMode(led15, OUTPUT);
  pinMode(led16, OUTPUT);      //led en pin sortie
  pinMode(led17, OUTPUT);
  pinMode(led18, OUTPUT);
  pinMode(led19, OUTPUT);      //led en pin sortie
  pinMode(led20, OUTPUT);
  pinMode(led21, OUTPUT);
  pinMode(led22, OUTPUT);      //led en pin sortie
  pinMode(led23, OUTPUT);
  pinMode(led24, OUTPUT);
  pinMode(led25, OUTPUT);      //led en pin sortie
  pinMode(led26, OUTPUT);
  pinMode(led27, OUTPUT);
  pinMode(led28, OUTPUT);      //led en pin sortie
  pinMode(led29, OUTPUT);
  pinMode(led30, OUTPUT);

peut s’écrire

byte ledNumber[30];
for (byte i=0; i<30;i++) {
  ledNumber[i] = i+22;
  pinMode(led[i],OUTPUT); }

De même avec ta suite de tests sur valeur_recue :

for (byte i=30;i>=1;i--) if (valeur_recue >= i) digitalWrite(ledNumber[i-1], HIGH);

Une seule ligne pour en remplacer 120 !

ah d'accord… merci bien :wink:
c'est clair que je peut déjà gagner 1heure par boucle… j'en serais déjà a 4heures en moins mdr.
Je modifis sa et continu mes recherches de tuto sur le chrono pour ce fameux bonus

{
  if ((etat_bouton != memoire_plus) && (etat_bouton == LOW))           // condition si etat capteur different ET etat capteur bas
  { nombre_led++;                                                     //on allume une led
    delay(100);                                                       //delai 100ms
}}
if(etat_bouton = HIGH){
  chrono = millis();
  delay(30);
}
if(etat_bouton = HIGH){
  millis()=(chrono-10000);
}
if(chrono>=10000){
  digitalWrite(resetPin,HIGH);
}

j'ai essayer de passer avec le chrono par contre j'ai un autre petit soucis :confused:
le chrono ne se remet pas a zero lors de chaque appui sur le bp donc dès que j'ai passer les 10sec de demarrage(plus rapide que 20 pour les test) lors de l'appui suivant l'arduino se reset pouvez vous m'orienter sur mon beug lol

Ooopsif(etat_bouton = HIGH){-->Ne pas confondre comparaison d'égalité et assignation (== versus =)

re-oooops   millis()=(chrono-10000);-->Une fonction retourne une valeur, on n'affecte pas du contenu à une valeur, mais à une variable

olala je devient fous les gars ptdrrr

if((etat_bouton, HIGH)&&(nombre_led>=1)){
  chrono = millis();
  delay(30);
}
if(etat_bouton, HIGH){
  millis()==(chrono-10000);
}

j'ai modifié pour l'etat du bouton j'espere avoir bon lol
par contre j'ai ajouter le nombre_led>=1 pour eviter le reset si 0 led allumer (j'espere toujours avoir bon…) par contre je reste completement bloquer pour le nouveau depart a chaque appui :confused: :confused:

Bonjour,

if(etat_bouton, HIGH) est évalué comme HIGH et est toujours vrai
Je suppose que ce que tu veux faire est if(etat_bouton==HIGH)

et aussi le soucis avec   millis()==(chrono-10000); qui ne veut rien dire de vraiment particulier... c'est un test dont on ne se sert pas du résulat donc le compilateur va le virer purement et simplement :slight_smile:

le probleme est que je ne sais pas comment remettrre le chrono a zero a chaque appui...donc jessayer de soustraire le temp depuis le dernier appui. étant electricien je pense je vais mettre une minuterie mecanique :slight_smile: :slight_smile: mdrrr

On ne remet pas millis() à zéro - on le laisse compter mais on doit se souvenir du dernier moment où on a appuyé et comparer avec le moment courant.

voilà une structure de code qui pourrait vous convenir sans doute (tapé ici, je ne sais pas si ça compile ni si ça fonctionne - en utilisant la gestion des boutons par la librairie de @bricoleau)

#include <simpleBouton.h>

const uint8_t moteur1 = 53;   //moteur BONUS
const uint8_t resetPin = 12;  //pin reset apres BONUS
const uint8_t pinLedsDebut = 22;
const uint8_t pinLedsFin = 51;
const uint8_t nombreDeLeds = pinLedsFin - pinLedsDebut + 1;
uint8_t nombreLedAllumees = 0;           //nombre led allumées
unsigned long chrono = 0;
const unsigned long attenteMaxPieceSuivante = 20000ul; // 20 secondes en millisecondes

const uint8_t plusPin = 13;  //capteur piece inserée
simpleBouton boutonPlus(plusPin);//Cablage : pin---BP---GND

void eteindreLEDs()
{
  for (uint8_t ledPin = pinLedsDebut; ledPin <= pinLedsFin; ledPin++)   pinMode(ledPin, LOW);
  nombreLedAllumees = 0;
}

void setup() {
  pinMode(moteur1, OUTPUT);   //moteur en pin sortie
  pinMode(resetPin, OUTPUT);  //reset en pin sortie
  for (uint8_t ledPin = pinLedsDebut; ledPin <= pinLedsFin; ledPin++)   pinMode(ledPin, OUTPUT);      //led en pin sortie
  eteindreLEDs();
}

void loop() {

  if (boutonPlus) {  // on vient d'appuyer sur le bouton (insérer une pièce)
    chrono = millis(); // on se souvient qu'on a fait une action à ce moment
    pinMode(pinLedsDebut + nombreLedAllumees, HIGH); // on allume la LED qui va bien
    nombreLedAllumees++; // on augmente le nombre de LEDs allumées

    // traiter ce que doit faire l'ajout d'une pièce
    // ----------------------------
    // >>>>> VOTRE CODE ICI <<<<<<
    // ----------------------------

    //  est-on arrivé au nombre max de LEDs ?
    if (nombreLedAllumees >= nombreDeLeds) {
      // faire ce qu'il faut, animation etc
      // ----------------------------
      // >>>>> VOTRE CODE ICI <<<<<<
      // ----------------------------

      // puis on éteint toutes les LEDs
      eteindreLEDs();
    } else {// on n'est pas encore arrivé au nombre max de LEDs
      // y-a-t-il quelque chose à faire dans ce cas?
      // ----------------------------
      // >>>>> VOTRE CODE ICI <<<<<<
      // ----------------------------
    }
  }

  // testons si on n'a pas rajouté de pièces depuis un certain temps ?
  if (nombreLedAllumees && (millis() - chrono >= attenteMaxPieceSuivante)) {

    // ----------------------------
    // >>>>> VOTRE CODE ICI <<<<<<
    // ----------------------------

    // puis on éteint toutes les LEDs
    eteindreLEDs();
  }

  // ici on peut faire autre chose

}
if (boutonPlus) {  // on vient d'appuyer sur le bouton (insérer une pièce)
    chrono = millis(); // on se souvient qu'on a fait une action à ce moment
    pinMode(pinLedsDebut + nombreLedAllumees, HIGH); // on allume la LED qui va bien
    nombreLedAllumees++; // on augmente le nombre de LEDs allumées

    // traiter ce que doit faire l'ajout d'une pièce
    // ----------------------------
    // >>>>> VOTRE CODE ICI <<<<<<

merci beaucoup pour votre patience
:slight_smile:
si je comprend bien vous avez retaper tout le texte en entier?

par contre comme dans ce morceau " votre code ici" a la base il faut juste augmenter le nombre de led allumees mais comme il et déjà ajouté au dessus j’ai pas besoin de le remettre ici??

void loop() {
etat_bouton = digitalRead(btn_plus);                                //lecture etat capteur piece


  if ((etat_bouton != memoire_plus) && (etat_bouton == LOW))           // condition si etat capteur different ET etat capteur bas
  { nombre_led++;                                                     //on allume une led
    delay(100);                                                       //delai 100ms
chrono = millis();

}
if((nombre_led>=1)&&(millis() - chrono >= attenteMaxPieceSuivante)){  
  digitalWrite(resetPin,HIGH);
}

bon se fut avec beaucoup de maux de tete et beaucoup de votre aide que ce code fonctionne :slight_smile: :slight_smile:
merci beaucoup a J.M.L pour votre aide en prenant votre AttenteMaxPieceSuivante que j'ai reussi je vais enfin pouvoir tous mettre dans le coin pusher encore merci :wink: