Long press toggle output HIGH and LOW

Hello guys, new B here!

I've been turning around the internet looking for a way to toggle an output from LOW to HIGH and vice versa when a button is pressed over an amount of time e.g 3000 millis!

Found a toggle sketch so far but couldn't successfully implement the wait timer!

I would also like this button to act like a normally pressed button when short pressed then toggle from whatever state output is to the other if button is long pressed!!!

here is what I'v got so far! thanks in advance for your lights!

int inPin = 5; // the number of the input pin int outPin = 2; // the number of the output pin

int state = LOW; // the current state of the output pin int reading; // the current reading from the input pin int previous = LOW; // the previous reading from the input pin

unsigned long time = 0; // the last time the output pin was toggled unsigned long debounce = 20UL; // the debounce time, increase if the output flickers unsigned long duration = 3000; // time over wich the press is concidered a lond press

void setup() { pinMode(inPin, INPUT); pinMode(outPin, OUTPUT); }

void loop() { reading = digitalRead(inPin);

// if the input just went from LOW and HIGH and we've waited long enough // to ignore any noise on the circuit, toggle the output pin and remember // the time if (reading == HIGH && previous == LOW && millis() - time > debounce) { if (state == LOW) state = HIGH; else state = LOW;

time = millis(); }

digitalWrite(outPin, state);

previous = reading; }

For switch timing sketches, suggest you use Nick Gammon’s ‘switchmanager’ library.

/*SwitchManager skeleton 
 
 
 This sketch is to introduce new people to the SwitchManager library written by Nick Gammon
 
 The library handles switch de-bouncing and provides timing and state change information in your sketch.
 The SwitchManager.h file should be placed in your libraries folder, i.e.
 C:\Users\YourName\Documents\Arduino\libraries\SwitchManager\SwitchManager.h
 You can download the library at:
 http://gammon.com.au/Arduino/SwitchManager.zip    Thank you Nick!
 
 In this example we have 2 normally open (N.O.) switches connected to the Arduino - increment and decrement.
 The increment switch will also be used as a "Reset" switch if pressed for more than two seconds.
 The two switches are connected between GND (0 volts) and an Arduino input pin.
 The library enables pull-up resistors for your switch inputs.
 Pushing a switch makes its pin LOW. Releasing a switch makes its pin HIGH.
 
 The SwitchManager library provides 10ms de-bounce for switches. 
 i.e. enum { debounceTime = 10, noSwitch = -1 };
 If you need more time, edit the SwitchManager.h file
 i.e. enum { debounceTime = 50, noSwitch = -1 }; //here it is changed to 50ms
 */

#include <SwitchManager.h>             
//object instantiations
SwitchManager myIncSwitch;
SwitchManager myDecSwitch;

unsigned long currentMillis;
unsigned long heartBeatMillis;
unsigned long heartFlashRate  = 500UL; // time the led will change state       
unsigned long incShortPress   = 500UL; // 1/2 second
unsigned long incLongPress    = 2000UL;// 2 seconds 
unsigned long decShortPress   = 500UL; // 1/2 second

const byte heartBeatLED       = 13;
const byte incSwitch          = 4; //increment switch is on Arduino pin 4
const byte decSwitch          = 5; //decrement switch is on Arduino pin 5

int myCounter;

//======================================================================

void setup()
{
  Serial.begin(9600);

  //gives a visual indication if the sketch is blocking
  pinMode(heartBeatLED, OUTPUT);  

  myIncSwitch.begin (incSwitch, handleSwitchPresses); 
  myDecSwitch.begin (decSwitch, handleSwitchPresses);
  //the handleSwitchPresses() function is called when a switch changes state

} //                   E N D  O F  s e t u p ( )

//======================================================================

void loop()
{
  //leave this line of code at the top of loop()
  currentMillis = millis();

  //***************************
  //some code to see if the sketch is blocking
  if (CheckTime(heartBeatMillis, heartFlashRate, true))
  {
    //toggle the heartBeatLED
    digitalWrite(heartBeatLED,!digitalRead(heartBeatLED));
  }

  //***************************
  //check to see what's happening with the switches
  //"Do not use delay()s" in your sketch as it will make switch changes unresponsive 
  //Use BlinkWithoutDelay (BWD) techniques instead.
  myIncSwitch.check ();  
  myDecSwitch.check (); 

  //***************************
  //put other non-blocking stuff here


} //                      E N D  O F  l o o p ( )


