OneButton.cpp

// -----
// OneButton.cpp - Library for detecting button clicks, doubleclicks and long press pattern on a single button.
// This class is implemented for use with the Arduino environment.
// Copyright (c) by Matthias Hertel, http://www.mathertel.de
// This work is licensed under a BSD style license. See http://www.mathertel.de/License.aspx
// More information on: http://www.mathertel.de/Arduino
// -----
// Connect the button to pin A1 (MenuPin)
// 02.10.2010 created by Matthias Hertel
// 21.04.2011 support of active LOW and active HIGH button signal input.
// 01.12.2011 include file changed to work with the Arduino 1.0 environment
// 12.01.2014 some typos fixed.
// 01.03.2014 Enhanced long press functionalities by adding longPressStart and longPressStop callbacks
// -----

#include "OneButton.h"

// ----- Initialization and Default Values -----

OneButton::OneButton(int pin, int activeLow) {
  init();
  setPin(pin);
  setActiveLow(activeLow);

} // OneButton

// argument-free constructor so we can set pin/activelow later depending on device
OneButton::OneButton() {
  init();
}

OneButton::OneButton(bool (*pseudo)(void), bool activeLow) {
  init();
  setPseudo(pseudo);
  setActiveLow(activeLow);
}

void OneButton::init() {
  _clickTicks = 250;        // number of millisec that have to pass by before a click is detected.
  _pressTicks = 1000;       // number of millisec that have to pass by before a long button press is detected.

  _state = 0; // starting with state 0: waiting for button to be pressed
  _isLongPressed = false;  // Keep track of long press state

  _doubleClickFunc = NULL;
  _pressFunc = NULL;
  _longPressStartFunc = NULL;
  _longPressStopFunc = NULL;
  _duringLongPressFunc = NULL;

}

void OneButton::setPin(int pin) {
  if (!_pseudo) {
    pinMode(pin, INPUT);      // sets the MenuPin as input
    _pin = pin;
  }
}

void OneButton::setActiveLow(int activeLow) {
  if (activeLow) {
    // button connects ground to the pin when pressed.
    _buttonReleased = HIGH; // notPressed
    _buttonPressed = LOW;
    if (!_pseudo) pinMode(_pin, INPUT_PULLUP);   // turn on pullUp resistor

  } else {
    // button connects VCC to the pin when pressed.
    _buttonReleased = LOW;
    _buttonPressed = HIGH;
  } // if

  // Debounce init
  _db_buttonState      = _buttonReleased;  // the current reading from the input pin, assume its in rest during setup
  _db_lastButtonState  = _db_buttonState;  // the previous reading from the input pin, no previous reading so use current
  _db_lastDebounceTime = 0;                // the last time the output pin was toggled, init to zero
  _db_debounceDelay    = 25;               // the debounce time; increase if the output flickers. Settable with setDebounceDelay() function
}

// explicitly set the number of millisec that have to pass by before a click is detected.
void OneButton::setClickTicks(int ticks) {
  _clickTicks = ticks;
} // setClickTicks


// explicitly set the number of millisec that have to pass by before a long button press is detected.
void OneButton::setPressTicks(int ticks) {
  _pressTicks = ticks;
} // setPressTicks

// if we're reading from a pseudo button (ie, not directly off a digital pin), newFunction
// will return the button state (boolean) when called with no arguments
void OneButton::setPseudo(bool (*newFunction)(void)) {
  _pseudo = newFunction;
}

// save function for click event
void OneButton::attachClick(callbackFunction newFunction)
{
  _clickFunc = newFunction;
} // attachClick


// save function for doubleClick event
void OneButton::attachDoubleClick(callbackFunction newFunction)
{
  _doubleClickFunc = newFunction;
} // attachDoubleClick


// save function for press event
// DEPRECATED, is replaced by attachLongPressStart, attachLongPressStop, attachDuringLongPress,
void OneButton::attachPress(callbackFunction newFunction)
{
  _pressFunc = newFunction;
} // attachPress

