Bugfix, Refactoring

Author: DoImant

library.json

@@ -1,6 +1,6 @@
 {
   "name": "Button_SL",
-  "version": "1.1.6",
+  "version": "1.1.7",
 	"keywords": "button, debounce, signal, input, ouput",
   "description": "Button_SL enables the query of buttons. The query is debounced. A query can be made as to whether the button was pressed for a short or long time.",
   "repository": {

library.properties

@@ -1,5 +1,5 @@
 name=Button_SL
-version=1.1.6
+version=1.1.7
 author=Kai R.
 maintainer=Kai R. 
 sentence=Button query

src/Button_SL.cpp

@@ -25,9 +25,18 @@
 /// @version 1.1.4        Repeated debounce in the button class removed.
 ///
 /// @date 2024-07-06
-/// @version 1.1.5        The autorelease is only executed once as long as the button has not been released. 
-///                       Previously, if the button was held down continuously, the autorelease was executed 
-///                       every time the time for a long button press expired. 
+/// @version 1.1.5        The autorelease is only executed once as long as the button has not been released.
+///                       Previously, if the button was held down continuously, the autorelease was executed
+///                       every time the time for a long button press expired.
+///
+/// @date 2025-05-10
+/// @version 1.1.6        The ButtonState::pressed status has been added.
+///                       For a long button press with automatic release enabled, the ButtonState::longPressed status 
+///                       is returned once when the defined time for a long button press is reached. Then 
+///                       the ButtonState::pressed status is returned as long as the button is held down.
+///
+/// @date 2025-05-26
+/// @version 1.1.7        tick() Method code rework. Bug fix.
 ///
 /// @copyright Copyright (c) 2022
 /// MIT license, check license.md for more information
@@ -58,10 +67,10 @@ bool Button::tick() {
     switch (compareState) {
       case LOW:
         compareState = HIGH;   // set to HIGH when Button was pressed
-        timeStamp = millis();
+        timestamp = millis();
         [[fallthrough]];
       case HIGH:
-        if (millis() - timeStamp > dbTime_ms) {
+        if (millis() - timestamp > dbTime_ms) {
           // If the button press is equal to the specified debounce time, confirm the button press with true.
           flag = true;
         }
@@ -84,30 +93,50 @@ void Button::setDebounceTime_ms(uint16_t dbT_ms) { dbTime_ms = dbT_ms; }
 /// @brief The ButtonSL query. The tick() method should be called in an endless loop.
 ///
 /// @param time_ms        time (in ms) from which a key press is recognized as long
-/// @return ButtonState   The states are "Not pressed", "short pressed" and "long pressed"
+/// @return ButtonState   The states are "not pressed", "pressed", "short pressed" and "long pressed"
 //////////////////////////////////////////////////////////////////////////////
+
 ButtonState ButtonSL::tick() {
-  uint_least32_t now = millis();
   compareState = state;
   state = digitalRead(pin);
-  if (state == activeState && compareState != activeState) {
-    timeStamp = now;
-    hasReleased = false;
-  } else if (state != activeState && compareState == activeState) {
-    timeStamp = now - timeStamp;
-    if (timeStamp >= dbTime_ms && !hasReleased) {   // released after debounce time?
-      return (timeStamp >= time_ms) ? ButtonState::longPressed : ButtonState::shortPressed;
-    }
-    // hasReleased = false;
-  } else if (autoRelease && not hasReleased && (compareState == activeState)) {
-    if (now - timeStamp >= time_ms) {
-      // state = !compareState;
-      hasReleased = true;
-      timeStamp = time_ms;
-      return ButtonState::longPressed;
-    }
+  
+  MillisType now = millis();
+  if (state != activeState && compareState != activeState) {          // not pressed
+    return ButtonState::notPressed;
+  } else if (state == activeState && compareState != activeState) {   // Not pressed to pressed
+    timestamp = now;
+    autoReleaseFired = false;
+    pin_state = Condition::notPressedToPressed;
+  } else if (state == activeState && compareState == activeState) {   // pressed
+    pin_state = Condition::pressed;
+  } else if (state != activeState && compareState == activeState) {   //  Pressed to not pressed
+    pin_state = Condition::pressedToNotpressed;
+  } 
+
+  switch (pin_state) {
+    case Condition::notPressedToPressed:
+    case Condition::pressed:
+      if (autoRelease) {
+        switch (autoReleaseFired) {
+          case true: return ButtonState::pressed; break;
+          case false:
+            if (now - timestamp >= time_ms) {
+              autoReleaseFired = true;
+              timestamp = time_ms;
+              return ButtonState::longPressed;
+            }
+        }
+      }
+      break;
+    case Condition::pressedToNotpressed:
+      timestamp = now - timestamp;
+      // Push duration longer than the debounce time?
+      if (timestamp >= dbTime_ms && !autoReleaseFired) {
+        return (timestamp >= time_ms) ? ButtonState::longPressed : ButtonState::shortPressed;
+      }
+      break;
   }
-  return hasReleased ? ButtonState::pressed : ButtonState::notPressed;
+  return ButtonState::notPressed;
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -122,5 +151,5 @@ void ButtonSL::setTimeThreshold_ms(uint16_t th_ms) { time_ms = th_ms; }
 ///
 /// @return uint32_t Time in milliseconds
 //////////////////////////////////////////////////////////////////////////////
-uint32_t ButtonSL::getDuration_ms(void) const { return timeStamp; }
+uint32_t ButtonSL::getDuration_ms(void) const { return timestamp; }
 }   // namespace Btn

src/Button_SL.hpp

@@ -17,15 +17,21 @@
 /// All text above must be included in any redistribution
 //////////////////////////////////////////////////////////////////////////////
 
-#ifndef _BUTTON_SL_HPP_
-#define _BUTTON_SL_HPP_
+#pragma once
+
 #include <Arduino.h>
 
 namespace Btn {
+
+//////////////////////////////////////////////////
+// Type alias(es)
+//////////////////////////////////////////////////
+using MillisType = decltype(millis());
+
 //////////////////////////////////////////////////
 // Constants
 //////////////////////////////////////////////////
-constexpr uint8_t DEBOUNCE_TIME{30};   // The value can be reduced for buttons that bounce little. Time in ms.
+constexpr uint8_t DEBOUNCE_TIME {30};   // The value can be reduced for buttons that bounce little. Time in ms.
 
 //////////////////////////////////////////////////
 // Variables and Classdefinitions
@@ -40,20 +46,20 @@ enum class ButtonState : uint8_t { notPressed = false, pressed = true, shortPres
 //////////////////////////////////////////////////////////////////////////////
 class Button {
 public:
-  Button(uint8_t pinNr = 0, bool as = LOW) : pin{pinNr}, activeState{as} {}
-  Button(const Button &) = delete;              // No copy constructor
-  Button &operator=(const Button &) = delete;   // No assignment
-  Button(Button &&) = default;                  // Move it
+  Button(uint8_t pinNr = 0, bool as = LOW) : pin {pinNr}, activeState {as} {}
+  Button(const Button&) = delete;              // No copy constructor
+  Button& operator=(const Button&) = delete;   // No assignment
+  Button(Button&&) = default;                  // Move it
   void begin();
   bool tick();
   void setDebounceTime_ms(uint16_t);
 
 protected:
   uint8_t pin;           // Button PIN number
   uint8_t activeState;   // Saves whether the buttons active state is HIGH or LOW.
-  uint8_t compareState{LOW};
-  uint16_t dbTime_ms{DEBOUNCE_TIME};
-  uint_least32_t timeStamp;
+  uint8_t compareState {LOW};
+  uint16_t dbTime_ms {DEBOUNCE_TIME};
+  MillisType timestamp;
 };
 
 //////////////////////////////////////////////////////////////////////////////
@@ -63,19 +69,19 @@ class Button {
 //////////////////////////////////////////////////////////////////////////////
 class ButtonSL : public Button {
 public:
-  ButtonSL(uint8_t pinNr = 0, uint16_t t_ms = 1000, bool as = LOW) : Button{pinNr, as} { time_ms = t_ms; }
+  ButtonSL(uint8_t pinNr = 0, uint16_t t_ms = 1000, bool as = LOW) : Button {pinNr, as} { time_ms = t_ms; }
   ButtonState tick();
   void setTimeThreshold_ms(uint16_t);
   void releaseOn() { autoRelease = true; }
   void releaseOff() { autoRelease = false; }
   uint32_t getDuration_ms() const;
 
 private:
-  uint16_t time_ms;   // Saves the time (in ms) from which a key press is recognized as long.
-  uint8_t state{!activeState};
-  uint16_t pressingTime;   // Saves the length of time that the button was pressed (ms).
-  bool autoRelease{false};
-  bool hasReleased{false};
+  uint16_t time_ms;        // Saves the time (in ms) from which a key press is recognized as long.
+  uint8_t state {!activeState};
+  bool autoRelease {false};
+  bool autoReleaseFired {false};
+  enum class Condition : byte { notPressedToPressed, pressed, pressedToNotpressed };
+  Condition pin_state {Condition::pressedToNotpressed};
 };
 }   // namespace Btn
-#endif