
#include "jcbutton.h"


byte g_cnt;
byte g_test;

//Button btnPdwn(9, 25, false, false);
Button btnPdwn(9, InputMode::EXPDWN);
Button btnPup(6);  // default InputMode::IPUP

void setup() {
  Serial.begin(115200);
  
  Serial.println("setup");

}

void loop() {
  
  btnPdwn.read();
  btnPup.read();
  switch(g_test) {
      case 0:
        if (btnPdwn.isPressed()) {
            if (g_cnt > 0) {
                g_cnt--;
                Serial.println(g_cnt);
            }
            
        } else if (btnPup.isPressed()) {
            g_cnt++;
            Serial.println(g_cnt);
            if (g_cnt > 120)
                g_test = 1;
        }
      break;
      case 1:
        if (btnPdwn.wasPressed()) {
            Serial.println("redleft");
        } else if (btnPup.wasPressed()) {
            Serial.println("redRight");
        }
      break;

  }
 
  if (btnPdwn.wasPressedFor(500)) {
    Serial.println("btnPdwn long pressed");
  } else if (btnPup.wasPressedFor(1000)) {
    Serial.println("btnPup long pressed");

  }
}




testbuttons.ino

diagram.json

# Wokwi Library List
# See https://docs.wokwi.com/guides/libraries

# Automatically added based on includes:

libraries.txt

readme.md

#ifndef JC_BUTTON_H_
#define JC_BUTTON_H_

#include <stdint.h>
// INPUT_PULLDOWN non è una macro ma un enum su core SAMD
// INPUT_PULLDOWN è una macro nel core ESP32
#if defined (ARDUINO_ARCH_SAMD) || defined (INPUT_PULLDOWN)
  #ifndef HAVE_PULL_DOWN
    #define HAVE_PULL_DOWN
  #endif
#endif

enum InputMode { 
      IPUP    // Internal Pull Up
    , EXPUP   // External Pull Up
    , EXPDWN  // External Pull Down
#ifdef HAVE_PULL_DOWN
    IPDWN     // Internal Pull Down
#endif
};

class Button {
    public:
      // ctor
      /** mode = IPUP | EXPUP | EXPDWN | IPDWN */
      Button(uint8_t pin, InputMode mode = IPUP)
            : m_pin(pin), m_pinMode(mode) {
          begin();
      }    

      /** Set debounce time (default debounce time is 10ms) */
      void setDebounceTime(uint32_t dt) {
          m_dbTime = dt;
      }

      /** Call this function frequently to ensure
          the sketch is responsive to user input.
          Return the current state of button.
      */
      bool read();

      // Returns true if the button state was pressed at the last call to read().
      // Does not cause the button to be read.
      bool isPressed() const {
          return m_state;
      }

      // Returns true if the button state was released at the last call to read().
      // Does not cause the button to be read.
      bool isReleased() const {
          return !m_state;
      }

      // Returns true if the button state at the last call to read() was pressed,
      // and this was a change since the previous read.
      bool wasPressed() const {
          return m_state && m_changed;
      }

      // Returns true if the button state at the last call to read() was released,
      // and this was a change since the previous read.
      bool wasReleased() const {
          return !m_state && m_changed;
      }

      // Returns true if the button state at the last call to read() was pressed,
      // and has been in that state for at least the given number of milliseconds.
      bool pressedFor(uint32_t ms) const {
          return m_state && m_time - m_lastChange >= ms;
      }
      // Returns true if the button has been pressed 
      // for the time specified as the argument (ms).
      // If the button is still pressed at the next call 
      // of this method, it returns false. 
      bool wasPressedFor(const uint32_t ms);

      // Returns true if the button state at the last call to read() was released,
      // and has been in that state for at least the given number of milliseconds.
      bool releasedFor(uint32_t ms) const {
          return !m_state && m_time - m_lastChange >= ms;
      }