//======================================================================
//                          F U N C T I O N S
//======================================================================


//                        C h e c k T i m e ( ) 
//**********************************************************************
//Delay time expired function
//parameters:
//lastMillis = time we started
//wait = delay in ms
//restart = do we start again  

boolean CheckTime(unsigned long  & lastMillis, unsigned long wait, boolean restart) 
{
  //has time expired for this task?
  if (currentMillis - lastMillis >= wait) 
  {
    //should this start again? 
    if(restart)
    {
      //yes, get ready for the next iteration
      lastMillis = millis();  
    }
    return true;
  }
  return false;

} //                 E N D   o f   C h e c k T i m e ( )


//                h a n d l e S w i t c h P r e s s e s ( )
//**********************************************************************

void handleSwitchPresses(const byte newState, const unsigned long interval, const byte whichPin)
{
  //  You get here "ONLY" if there has been a change in a switches state.

  //When a switch has changed state, SwitchManager passes this function 3 arguments:
  //"newState" this will be HIGH or LOW. This is the state the switch is in now.
  //"interval" the number of milliseconds the switch stayed in the previous state
  //"whichPin" is the switch pin that we are examining  

  switch (whichPin)
  {
    //***************************
    //are we dealing with this switch?
  case incSwitch: 

    //has this switch gone from LOW to HIGH (gone from pressed to not pressed)
    //this happens with normally open switches wired as mentioned at the top of this sketch
    if (newState == HIGH)
    {
      //The incSwitch was just released
      //was this a short press followed by a switch release
      if(interval <= incShortPress) 
      {
        Serial.print("My counter value is = ");
        myCounter++;
        if(myCounter > 1000)
        {
          //limit the counter to a maximum of 1000
          myCounter = 1000; 
        }
        Serial.println(myCounter);
      }

      //was this a long press followed by a switch release
      else if(interval >= incLongPress) 
        //we could also have an upper limit
        //if incLongMillis was 2000UL; we could then have a window between 2-3 seconds
        //else if(interval >= incLongMillis && interval <= incLongMillis + 1000UL) 
      {
        //this could be used to change states in a StateMachine
        //in this example however, we will just reset myCounter
        myCounter = 0;
        Serial.print("My counter value is = ");
        Serial.println(myCounter);
      }

    }

    //if the switch is a normally closed (N.C.) and opens on a press this section would be used
    //the switch must have gone from HIGH to LOW 
    else 
    {
      Serial.println("The incSwitch was just pushed");
    } 

    break; //End of case incSwitch

    //*************************** 
    //are we dealing with this switch?
  case decSwitch: 

    //has this switch gone from LOW to HIGH (gone from pressed to not pressed)
    //this happens with normally open switches wired as mentioned at the top of this sketch
    if (newState == HIGH)
    {
      //The decSwitch was just released
      //was this a short press followed by a switch release
      if(interval <= decShortPress) 
      {
        Serial.print("My counter value is = ");
        myCounter--;
        if(myCounter < 0) 
        {
          //don't go below zero
          myCounter = 0;
        }
        Serial.println(myCounter);
      }

    }

    //if the switch is a normally closed (N.C.) and opens on a press this section would be used
    //the switch must have gone from HIGH to LOW
    else 
    {
      Serial.println("The decSwitch switch was just pushed");
    } 

    break; //End of case decSwitch

    //*************************** 
    //Put default stuff here
    //default:
    //break; //END of default

  } //End switch (whichPin)

} //      E n d   o f   h a n d l e S w i t c h P r e s s e s ( )


//======================================================================
//                      E N D  O F  C O D E
//======================================================================
static int state = LOW;
static int previous_reading = LOW;
static unsigned long start_time = 0; 
static bool registered = false;

const unsigned long DURATION = 3000;

...

