Partage
  • Partager sur Facebook
  • Partager sur Twitter

Arduino,Gestion d'éclairage

appuie long/court sur bouton

Sujet résolu
    31 octobre 2012 à 18:24:34

    Bonjour a tous,

    j'aurai besoin de quelque lumière de personne qui s'y connaissent mieux que moi =p
    J'ai eu comme projet de domotique au lycée , avec une carte arduino, de faire de la gestion d'éclairage.
    Principe:
    - bp
    -une carte arduino
    -un relais
    -une lampe
    -deux led

    -L'appuis normal sur le bp allume la lampe pendant un temps donné ( comme une lumière normale)
    -programation du temps donné:

    Un appuis Supérieur ou égale à 2s programme le temps d'allumage de la lampe de 5 min
    un appuis supérieur ou égale à 5s programme le temps d'allumage de la lampe de 10 min

    deux led temoin (une pour 5 min , la deuxieme pour 10min)


    Mon problème est :
    je n'arrive pas à compter le temp a partir de l'appuis sur le bp,
    car après selon le temp mesurer je stock dans des variables le temp d'allumage de la lampe,
    de plus y aurai-t-il un autre moyen de laisser allumer la lampe pendant un certain temps sans utiliser la fonction delay, car celle-ci stop le programme ,qui ceci n'est pas génial =s

    merci a ceux qui me répondrons
    • Partager sur Facebook
    • Partager sur Twitter
      1 novembre 2012 à 12:36:56

      En utilisant la fonction millis(), qui n'est pas bloquante mais demande à bien architecturer son code
      • Partager sur Facebook
      • Partager sur Twitter
        1 novembre 2012 à 16:05:54

        merci d’avoir répondu
        j'ai regarder avec la foncion millis, j'arrive à ce bout de code la :

        tempsbp=millis
        tempslampe = 5min
        tempsbp= millis


        if (bp && millis= tempsbp + 6000) (6s par exemple)
        {
        tempslampe= 10 min
        }

        else

        {
        tempslampe =5min
        }

        ce n'est pas la syntaxe exact mais c'est pour expliquer,

        est-ce que cela est juste ?
        car si maintenant la condition n'est plus vrai le tempslampe est de nouveau égale à 5min!
        comment pourrai-je faire ?
        merci
        • Partager sur Facebook
        • Partager sur Twitter
          1 novembre 2012 à 19:32:10

          Citation : Calengula

          if (bp && millis= tempsbp + 6000) (6s par exemple)



          Écris plutôt :

          if (bp && millis>= tempsbp + 6000) (6s par exemple)

          Car il y a trés peu de chance que le programme arrive pile poil a la valeur voulue!

          Et n'oublie pas les parenthèses pour la fonction millis()
          • Partager sur Facebook
          • Partager sur Twitter
            7 novembre 2012 à 12:42:28

            merci pour ta réponse,
            j'ai trouver ce code la,
            il marche pas de soucis, mais je ne le comprend pas , qqun pourrait-il me l'expliquer ?


            /* 4-Way Button: Click, Double-Click, Press+Hold, and Press+Long-Hold Test Sketch
            By Jeff Saltzman
            Oct. 13, 2009
            
            To keep a physical interface as simple as possible, this sketch demonstrates generating four output events from a single push-button.
            1) Click: rapid press and release
            2) Double-Click: two clicks in quick succession
            3) Press and Hold: holding the button down
            4) Long Press and Hold: holding the button down for a long time
            */
            
            #define buttonPin 7 // analog input pin to use as a digital input
            #define ledPin1 9 // digital output pin for LED 1
            #define ledPin2 10 // digital output pin for LED 2
            #define ledPin3 11 // digital output pin for LED 3
            #define ledPin4 12 // digital output pin for LED 4
            
            // LED variables
            boolean ledVal1 = false; // state of LED 1
            boolean ledVal2 = false; // state of LED 2
            boolean ledVal3 = false; // state of LED 3
            boolean ledVal4 = false; // state of LED 4
            
            //=================================================
            
            void setup()
            {
              
                // Set button input pin
                pinMode(buttonPin, INPUT);
                digitalWrite(buttonPin, HIGH );
                // Set LED output pins
                pinMode(ledPin1, OUTPUT);
                digitalWrite(ledPin1, ledVal1);
                pinMode(ledPin2, OUTPUT);
                digitalWrite(ledPin2, ledVal2);
                pinMode(ledPin3, OUTPUT);
                digitalWrite(ledPin3, ledVal3);
                pinMode(ledPin4, OUTPUT);
                digitalWrite(ledPin4, ledVal4);
            }
            
            void loop()
            {
            // Get button event and act accordingly
                  int b = checkButton();
                  if (b == 1) clickEvent();
                  if (b == 2) doubleClickEvent();
                  if (b == 3) holdEvent();
                  if (b == 4) longHoldEvent();
            }
            
            //=================================================
            // Events to trigger by click and press+hold
            
            void clickEvent() 
            {
                  ledVal1 = !ledVal1;
                  digitalWrite(ledPin1, ledVal1);
            }
            
            void doubleClickEvent() 
            {
                  ledVal2 = !ledVal2;
                  digitalWrite(ledPin2, ledVal2);
            }
            
            void holdEvent() 
            {
                  ledVal3 = !ledVal3;
                  digitalWrite(ledPin3, ledVal3);
            }
            
            void longHoldEvent() 
            {
                  ledVal4 = !ledVal4;
                  digitalWrite(ledPin4, ledVal4);
            }
            
            /*
            MULTI-CLICK: One Button, Multiple Events
            
            Oct 12, 2009
            Run checkButton() to retrieve a button event:
            Click
            Double-Click
            Hold
            Long Hold
            */
            
            // Button timing variables
            int debounce = 20; // ms debounce period to prevent flickering when pressing or releasing the button
            int DCgap = 250; // max ms between clicks for a double click event
            int holdTime = 2000; // ms hold period: how long to wait for press+hold event
            int longHoldTime = 5000; // ms long hold period: how long to wait for press+hold event
            
            // Other button variables
            boolean buttonVal = HIGH; // value read from button
            boolean buttonLast = HIGH; // buffered value of the button's previous state
            boolean DCwaiting = false; // whether we're waiting for a double click (down)
            boolean DConUp = false; // whether to register a double click on next release, or whether to wait and click
            boolean singleOK = true; // whether it's OK to do a single click
            long downTime = -1; // time the button was pressed down
            long upTime = -1; // time the button was released
            boolean ignoreUp = false; // whether to ignore the button release because the click+hold was triggered
            boolean waitForUp = false; // when held, whether to wait for the up event
            boolean holdEventPast = false; // whether or not the hold event happened already
            boolean longHoldEventPast = false;// whether or not the long hold event happened already
            
            int checkButton()
            {
                  int event = 0;
                  // Read the state of the button
                  buttonVal = digitalRead(buttonPin);
                  // Button pressed down
                  if (buttonVal == LOW && buttonLast == HIGH && (millis() - upTime) > debounce) 
                    {
                    downTime = millis();
                    ignoreUp = false;
                    waitForUp = false;
                    singleOK = true;
                    holdEventPast = false;
                    longHoldEventPast = false;
                    if ((millis()-upTime) < DCgap && DConUp == false && DCwaiting == true) DConUp = true;
                    else DConUp = false;
                    DCwaiting = false;
                    }
            // Button released
                  else if (buttonVal == HIGH && buttonLast == LOW && (millis() - downTime) > debounce) 
                  {
                      if (not ignoreUp) 
                      {
                        upTime = millis();
                         if (DConUp == false) DCwaiting = true;
                         else 
                            {
                                event = 2;
                                DConUp = false;
                                DCwaiting = false;
                                singleOK = false;
                            }
                      }
                  }
            // Test for normal click event: DCgap expired
            if ( buttonVal == HIGH && (millis()-upTime) >= DCgap && DCwaiting == true && DConUp == false && singleOK == true)
            {
                  event = 1;
                  DCwaiting = false;
            }
            // Test for hold
            if (buttonVal == LOW && (millis() - downTime) >= holdTime) 
            {
            // Trigger "normal" hold
            if (not holdEventPast) 
            {
                  event = 3;
                  waitForUp = true;
                  ignoreUp = true;
                  DConUp = false;
                  DCwaiting = false;
                  //downTime = millis();
                  holdEventPast = true;
            }
            // Trigger "long" hold
              if ((millis() - downTime) >= longHoldTime) 
              {
                if (not longHoldEventPast)
                  {
                    event = 4;
                    longHoldEventPast = true;
                  }
               }
            }
                  buttonLast = buttonVal;
                  return event;
            }
            
            • Partager sur Facebook
            • Partager sur Twitter
              7 novembre 2012 à 12:49:29

              arg mes yeux...balise code please...

              EDIT : La balise code c'est bien, avec de l'indentation c'est mieux ! (je sais je suis casse-pieds mais faut aussi se mettre à notre place...)
              • Partager sur Facebook
              • Partager sur Twitter
                7 novembre 2012 à 17:54:03

                Le code est assez simple (même si je ne l'aurais pas écrit comme ça). Il suffit de lire les commentaires :

                en boucle (dans loop donc)
                on lit l'état du bouton.// Read the state of the button

                si il est pressé, on note l'instant de début de la pression // Button pressed down
                si il est relaché, on regarde si c'était le second clic, et si oui on renvoie un double clic (si non, on sauvegarde juste la date de relachement) // Button released

                si le bouton ne change pas d'état, on regarde plusieurs cas :
                il n'était enfoncé, qu'il y avait eu un clic, et qu'il est trop tard pour un double clic, on signale un simple clic // Test for normal click event: DCgap expired
                si il était enfoncé depuis longtemps, on renvoit un appui long // Trigger "normal" hold
                si il était enfoncé depuis très longtemps, on renvoit un appui très long.// Trigger "long" hold


                dans tous les autres cas, on ne renvoit pas d'event.


                Encore une fois c'est une implémentation qui utilise énormément de variables (11, pour une fonctionnalité somme toute assez simple), c'est autant de risques d'oublier d'en réinitialiser une à un moment, mais, à priori, ce code a été débuggé.
                • Partager sur Facebook
                • Partager sur Twitter
                64kB de mémoire, c'est tout ce dont j'ai besoin
                  7 novembre 2012 à 19:16:03

                  Je vous remercie beaucoup pour cette explication ,
                  y aurai-t-il un moyen de faire plus simple?
                  car ce programme sera expliquer a des secondes,
                  et si déja mois etudiant en bts je m'y retrouve pas =s
                  ( il faut dire que je débute aussi )
                  car mon but serait de faire en sorte de:
                  -appuis long : valeur du temps d'allumage (10 min)
                  -appuis court: valeur du temps d'allumage (5min)
                  -appuis simple: allumage lampe
                  • Partager sur Facebook
                  • Partager sur Twitter
                  Anonyme
                    7 novembre 2012 à 21:26:41

                    Bonjour,

                    J'aurai fait ça avec une interruption sur changement d'état
                    en passant par 2 variables "flag"
                    parce que l'on ne peut pas utiliser millis dans une interruption
                    d'après mes souvenirs.

                    Pour être une explicite:
                    void interruption_sur_changement_de_frond() {
                      if bouton appuye
                        flag_appuye = true
                      if bouton_relacher
                        flag_relacher = true
                    }
                    
                    void loop(){
                      
                      if flag_appuye = true
                        flag_appuye = false
                        memorisationA de millis
                      
                      if flag_relacher = true
                        flag_relacher = false
                        memorisationR de millis
                    
                      comparaison des temps
                        choix
                    
                    }
                    
                    • Partager sur Facebook
                    • Partager sur Twitter
                      7 novembre 2012 à 21:28:12

                      D'aussi loin que je me souvienne (la flemme de vérifier), on peut utiliser millis() dans les interruptions (qui ne fait que retourner le nombre de millisecondes écoulé depuis le démarrage) mais on ne peut pas utiliser delay en revanche (et ça j'en suis sur)
                      • Partager sur Facebook
                      • Partager sur Twitter
                      Anonyme
                        7 novembre 2012 à 21:35:13

                        Le doute m’habitant, j'ai vérifier.
                        Et ainsi je confirme que l'on peut utiliser millis dans une interruption.

                        Donc on peut tous mettre dans l’interruption,

                        Mais je me rappel m'être fait tanné par des profs qui disait "JAMAIS mettre beaucoup de code dans une interruption".

                        Les deux fonctions en tout cas. =)
                        • Partager sur Facebook
                        • Partager sur Twitter
                          8 novembre 2012 à 20:19:00

                          merci pour ces réponse elles m'ont beaucoup aidés merci^^

                          mais juste une question, tant que je reste appuyer, flag_appuyer est bien égale à false ?
                          car si je comprend bien la carte lit le programme depuis le début, donc si il relit :
                          if bouton appuye
                              flag_appuye = true
                          


                          alors la variable sera de nouveau vrai ,meme si je reste appuyer sur le bouton ? corigé moi si cela est faux
                          • Partager sur Facebook
                          • Partager sur Twitter
                          Anonyme
                            11 novembre 2012 à 16:28:00

                            J'ai pas tellement compris ta question...
                            Mais je pense que si je te dit ce qui va suivre ça va d'aider:


                            L'interruption de type CHANGE lance la fonction que tu le souhaite,
                            Seulement au moment ou ton bouton change d'état.

                            en gros si ton bouton fait
                            Relâché -> Appuyé 
                            ou 
                            Appuyé -> Relâché

                            ça lance ta fonction choisi.

                            Dans algorithme que je t'ai proposé
                            Relâché -> Appuyé 
                            maintenant flag_appuye = true
                            juste après flag_appuye = false
                            Appuyé -> Relâché
                            maintenant flag_relacher = true
                            juste après flag_relacher = false


                            Mais comme l'a fait remarqué Eskimon on pourrais écrire:

                            void interruption_sur_changement_de_frond() { //appelé quand le bouton CHANGE d'état
                              if digitalRead(btn) { // au Moment ou on appui sur le bouton
                                memorisationA de millis()
                              }
                              else { // // au Moment ou on relâche le bouton
                                memorisationR de millis()
                                comparaison_des_temps()
                              }
                            }
                            
                            void loop(){
                            }
                            



                            En espérant t'avoir répondu...
                            • Partager sur Facebook
                            • Partager sur Twitter
                              11 novembre 2012 à 17:16:00

                              merci , tu as répondu a ma question, la solution ci-dessus me parrait la plus simple , au début je me bornai sur la fonction delay, qui n'est pas un très bonne chose, car celle-ci arrete la carte, enfin bref , merci a tous de m'avoir aidé ^^
                              • Partager sur Facebook
                              • Partager sur Twitter

                              Arduino,Gestion d'éclairage

                              × Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
                              × Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
                              • Editeur
                              • Markdown