button_status.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2025 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UTILITY_BUTTON_STATUS_HPP
#define M5_UTILITY_BUTTON_STATUS_HPP
 
#include <cstdint>
 
namespace m5 {
namespace utility {
namespace button {
 
class Status {
public:
    enum class button_state_t : uint8_t { state_nochange, state_clicked, state_hold, state_decide_click_count };
 
    explicit Status(const uint16_t hold_ms = 500, const uint16_t debounce_ms = 10, const uint16_t double_click_ms = 0)
        : _msecHold{hold_ms}, _msecDebounce{debounce_ms}, _msecDoubleClick{double_click_ms}
    {
    }
 
    inline void setDebounceThreshold(const uint32_t msec)
    {
        _msecDebounce = static_cast<uint16_t>(msec);
    }
    inline void setHoldThreshold(const uint32_t msec)
    {
        _msecHold = static_cast<uint16_t>(msec);
    }
    inline void setDoubleClickThreshold(const uint32_t msec)
    {
        _msecDoubleClick = static_cast<uint16_t>(msec);
    }
    inline uint32_t getDebounceThreshold(void) const
    {
        return _msecDebounce;
    }
    inline uint32_t getHoldThreshold(void) const
    {
        return _msecHold;
    }
    inline uint32_t getDoubleClickThreshold(void) const
    {
        return _msecDoubleClick ? _msecDoubleClick : _msecHold;
    }
 
    bool isPressed(void) const
    {
        return _press;
    }
    bool isReleased(void) const
    {
        return !_press;
    }
    bool isHolding(void) const
    {
        return _press == 2;
    }
    bool wasPressed(void) const
    {
        return !_oldPress && _press;
    }
    bool wasReleased(void) const
    {
        return _oldPress && !_press;
    }
    bool wasClicked(void) const
    {
        return _currentState == button_state_t::state_clicked;
    }
    bool wasHold(void) const
    {
        return _currentState == button_state_t::state_hold;
    }
    bool wasSingleClicked(void) const
    {
        return _currentState == button_state_t::state_decide_click_count && _clickCount == 1;
    }
    bool wasDoubleClicked(void) const
    {
        return _currentState == button_state_t::state_decide_click_count && _clickCount == 2;
    }
    bool wasDecideClickCount(void) const
    {
        return _currentState == button_state_t::state_decide_click_count;
    }
    uint8_t getClickCount(void) const
    {
        return _clickCount;
    }
    bool wasChangePressed(void) const
    {
        return ((bool)_press) != ((bool)_oldPress);
    }
    bool wasReleasedAfterHold(void) const
    {
        return !_press && _oldPress == 2;
    }
    bool wasReleaseFor(const uint32_t ms) const
    {
        return _oldPress && !_press && _lastHoldPeriod >= ms;
    }
    bool pressedFor(const uint32_t ms) const
    {
        return (_press && _lastMsec - _lastChange >= ms);
    }
    bool releasedFor(const uint32_t ms) const
    {
        return (!_press && _lastMsec - _lastChange >= ms);
    }
 
    void setRawState(const uint32_t msec, const bool press);
    void setState(const uint32_t msec, const button_state_t state);
    inline button_state_t getState(void) const
    {
        return _currentState;
    }
    inline uint32_t lastChange(void) const
    {
        return _lastChange;
    }
    inline uint32_t getUpdateMsec(void) const
    {
        return _lastMsec;
    }
 
private:
    uint16_t _msecHold{500}, _msecDebounce{10};
    // 0 follows _msecHold, which is what this class did before the threshold was separated
    uint16_t _msecDoubleClick{};
    uint32_t _lastMsec{}, _lastChange{}, _lastRawChange{}, _lastClicked{};
    uint16_t _lastHoldPeriod{};
    button_state_t _currentState{button_state_t::state_nochange};
    bool _raw_press{};
    // 0:release  1:click  2:holding
    uint8_t _press{}, _oldPress{}, _clickCount{};
};
 
}  // namespace button
}  // namespace utility
}  // namespace m5
 
#endif