new class LongPressDetector

- new class LongPressDetector added to easily detect long presses of buttons
- new example added to show difference between old approache and new simplified approach
- corrected `lastChange()` behaviour of all derived classes (previously reported value from base class which may differ)

Author: solamyl

README.md

@@ -27,8 +27,9 @@ The following example sketches are included with the **Mini_Button** library:
 
 - **SimpleOnOff**: Just turns the Arduino's pin 13 LED on and off.
 - **LongPress**: Demonstrates detecting long and short button presses.
+- **LongPress-LongPressDetector**: The same example as in JC_Button, but simplified using a new class `LongPressDetector`.
 - **UpDown**: Counts up or down, one number at a time or rapidly by holding the button down.
-- **UpDown-AutoRepeatButton**: Example `UpDown` from JC_Button, but made easily with `AutoRepeatButton`.
+- **UpDown-AutoRepeatButton**: The same example as in JC_Button, but made easily with a new class `AutoRepeatButton`.
 - **Toggle**: Demonstrates ToggleButton functionality.
 
 
@@ -60,15 +61,15 @@ Button myButton(4, 25, false, false);
 
 ```
 
-### ToggleButton(pin, initialState, dbTime, pullup, invert)
+### ToggleButton(pin, initState, dbTime, pullup, invert)
 ##### Description
 The constructor defines a toggle button object, which has "push-on, push-off" functionality. The initial state can be on or off. See the section, [ToggleButton Library Functions](https://github.com/JChristensen/JC_Button#togglebutton-library-functions) for functions that apply specifically to the ToggleButton object. The ToggleButton class is derived from the Button class, so all Button functions are available, but because it is inherently a more limited concept, the special ToggleButton functions will be most useful, along with `begin()` and `read()`.
 ##### Syntax
 `ToggleButton(pin, initialState, dbTime, pullup, invert);`
 ##### Required parameter
 **pin:** Arduino pin number that the button is connected to *(byte)*  
 ##### Optional parameters
-**initialState:** Initial state for the button. Defaults to off (false) if not given. *(bool)*  
+**initState:** Initial state for the button. Defaults to off (false) if not given. *(bool)*  
 **dbTime:** Debounce time in milliseconds, max 60000ms. Defaults to 25ms if not given. *(unsigned long)*  
 **pullup:** *true* to enable the microcontroller's internal pull-up resistor, else *false*. Defaults to *true* if not given. *(bool)*  
 **invert:** *false* interprets a high logic level to mean the button is pressed, *true* interprets a low level as pressed. *true* should be used when a pull-up resistor is employed, *false* for a pull-down resistor. Defaults to *true* if not given. *(bool)*
@@ -194,20 +195,18 @@ The time in milliseconds when the button last changed state *(unsigned long)*
 unsigned long msLastChange = myButton.lastChange();
 ```
 
-## ToggleButton Library Functions
-
 ### changed()
 ##### Description
-Returns a boolean value (true or false) to indicate whether the toggle button changed state the last time `read()` was called.
+Returns a boolean value (true or false) to indicate whether the button changed state the last time `read()` was called.
 ##### Syntax
-`myToggle.changed();`
+`myButton.changed();`
 ##### Parameters
 None.
 ##### Returns
-*true* if the toggle state changed, else *false* *(bool)*
+*true* if the button state changed, else *false* *(bool)*
 ##### Example
 ```c++
-if (myToggle.changed())
+if (myButton.changed())
 {
     // do something
 }
@@ -217,6 +216,8 @@ else
 }
 ```
 
+## ToggleButton Library Functions
+
 ### toggleState()
 ##### Description
 Returns a boolean value (true or false) to indicate the toggle button state as of the last time `read()` was called.

examples/LongPress-LongPressDetector/LongPress-LongPressDetector.ino

