
#include "mtbutton.h"

uint16_t g_cnt;
uint8_t g_test;
uint8_t g_oldTest = ~0;

bool g_onEntry;
MtButton btnPdwn(9, InputMode::EXPDWN);
MtButton btnPup(6);  // default InputMode::IPUP
MtButton nextTest(5);
MtButton prevTest(4);

void setup() {
    Serial.begin(115200);
    Serial.println("setup");
    g_test = 3;
    btnPdwn.begin();
    btnPup.begin();
    nextTest.begin();
    prevTest.begin();
 
}

void loop() {
  btnPdwn.read();
  btnPup.read();
  nextTest.read();
  prevTest.read();
  if (prevTest.wasPressed()) {
      g_test = (((g_test -1) % (4)) + (4)) % (4);
  } else if (nextTest.wasPressed()) {
      g_test = (g_test + 1) % (4);
  } 
  if (g_oldTest != g_test) {
      g_onEntry = true;
      g_oldTest = g_test;
  } else {
      g_onEntry = false;
  }
  switch(g_test) {
      case 0:
        if (g_onEntry) {
            Serial.println("isPressed test.");
        }
        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 > 200) {
                g_test = 1;
                g_cnt = 0;
            }*/
        }
      break;
      case 1:
        if (g_onEntry) {
            Serial.println("wasPressed() test.");
        }
        if (btnPdwn.wasPressed()) {
            Serial.println("redleft");
            g_cnt++;
        } else if (btnPup.wasPressed()) {
            Serial.println("redRight");
            g_cnt++;
        }
        /*if (g_cnt > 3) {
            g_test = 2;
            g_cnt = 0;
        }*/

      break;
      case 2:
        if (g_onEntry) {
            Serial.println("wasPressedFor() test.");
        }
        if (btnPdwn.wasPressedFor(500)) {
            Serial.println("redleft 500");
            g_cnt++;
        } else if (btnPup.wasPressedFor(1500)) {
            Serial.println("redRight 1500");
            g_cnt++;
        }
        /*if (g_cnt > 3) {
            g_cnt = 0;
            g_test = 3;
            Serial.println("rilascia il pulsante");
            delay(1000);
        }*/


      break;
    case 3:
      if (g_onEntry) {
          Serial.println("isPressed_r() test.");
      }
      if (btnPdwn.isPressed_r(100, 50)) {
        if (g_cnt > 0) {
            g_cnt--;
            Serial.println(g_cnt);
        }
            
      } else if (btnPup.isPressed_r(100, 50)) {
          g_cnt++;
         Serial.println(g_cnt);
         /*if (g_cnt > 120) {
            g_test = 2;
            g_cnt = 0;
          }*/
      }

    break;

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

  }
  */

}


testmtbutton.ino

diagram.json

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

# Automatically added based on includes:
SSD1306Ascii
LedControl

libraries.txt

# JCBUTTON
Ci sto lavorando, sembra funzionare.
Devo documentare il codice:
* [1] if (trigger) è vero solo alla pressione del pulsante
ma al secondo ciclo trigger(false) e resta false finché
m_timeRepeat viene portato a 0 progressivamente.
~~~
bool isPressed(uint16_t time) {
    bool trigger = m_state && m_changed && !m_timeRepeat;
    
    // [1] trigger è vero:
    // * Alla prima pressione
    // * Al rilascio m_timeRepeat viene ricaricato a tempo
    //   fino a valore > @time è subito azzerato, una nuova 
    //   pressione sul pulsante quando m_timeRepeat(0).
    //   
    // trigger è falso;
    // * Durante la pressione
    // * Al rilascio e pressione
    
    if (trigger) {  // [1]
        m_lastRepeat = millis();
        m_timeRepeat = time;
    } else if (m_state) {   // [2]
        if (millis() - m_lastRepeat >= m_timeRepeat) {
            m_lastRepeat = millis();
            trigger = true;  // stato di uscita dalla funzione
            // riduzione di @m_timeRepeat
            if (m_timeRepeat > 10) {
                m_timeRepeat -= log(m_timeRepeat) * pow(m_timeRepeat, 0.25);
            } 
        }
    } else if (m_timeRepeat && (m_timeRepeat < time)) {  // [3]
        if (millis() - m_lastRepeat >= 100 /*m_timeRepeat*/) {
            m_lastRepeat = millis();
            m_timeRepeat += log(m_timeRepeat) * pow(m_timeRepeat, 0.5);
            if (m_timeRepeat > time) {
                m_timeRepeat = 0;
            }
            Serial.println(m_timeRepeat);
        }
    }
} // end isPressed(uint16_t time)
~~~