void loop()
{
  unsigned long current_time = millis();

  int reading = digitalRead(inPin);
  if (reading != previous_reading)
  {
    start_time = current_time;
    previous_reading = reading;
    registered = false;
  }
  else if (!registered && reading == HIGH && current_time - start_time >= DURATION)
  {
    state = state == LOW ? HIGH : LOW;
    digitalWrite(outPin, state); 
    registered = true;
  }
}

There's no need to make reading a non-local variable.

The requirement to wait for a specific (fairly long) duration is already a debouncing functionality in itself . You don't need to implement separate "ordinary" debouncing.

Variable registered ensures that the state is changed only once during a long press, under assumption that this is what you need.

larryd:
For switch timing sketches, suggest you use Nick Gammon’s ‘switchmanager’ library.

/*SwitchManager skeleton 

This sketch is to introduce new people to the SwitchManager library written by Nick Gammon

The library handles switch de-bouncing and provides timing and state change information in your sketch.
The SwitchManager.h file should be placed in your libraries folder, i.e.
C:\Users\YourName\Documents\Arduino\libraries\SwitchManager\SwitchManager.h
You can download the library at:
http://gammon.com.au/Arduino/SwitchManager.zip    Thank you Nick!

In this example we have 2 normally open (N.O.) switches connected to the Arduino - increment and decrement.
The increment switch will also be used as a “Reset” switch if pressed for more than two seconds.
The two switches are connected between GND (0 volts) and an Arduino input pin.
The library enables pull-up resistors for your switch inputs.
Pushing a switch makes its pin LOW. Releasing a switch makes its pin HIGH.

The SwitchManager library provides 10ms de-bounce for switches.
i.e. enum { debounceTime = 10, noSwitch = -1 };
If you need more time, edit the SwitchManager.h file
i.e. enum { debounceTime = 50, noSwitch = -1 }; //here it is changed to 50ms
*/

#include <SwitchManager.h>           
//object instantiations
SwitchManager myIncSwitch;
SwitchManager myDecSwitch;

unsigned long currentMillis;
unsigned long heartBeatMillis;
unsigned long heartFlashRate  = 500UL; // time the led will change state     
unsigned long incShortPress  = 500UL; // 1/2 second
unsigned long incLongPress    = 2000UL;// 2 seconds
unsigned long decShortPress  = 500UL; // 1/2 second

const byte heartBeatLED      = 13;
const byte incSwitch          = 4; //increment switch is on Arduino pin 4
const byte decSwitch          = 5; //decrement switch is on Arduino pin 5

int myCounter;

//======================================================================

void setup()
{
  Serial.begin(9600);

//gives a visual indication if the sketch is blocking
  pinMode(heartBeatLED, OUTPUT);

myIncSwitch.begin (incSwitch, handleSwitchPresses);
  myDecSwitch.begin (decSwitch, handleSwitchPresses);
  //the handleSwitchPresses() function is called when a switch changes state

} //                  E N D  O F  s e t u p ( )

//======================================================================

void loop()
{
  //leave this line of code at the top of loop()
  currentMillis = millis();

//***************************
  //some code to see if the sketch is blocking
  if (CheckTime(heartBeatMillis, heartFlashRate, true))
  {
    //toggle the heartBeatLED
    digitalWrite(heartBeatLED,!digitalRead(heartBeatLED));
  }

//***************************
  //check to see what’s happening with the switches
  //“Do not use delay()s” in your sketch as it will make switch changes unresponsive
  //Use BlinkWithoutDelay (BWD) techniques instead.
  myIncSwitch.check (); 
  myDecSwitch.check ();

//***************************
  //put other non-blocking stuff here

} //                      E N D  O F  l o o p ( )

//======================================================================
//                          F U N C T I O N S
//======================================================================

//                        C h e c k T i m e ( )
//**********************************************************************
//Delay time expired function
//parameters:
//lastMillis = time we started
//wait = delay in ms
//restart = do we start again