@@ -0,0 +1,92 @@
+// Mini_Button Arduino library
+// https://github.com/solamyl/Mini_Button
+// Copyright (C) 2025 by Štěpán Škrob, Copyright (C) 2018 by Jack Christensen
+// licensed under GNU GPL v3.0, https://www.gnu.org/licenses/gpl.html
+//
+// Example sketch demonstrating short and long button presses.
+//
+// A simple state machine where a short press of the button turns the
+// Arduino pin 13 LED on or off, and a long press causes the LED to
+// blink rapidly. Once in rapid blink mode, another long press goes
+// back to on/off mode.
+
+#include <Mini_Button.h>          // https://github.com/solamyl/Mini_Button
+
+// pin assignments
+const byte
+    BUTTON_PIN(7),              // connect a button switch from this pin to ground
+    LED_PIN(13);                // the standard Arduino "pin 13" LED
+
+const unsigned long
+    LONG_PRESS(1000),           // we define a "long press" to be 1000 milliseconds.
+    BLINK_INTERVAL(100);        // in the BLINK state, switch the LED every 100 milliseconds.
+
+Button myBtn(BUTTON_PIN);       // define the button
+LongPressDetector detectLP(&myBtn, LONG_PRESS);
+
+void setup()
+{
+    myBtn.begin();              // initialize the button object
+    detectLP.begin();
+    pinMode(LED_PIN, OUTPUT);   // set the LED pin as an output
+}
+
+// the list of possible states for the state machine. This state machine has a fixed
+// sequence of states, i.e. ONOFF --> BLINK --> ONOFF
+enum states_t {ONOFF, BLINK};
+
+bool ledState;                  // current LED status
+unsigned long ms;               // current time from millis()
+unsigned long msLast;           // last time the LED was switched
+
+void loop()
+{
+    static states_t STATE;      // current state machine state
+    ms = millis();              // record the current time
+    myBtn.read();               // read the button
+    detectLP.read();            // check the button state for a long press
+
+    switch (STATE)
+    {
+        // this state watches for short and long presses, switches the LED for
+        // short presses, and moves to the BLINK state for long presses.
+        case ONOFF:
+            if (detectLP.wasPressed())
+                STATE = BLINK;
+            // distinguish between short-press release and long-press release
+            // LongPressDetector observes the same button so when released
+            // then both `myBtn` and `detectLP` indicate a key release
+            else if (myBtn.wasReleased() && !detectLP.wasReleased())
+                switchLED();
+            break;
+
+        // the fast-blink state. Watch for another long press which will cause us to
+        // turn the LED off (as feedback to the user) and move to the ONOFF state.
+        case BLINK:
+            if (detectLP.wasPressed())
+            {
+                STATE = ONOFF;
+                digitalWrite(LED_PIN, LOW);
+                ledState = false;
+            }
+            else
+                fastBlink();
+            break;
+    }
+}
+
+// reverse the current LED state. if it's on, turn it off. if it's off, turn it on.
+void switchLED()
+{
+    msLast = ms;                // record the last switch time
+    ledState = !ledState;
+    digitalWrite(LED_PIN, ledState);
+}
+
+// switch the LED on and off every BLINK_INTERVAL milliseconds.
+void fastBlink()
+{
+    if (ms - msLast >= BLINK_INTERVAL)
+        switchLED();
+}
+

keywords.txt

@@ -9,6 +9,7 @@ JC_Button	KEYWORD1
 Button	KEYWORD1
 ToggleButton	KEYWORD1
 AutoRepeatButton	KEYWORD1
+LongPressDetector	KEYWORD1
 begin	KEYWORD2
 read	KEYWORD2
 isPressed	KEYWORD2

library.properties

@@ -1,9 +1,9 @@
 name=Mini_Button
-version=1.3.0
+version=1.4.0
 author=Štěpán Škrob, Jack Christensen
 maintainer=Štěpán Škrob <solamy@seznam.cz>
 sentence=Button debouncing library with minimal footprint.
-paragraph=Features autorepeat and two-state button. Provides robust debouncing, low-memory usage and easy API. Forked from JC_Button.
+paragraph=Features autorepeat, long press detection and two-state button. Provides robust debouncing, low-memory usage and easy API. Forked from JC_Button.
 category=Signal Input/Output
 url=https://github.com/solamyl/Mini_Button
 architectures=*