* [2] @m_state è vero se il pulsante è premuto e mantenuto.
  @m_timeRepeat finché > 10 viene ridotto dalla seguente equazione:
  
  `m_timeRepeat -= log(m_timeRepeat) * pow(m_timeRepeat, 0.25)`

* [3] Se @m_state è falso e `m_timeRepeat` != 0 e `m_timeRepeat` < `time` avviene la ricarica
  di `m_timeRepeat` ad intervalli regolari di 100 ms.
  La ricarica avviene secondo la seguente equazione:

  `m_timeRepeat += log(m_timeRepeat) * pow(m_timeRepeat, 0.5)`

  Quando `m_timeRepeat` > `time`, `m_timeRepeat` viene azzerato.

# Riduzione di m_timeRepeat 

| Ripetizione | m_timeRepeat (ms)  |    
| ------------| ------------- |    
| 1           | 300           |
| 2           | 276           |
| 3           | 253           |
| 4           | 230           |
| 5           | 208           |
| 6           | 187           |
| 7           | 167           |
| 8           | 148           |
| 9           | 130           |
| 10          | 113           |
| 11          | 97            |
| 12          | 82            |
| 13          | 68            |
| 14           | 55           |
| 15           | 44           |
| 16           | 34           |
| 17           | 25           |
| 18           | 17           |
| 19           | 11           |
| 20           | 6            |
 
La 1° ripetizione avviene 300ms dopo la pressione del pulsante.
La 2° dopo 276 ms, la 3° dopo 253 ms ecc. L'ultima (20°) ripetizione
avviene dopo 6 ms e resta 6 ms finché viene mantenuto premuto il pulsante. 

# Auto ricarica al punto [3]
Questa funzione è stata al momento commentata. Il motivo è
che `m_timeRepeat` potrebbe non tornare mai a zero.
Supponiamo di chiamare la funzione all'interno di case 1, come di seguito:

~~~
case 1:
    if (btnPup.isPressed_r(100, 30)) {
        g_cnt++;
        if (g_cnt > 120) {
            g_test = 2;  
            g_cnt = 0;
            // al prossimo ciclo btnPup.isPressed_r(100, 30)
            // non viene chiamata.
        }
    }
    break;
~~~

# Analisi di read() 