boolean CheckTime(unsigned long  & lastMillis, unsigned long wait, boolean restart)
{
  //has time expired for this task?
  if (currentMillis - lastMillis >= wait)
  {
    //should this start again?
    if(restart)
    {
      //yes, get ready for the next iteration
      lastMillis = millis(); 
    }
    return true;
  }
  return false;

} //                E N D  o f  C h e c k T i m e ( )

//                h a n d l e S w i t c h P r e s s e s ( )
//**********************************************************************

void handleSwitchPresses(const byte newState, const unsigned long interval, const byte whichPin)
{
  //  You get here “ONLY” if there has been a change in a switches state.

//When a switch has changed state, SwitchManager passes this function 3 arguments:
  //“newState” this will be HIGH or LOW. This is the state the switch is in now.
  //“interval” the number of milliseconds the switch stayed in the previous state
  //“whichPin” is the switch pin that we are examining

switch (whichPin)
  {
    //***************************
    //are we dealing with this switch?
  case incSwitch:

//has this switch gone from LOW to HIGH (gone from pressed to not pressed)
    //this happens with normally open switches wired as mentioned at the top of this sketch
    if (newState == HIGH)
    {
      //The incSwitch was just released
      //was this a short press followed by a switch release
      if(interval <= incShortPress)
      {
        Serial.print("My counter value is = ");
        myCounter++;
        if(myCounter > 1000)
        {
          //limit the counter to a maximum of 1000
          myCounter = 1000;
        }
        Serial.println(myCounter);
      }

//was this a long press followed by a switch release
      else if(interval >= incLongPress)
        //we could also have an upper limit
        //if incLongMillis was 2000UL; we could then have a window between 2-3 seconds
        //else if(interval >= incLongMillis && interval <= incLongMillis + 1000UL)
      {
        //this could be used to change states in a StateMachine
        //in this example however, we will just reset myCounter
        myCounter = 0;
        Serial.print("My counter value is = ");
        Serial.println(myCounter);
      }

}

//if the switch is a normally closed (N.C.) and opens on a press this section would be used
    //the switch must have gone from HIGH to LOW
    else
    {
      Serial.println(“The incSwitch was just pushed”);
    }

break; //End of case incSwitch

//***************************
    //are we dealing with this switch?
  case decSwitch:

//has this switch gone from LOW to HIGH (gone from pressed to not pressed)
    //this happens with normally open switches wired as mentioned at the top of this sketch
    if (newState == HIGH)
    {
      //The decSwitch was just released
      //was this a short press followed by a switch release
      if(interval <= decShortPress)
      {
        Serial.print("My counter value is = ");
        myCounter–;
        if(myCounter < 0)
        {
          //don’t go below zero
          myCounter = 0;
        }
        Serial.println(myCounter);
      }

}

//if the switch is a normally closed (N.C.) and opens on a press this section would be used
    //the switch must have gone from HIGH to LOW
    else
    {
      Serial.println(“The decSwitch switch was just pushed”);
    }

break; //End of case decSwitch

//***************************
    //Put default stuff here
    //default:
    //break; //END of default

} //End switch (whichPin)

} //      E n d  o f  h a n d l e S w i t c h P r e s s e s ( )

//======================================================================
//                      E N D  O F  C O D E
//======================================================================

Thanks Larryd, i will definitly try to understand and use this library!!!

Very easy to use.

If there are questions in the example above, ask for explanation.

Montmorency: ``` static int state = LOW; static int previous_reading = LOW; static unsigned long start_time = 0; static bool registered = false;

const unsigned long DURATION = 3000;

...

void loop() {  unsigned long current_time = millis();

 int reading = digitalRead(inPin);  if (reading != previous_reading)  {    start_time = current_time;    previous_reading = reading;    registered = false;  }  else if (!registered && reading == HIGH && current_time - start_time >= DURATION)  {    state = state == LOW ? HIGH : LOW;    digitalWrite(outPin, state);    registered = true;  } }




There's no need to make `reading` a non-local variable.

The requirement to wait for a specific (fairly long) duration is already a debouncing functionality in itself . You don't need to implement separate "ordinary" debouncing.

Variable `registered` ensures that the state is changed only once during a long press, under assumption that this is what you need.

Thank you Montmorency, works like charm..