Button.cpp

/*----------------------------------------------------------------------*
 * Arduino Button Library v1.0                                          *
 * Jack Christensen May 2011, published Mar 2012                        *
 *                                                                      *
 * Library for reading momentary contact switches like tactile button   *
 * switches. Intended for use in state machine constructs.              *
 * Use the read() function to read all buttons in the main loop,        *
 * which should execute as fast as possible.                            *
 *                                                                      *
 * This work is licensed under the Creative Commons Attribution-        *
 * ShareAlike 3.0 Unported License. To view a copy of this license,     *
 * visit http://creativecommons.org/licenses/by-sa/3.0/ or send a       *
 * letter to Creative Commons, 171 Second Street, Suite 300,            *
 * San Francisco, California, 94105, USA.                               *
 *----------------------------------------------------------------------*/

#include "Button.h"

/*----------------------------------------------------------------------*
 * Button(pin, puEnable, invert, dbTime) instantiates a button object.  *
 * pin      Is the Arduino pin the button is connected to.              *
 * puEnable Enables the AVR internal pullup resistor if != 0 (can also  *
 *          use true or false).                                         *
 * invert   If invert == 0, interprets a high state as pressed, low as  *
 *          released. If invert != 0, interprets a high state as        *
 *          released, low as pressed  (can also use true or false).     *
 * dbTime   Is the debounce time in milliseconds.                       *
 *                                                                      *
 * (Note that invert cannot be implied from puEnable since an external  *
 *  pullup could be used.)                                              *
 *----------------------------------------------------------------------*/
Button::Button(uint8_t pin, uint8_t invert, uint32_t dbTime) {
  _pin = pin;
  _invert = invert;
  _dbTime = dbTime;
  pinMode(_pin, INPUT_PULLUP);
  _state = digitalRead(_pin);
  if (_invert != 0) _state = !_state;
  _time = millis();
  _lastState = _state;
  _changed = 0;
  _hold_time = -1;
  _lastTime = _time;
  _lastChange = _time;
  _pressTime = _time;
}

/*----------------------------------------------------------------------*
 * read() returns the state of the button, 1==pressed, 0==released,     *
 * does debouncing, captures and maintains times, previous states, etc. *
 *----------------------------------------------------------------------*/
uint8_t Button::read(void) {
  static uint32_t ms;
  static uint8_t pinVal;

  ms = millis();
  pinVal = digitalRead(_pin);
  if (_invert != 0) pinVal = !pinVal;
  if (ms - _lastChange < _dbTime) {
    _lastTime = _time;
    _time = ms;
    _changed = 0;
    return _state;
  }
  else {
    _lastTime = _time;
    _time = ms;
    _lastState = _state;
    _state = pinVal;
    if (_state != _lastState) {
      _lastChange = ms;
      _changed = 1;
      if (_state) { _pressTime = _time; }
    }
    else {
      _changed = 0;
    }
    return _state;
  }
}

/*----------------------------------------------------------------------*
 * isPressed() and isReleased() check the button state when it was last *
 * read, and return false (0) or true (!=0) accordingly.                *
 * These functions do not cause the button to be read.                  *
 *----------------------------------------------------------------------*/
uint8_t Button::isPressed(void) {
  return _state == 0 ? 0 : 1;
}

uint8_t Button::isReleased(void) {
  return _state == 0 ? 1 : 0;
}

/*----------------------------------------------------------------------*
 * wasPressed() and wasReleased() check the button state to see if it   *
 * changed between the last two reads and return false (0) or           *
 * true (!=0) accordingly.                                              *
 * These functions do not cause the button to be read.                  *
 *----------------------------------------------------------------------*/
uint8_t Button::wasPressed(void) {
  return _state && _changed;
}

uint8_t Button::wasReleased(void) {
  return !_state && _changed && millis() - _pressTime < _hold_time;
}

uint8_t Button::wasReleasefor(uint32_t ms) {
  _hold_time = ms;
  return !_state && _changed && millis() - _pressTime >= ms;
}
/*----------------------------------------------------------------------*
 * pressedFor(ms) and releasedFor(ms) check to see if the button is     *
 * pressed (or released), and has been in that state for the specified  *
 * time in milliseconds. Returns false (0) or true (1) accordingly.     *
 * These functions do not cause the button to be read.                  *
 *----------------------------------------------------------------------*/
uint8_t Button::pressedFor(uint32_t ms) {
  return (_state == 1 && _time - _lastChange >= ms) ? 1 : 0;
}

uint8_t Button::pressedFor(uint32_t ms, uint32_t continuous_time) {
  if (_state == 1 && _time - _lastChange >= ms && _time - _lastLongPress >= continuous_time) {
    _lastLongPress = _time;
    return 1;
  } 
  return 0;
}

uint8_t Button::releasedFor(uint32_t ms) {
  return (_state == 0 && _time - _lastChange >= ms) ? 1 : 0;
}
/*----------------------------------------------------------------------*
 * lastChange() returns the time the button last changed state,         *
 * in milliseconds.                                                     *
 *----------------------------------------------------------------------*/
uint32_t Button::lastChange(void) {
  return _lastChange;
}