~~~
bool MtButton::read() {
    uint32_t ms = millis(); [1]
            
    if (ms - m_lastChange < m_dbDt) {  // [if 1]
        m_changed = false;
    } else  {
~~~
[1] `ms` riflette il tempo di ciclo. Inizialmente:
* `ms` is(0), m_changed is(false), m_dbDt is(25) e m_lastChange is(false)
* [if 1] if (0 - 0 < 25) si 0 è < di 25: RUN(m_changed = false)
* [if 1] if (26 - 0 < 25) no 26 non è < 25: RUN (else)

**_Risultato:_**
`m_lastChange` non potrà cambiare per 25ms dall'accensione.
**note:** Assicurarsi che il `setup()` duri almeno 26ms, o meglio
che il `setup()` duri almeno m_dbDt + 1.

# Analisi di else {}
~~~
    } else  {
        // [read 3] salva m_state in m_lastState
        // qui m_state riflette lo stato precedente
        m_lastState = m_state;
        // [read 4] adesso m_state riflette lo stato corrente
        m_state = getPinState();
        // [read 5] se m_state != m_lastState m_changed istrue
        m_changed = (m_state != m_lastState); [else 1]
        if (m_changed) { // Se m_changed istrue
            // salva il tempo di ciclo in m_lastChange
            m_lastChange = ms;
    }
~~~
[else 1] Se `m_state != m_lastState`:
* m_changed is(true)
* m_lastChange is(ms) con ms > m_dbDt + 1, (ms > 25)

Se m_changed is(false) pulante non premuto:
* `m_state = m_lastState = m_changed = false`

# Alla pressione del pulsante
* `m_lastState` is(false), `m_state` is(true), `m_changed` is(true).
`m_lastChange` = ms: es m_lastChange = 200ms.

## Al prossimo ciclo
Vedi [if 1]
~~~
  if (ms - m_lastChange < m_dbDt)
~~~
Se (200 - 200 < 25) si 0 < 25: `m_changed` is(false);
Se `ms` >= 226: RUN(else)
:else:  'm_lastState = m_state` is(true) 

~~~
bool MtButton::read() {
    uint32_t ms = millis();
            
    if (ms - m_lastChange < m_dbDt) {
        m_changed = false;
    } else  {
        
        // [read 3] salva m_state in m_lastState
        // qui m_state riflette lo stato precedente
        m_lastState = m_state;
        // [read 4] adesso m_state riflette lo stato corrente
        m_state = getPinState();
        // [read 5] se m_state != m_lastState m_changed istrue
        m_changed = (m_state != m_lastState);
        if (m_changed) { // Se m_changed istrue
            // salva il tempo di ciclo in m_lastChange
            m_lastChange = ms;
        }
    }
    if (!m_state & m_wasTrigger)
        m_wasTrigger = false;
    if (m_timeRepeat && !m_state)
        m_timeRepeat = 0;
    m_time = ms;
    return m_state;
}

~~~

readme.md

#ifndef _MT_BUTTON_H_
#define _MT_BUTTON_H_
/**
    @file MtButton.h  Ver 0.8.0
    @brief MtButton è una classe per gestire in modo facile e conveniente i pulsanti.
    @detail MtButton è molto simile alle altre classi da cui traè ispirazione, ad esempio
    JC_BUTTON.
*/
#include <Arduino.h>

#if defined (ARDUINO_ARCH_SAMD) || defined (INPUT_PULLDOWN)
  #ifndef HAVE_PULL_DOWN
    #define HAVE_PULL_DOWN
  #endif
#endif

/** 
*/
enum InputMode { 
      IPUP
    , EXPUP
    , EXPDWN
// INPUT_PULLDOWN non è una macro ma un enum su core SAMD
// INPUT_PULLDOWN è una macro nel core ESP32
#ifdef HAVE_PULL_DOWN
    IPDWN 
#endif
};

class MtButton {
  public:
      // Required parameter:
      // pin      The Arduino pin the button is connected to
      //
      // Optional parameters:
      // mode = IPUP | EXPUP | EXPDWN | IPDWN (default IPUP)
      
      MtButton(uint8_t pin, InputMode mode = IPUP)
            : m_pin(pin), m_pinMode(mode) {
          
      }

      // chiama begin() all'interno del setup()
      void begin();    
      
      /** Set debounce time (default debounce time is 5ms) */
      void setDebounceTime(uint8_t dt) {
          if (dt >= 5) 
              m_dbDt = dt;
      }

      // Returns the current debounced button state, true for pressed,
      // false for released. Call this function frequently to ensure
      // the sketch is responsive to user input.
      bool read();

      bool isPressed_r(uint16_t time, uint8_t minSpeed = 20);

      // Returns true if the button state was pressed at the last call to read().
      // Does not cause the button to be read.
      
      bool isPressed() {
          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() {
          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() {
          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() {
          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) {
          //Serial.println(m_changed);
          return m_state && (m_time - m_lastChange >= 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) {
          return !m_state && (m_time - m_lastChange >= ms);
      }
      // come wasPressed(), ma restituisce true dopo ms
      bool wasPressedFor(uint32_t ms) {
          bool wasTrigger = !m_wasTrigger && pressedFor(ms);
          if (wasTrigger) {
              m_wasTrigger = true;
          }
     
          return wasTrigger;
      }

      // Returns the time in milliseconds (from millis) that the button last
      // changed state.
      uint32_t lastChange() {
          return m_lastChange;
      }
  protected:
      //void begin();
      bool getPinState() const {
          return m_inverted ^ digitalRead(m_pin);
      }

  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_wasTrigger;
      uint16_t m_timeRepeat;
      uint32_t m_lastRepeat;
      uint32_t m_time;        // time of current state (ms from millis)
      uint32_t m_lastChange;  // time of last state change (ms)
      uint16_t m_dbDt;         // debounce time (ms)
      
};

#endif


mtbutton.h


#include "mtbutton.h"
#define DFLT_DEBOUNCE 100
/*----------------------------------------------------------------------*
/ initialize a Button object and the pin it's connected to.             *
/-----------------------------------------------------------------------*/
void MtButton::begin() {
   m_dbDt = 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;
}

/*----------------------------------------------------------------------*
/ returns the state of the button, true if pressed, false if released.  *
/ does debouncing, captures and maintains times, previous state, etc.   *
/-----------------------------------------------------------------------*/
bool MtButton::read() {
    uint32_t ms = millis();
            
    if (ms - m_lastChange < m_dbDt) {
        m_changed = false;
    } else  {
        
        // [read 3] salva m_state in m_lastState
        // qui m_state riflette lo stato precedente
        m_lastState = m_state;
        // [read 4] adesso m_state riflette lo stato corrente
        m_state = getPinState();
        // [read 5] se m_state != m_lastState m_changed istrue
        m_changed = (m_state != m_lastState);
        if (m_changed) { // Se m_changed istrue
            // salva il tempo di ciclo in m_lastChange
            m_lastChange = ms;
        } // else if (m_state)
    }
    if (m_changed && !m_state) {
        if (m_wasTrigger) 
            m_wasTrigger = false;
                            
        if (m_timeRepeat)
            m_timeRepeat = 0;
    }
    
    m_time = ms;
    return m_state;
}

bool MtButton::isPressed_r(uint16_t time, uint8_t minSpeed = 20) {
    //     HIGH  <-  HIGH  &&    HIGH   &&      HIGH
    bool trigger = m_state && m_changed && !m_timeRepeat;
    // [1]
    if (trigger) {
        // save last time it's fire
        //Serial.println("t");
        m_lastRepeat = m_time;//millis();
        // now !m_timeRepeat is false then trigger is false 
        // and not enter in this if.
        // see [3]
        m_timeRepeat = time;
    // [2]    
    } else if (m_state) {
        
        if (m_time - m_lastRepeat >= m_timeRepeat) {
            m_lastRepeat = m_time;
            trigger = true;
            if (m_timeRepeat > minSpeed) {
                m_timeRepeat -= log(m_timeRepeat) * pow(m_timeRepeat, 0.25);
            } 
        }
    // [3]
    } 
    #if(0)
    // ricarica m_timeRepeat, quindi è possibile
    // rilasciare il pulsante e ripremerlo.
    // Però c'è il rischio che m_timeRepeat non venga 
    // mai azzerato.
    else if (m_timeRepeat && (m_timeRepeat < time)) {
        //if (millis() - m_lastRepeat >= 100 /*m_timeRepeat*/) {
        if (m_time - m_lastRepeat >= 100 /*m_timeRepeat*/) {  
            //m_lastRepeat = millis();
            m_lastRepeat = m_time;
            m_timeRepeat += log(m_timeRepeat) * pow(m_timeRepeat, 0.5);
            if (m_timeRepeat > time) {
                m_timeRepeat = 0;
            }
          #ifdef MTBUTTON_DEBUG
            Serial.println(m_timeRepeat);
          #endif
        }
    }
    #endif
    return trigger;
}

/*----------------------------------------------------------------------*
 * 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.                  *
 *----------------------------------------------------------------------*/

/*----------------------------------------------------------------------*
 * 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.                  *
 *----------------------------------------------------------------------*/

/*----------------------------------------------------------------------*
 * 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 (!=0) accordingly.   *
 * These functions do not cause the button to be read.                  *
 *----------------------------------------------------------------------*/

/*----------------------------------------------------------------------*
 * lastChange() returns the time the button last changed state,         *
 * in milliseconds.                                                     *
 *----------------------------------------------------------------------*/


mtbutton.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++;\
    }\
}