src/Mini_Button.cpp

@@ -54,6 +54,15 @@ bool Button::read()
     return m_state;
 }
 
+
+// Initialize a button object
+void ToggleButton::begin()
+{
+    Button::begin();
+    m_lastChange = millis();
+}
+
+
 // read the button and return its state.
 // should be called frequently.
 bool ToggleButton::read()
@@ -62,10 +71,23 @@ bool ToggleButton::read()
 
     if (Button::wasPressed()) {
         m_toggleState = !m_toggleState;
+        m_lastChange = millis();
     }
     return m_toggleState;
 }
 
+
+// Initialize a button object
+void AutoRepeatButton::begin()
+{
+    Button::begin();
+
+    m_virtualState = Button::isPressed();
+    m_virtualLastState = m_virtualState;
+    m_lastChange = millis();
+}
+
+
 #if 0
 // read the button, obtain physical state and then calculate virtual state
 // repeating is made by inserting fake key-releases into the stream of "pressed" states
@@ -74,35 +96,42 @@ bool AutoRepeatButton::read()
 {
     Button::read(); //read input and do the debouncing
 
+    uint32_t now = millis();
+
     m_virtualLastState = m_virtualState;
     m_virtualState = Button::isPressed();
 
     if (m_virtualState) {
-        uint32_t t = millis() - lastChange();
+        uint32_t t = now - lastChange();
         if (t >= m_delay) { //skip the init delay
             // repeating...
             t -= m_delay;
             t %= m_rate; //cycle in m_rate periods
-            if (t < debounceTime()) //if start of the period
+            if (t < 20/*debounceTime()*/) //if start of the period
                 m_virtualState = false; //make a virtual key release
         }
     }
+    if (changed()) {
+        m_lastChange = now;
+    }
     return m_virtualState;
 }
 
 #else
 
-// alternative implementation, previous may not work correctly for slower loop()
+// alternative implementation
+// previous may not work correctly for slower loop() and/or faster rates
 bool AutoRepeatButton::read()
 {
     Button::read(); //read input and do the debouncing
+    uint32_t now = millis();
 
     m_virtualLastState = m_virtualState;
     m_virtualState = Button::isPressed();
 
     if (m_virtualState) {
         // someone is holding the button
-        uint32_t t = millis() - lastChange(); //how long?
+        uint32_t t = now - lastChange(); //how long?
         if (t >= m_delay) {
             // do the repeating after m_delay has elapsed
             t -= m_delay;
@@ -112,14 +141,48 @@ bool AutoRepeatButton::read()
                 m_virtualState = false; //make a virtual key release
                 m_repeatCounter++;
             }
+            /*Serial.print(millis());
+            Serial.print(": repeat=");
+            Serial.print(m_repeatCounter);
+            Serial.print(", cnt=");
+            Serial.print(cnt);
+            Serial.print(", lastState=");
+            Serial.print(m_virtualLastState);
+            Serial.print(", state=");
+            Serial.print(m_virtualState);
+            Serial.println();*/
         }
     }
     else {
         // physical button is released
         m_repeatCounter = 0;
     }
+    if (changed()) {
+        m_lastChange = now;
+    }
     return m_virtualState;
 }
 #endif
 
 
+// Initialize a Detector object
+void LongPressDetector::begin()
+{
+    m_state = m_buttonPtr->isPressed();
+    m_lastState = m_state;
+    m_lastChange = millis();
+}
+
+
+// Observes specified (another) button for a long press and then updates its state.
+// Does not any physical button input reading! Just observes the state of another class!
+// Call this function frequently to ensure the sketch is responsive to user input.
+bool LongPressDetector::read()
+{
+    m_lastState = m_state;
+    m_state = pressedFor(m_delay);
+    if (changed()) {
+        m_lastChange = millis();
+    }
+    return m_state;
+}