Go Down

Topic: Button function: click, double click, more... (Read 75877 times) previous topic - next topic

salsaman

Oct 15, 2009, 05:50 am Last Edit: Oct 15, 2009, 09:31 am by salsaman Reason: 1
I nailed down code to process a button in different ways and thought it might be handy for other folks too.

This "4-way button" of "multi click" example shows four different ways to use one button-- click, double click, hold, and "long hold."  LEDs light up according to the event triggered.

The motivation is getting the most input from the least physical input devices-- one button and a rotary up/down controller.  Using the button for multiple functions, branching menu and value setting UIs can be built in software.

Video demo showing four events:  http://www.flickr.com/photos/salsaviz/4010863644/

The "long hold" was an afterthought-- keep holding the button down so it does something else after a while-- and limited since it has to trigger the "normal" hold event first.  It would be easy to have longer holds trigger more events, but they would all include the shorter hold events, since holds trigger when the button is held down.  Wouldn't be tough to add a triple-click either, by extending the double-click logic and timekeeping, but that's not a common way to interact with a button.

The bulk of the code just sets up the button and test LEDs and events, the real content being the checkButton() function and its variables, after "MULTI-CLICK."  I tried to make the sketch easy to read and the function as general as possible by only returning an event code, but welcome any suggestions for improvement.

Here's the first tab:

Quote

/* 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 for a long time
*/

#define buttonPin 19        // analog input pin to use as a digital input
#define ledPin1 17          // digital output pin for LED 1
#define ledPin2 16          // digital output pin for LED 2
#define ledPin3 15          // digital output pin for LED 3
#define ledPin4 14          // 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

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);
}



salsaman

Here's the second (of two) tabs with the checkButton() function:


Quote

//=================================================
//  MULTI-CLICK:  One Button, Multiple Events

// 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 = 1000;        // ms hold period: how long to wait for press+hold event
int longHoldTime = 3000;    // ms long hold period: how long to wait for press+hold event

// 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;
   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 != 2)
   {
       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;
}


mowcius

I have to admit that it is good idea but it looks like the code is rather too long for me to use it... If I get some time then I will have a more detailed look at it...

On my project I just did

while(digitalRead(button) == LOW){}
delay(1000)
if(digitalRead(button) == HIGH){
 "Do something"
}
else{
"do something else"
}

Then if it pressed for less than one second it does one thing, if it is held then it does another... It is used on my projects with menus... I focused on the idea of like a bike computer with single button...

Mowcius

JamesCarruthers

double click and other functions (and not using delay!) makes things a lot more complex :)

nice work salsaman - I wrote some code last weekend to do a similar thing (single, double and hold) - I figured those three events were enough for me.

Go Up