// save function for longPressStart event
void OneButton::attachLongPressStart(callbackFunction newFunction)
{
  _longPressStartFunc = newFunction;
} // attachLongPressStart

// save function for longPressStop event
void OneButton::attachLongPressStop(callbackFunction newFunction)
{
  _longPressStopFunc = newFunction;
} // attachLongPressStop

// save function for during longPress event
void OneButton::attachDuringLongPress(callbackFunction newFunction)
{
  _duringLongPressFunc = newFunction;
} // attachDuringLongPress

// function to get the current long pressed state
bool OneButton::isLongPressed(){
  return _isLongPressed;
}

void OneButton::tick(void)
{
  int buttonLevel;
  // Detect the input information
  if (_pseudo) {
    buttonLevel = debounce(_pseudo());
  } else {
    buttonLevel = debounce(digitalRead(_pin)); // current button signal. (debounced)
  }
  unsigned long now = millis(); // current (relative) time in msecs.

  // Implementation of the state machine
  if (_state == 0) { // waiting for menu pin being pressed.
    if (buttonLevel == _buttonPressed) {
      _state = 1; // step to state 1
      _startTime = now; // remember starting time
    } // if

  } else if (_state == 1) { // waiting for menu pin being released.
    if (buttonLevel == _buttonReleased) {
      _state = 2; // step to state 2

    } else if ((buttonLevel == _buttonPressed) && (now > _startTime + _pressTicks)) {
      _isLongPressed = true;  // Keep track of long press state
      if (_pressFunc) _pressFunc();
  	  if (_longPressStartFunc) _longPressStartFunc();
  	  if (_duringLongPressFunc) _duringLongPressFunc();
      _state = 6; // step to state 6

    } else {
      // wait. Stay in this state.
    } // if

  } else if (_state == 2) { // waiting for menu pin being pressed the second time or timeout.
    if (now > _startTime + _clickTicks) {
      //_blah = 43;
      // this was only a single short click
      if (_clickFunc) _clickFunc();
      _state = 0; // restart.

    } else if (buttonLevel == _buttonPressed) {
      _state = 3; // step to state 3
    } // if

  } else if (_state == 3) { // waiting for menu pin being released finally.
    if (buttonLevel == _buttonReleased) {
      // this was a 2 click sequence.
      if (_doubleClickFunc) _doubleClickFunc();
      _state = 0; // restart.
    } // if

  } else if (_state == 6) { // waiting for menu pin being release after long press.
    if (buttonLevel == _buttonReleased) {
	  _isLongPressed = false;  // Keep track of long press state
	  if(_longPressStopFunc) _longPressStopFunc();
      _state = 0; // restart.
    } else {
	  // button is being long pressed
	  _isLongPressed = true; // Keep track of long press state
	  if (_duringLongPressFunc) _duringLongPressFunc();
    } // if

  } // if
} // OneButton.tick()

boolean OneButton::debounce(boolean reading){
  // Source: http://arduino.cc/en/Tutorial/Debounce

  // check to see if you just pressed the button
  // (i.e. the input went from LOW to HIGH),  and you've waited
  // long enough since the last press to ignore any noise:

  // If the switch changed, due to noise or pressing:
  if (reading != _db_lastButtonState) {
    // reset the debouncing timer
    _db_lastDebounceTime = millis();
  }

  if ((millis() - _db_lastDebounceTime) > _db_debounceDelay) {
    // whatever the reading is at, it's been there for longer
    // than the debounce delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != _db_buttonState) {
      _db_buttonState = reading;
    }
  }

  // save the reading.  Next time through the loop,
  // it'll be the lastButtonState:
  _db_lastButtonState = reading;

  return _db_buttonState;
}

void OneButton::setDebounceDelay(int delay){
	_db_debounceDelay = delay;
}



// end.