      // Returns the time in milliseconds (from millis) that the button last
      // changed state.
      uint32_t lastChange() const {
          return m_lastChange;
      }

      
    protected:
      void begin();  
      inline bool getPinState() const;

    private:
                 
      uint8_t m_pin;          
      InputMode m_pinMode;    // default enable (IPUP) internal pull-up
      
      bool m_state;           // current button state, true=pressed
      bool m_lastState;       // previous button state
      bool m_changed;         // state changed since last read
      bool m_inverted;
      bool m_isLongPressed;
     
      uint32_t m_time;        // time of current state (ms from millis)
      uint32_t m_lastChange;  // time of last state change (ms)
      uint32_t m_dbTime;      // debounce time (ms)
      
};

#endif

jcbutton.h

#include "jcbutton.h"
#include <Arduino.h>

#define DFLT_DEBOUNCE 100
/*----------------------------------------------------------------------*
/ initialize a Button object and the pin it's connected to.             *
/-----------------------------------------------------------------------*/
void Button::begin() {
    m_dbTime = DFLT_DEBOUNCE;   
    m_inverted = (m_pinMode == InputMode::IPUP | m_pinMode == InputMode::EXPUP);
    
    if (m_pinMode == InputMode::IPUP) {
        pinMode(m_pin, INPUT_PULLUP);
    } else if (m_pinMode == InputMode::EXPUP
              || m_pinMode == InputMode::EXPDWN) {
        pinMode(m_pin, INPUT);
    } 
#ifdef HAVE_PULLDOWN
      else if (m_pinMode == InputMode::IPDWN) {
        pinMode(m_pin, INPUT_PULLDOWN);
    }
#endif
    m_state = getPinState();
    
    m_time = millis();
    m_lastState = m_state;
    m_changed = false;
    m_lastChange = m_time;
}

inline bool Button::getPinState() const {
    return m_inverted ^ digitalRead(m_pin);
}

bool Button::wasPressedFor(const uint32_t ms) {
    //bool istate = !m_isLongPressed && m_state && m_time - m_lastChange >= ms;
    bool istate = !m_isLongPressed && pressedFor(ms);
    if (istate) {
        m_isLongPressed = true;
    } else if (!m_state) {
        m_isLongPressed = false;
    }

    return istate;
        
}

/*----------------------------------------------------------------------*
/ returns the state of the button, true if pressed, false if released.  *
/ does debouncing, captures and maintains times, previous state, etc.   *
/-----------------------------------------------------------------------*/
bool Button::read()
{
    uint32_t ms = millis();
           
    if (ms - m_lastChange < m_dbTime) {
        m_changed = false;
    } else  {
        m_lastState = m_state;
        m_state = getPinState();
        
        if (m_state != m_lastState) {
            m_lastChange = ms;
            m_changed = true;
        }
    }
    
    m_time = ms;
    return m_state;
}



jcbutton.cpp


#define DBG_INIT() static uint32_t usBuffer[US_BUFF_SIZE];\
static byte indexOfBuffer;\
static byte forIndex

#define DBG_INCLUDE() \
static inline bool isBufferFull() {\
    return indexOfBuffer == (US_BUFF_SIZE - 1);\
}\
static inline bool saveUs() {\
    if (indexOfBuffer < (US_BUFF_SIZE - 1)) {\
        usBuffer[indexOfBuffer++] = micros();\
        return false;\
    }\
    return true;\
}\
static inline void restartSaveUs() {\
    indexOfBuffer = 0;\
    forIndex = 0;\
}\
static inline  void usPrint() {\
    if (forIndex < (US_BUFF_SIZE - 2)) {\
        byte i0 = forIndex;\
        byte i1 = forIndex + 1;\
        Serial.println(usBuffer[i1] - usBuffer[i0]);\
        forIndex++;\
    }\
}\
static inline  void usPrintRaw() {\
    if (forIndex < (US_BUFF_SIZE - 2)) {\
        Serial.println(usBuffer[forIndex]);\
        forIndex++;\
    }\
}