button_event_detector.hpp

Go to the documentation of this file.

/*
 * SPDX-FileCopyrightText: 2026 M5Stack Technology CO LTD
 *
 * SPDX-License-Identifier: MIT
 */
#ifndef M5_UNIT_KEYBOARD_UTILITY_BUTTON_EVENT_DETECTOR_HPP
#define M5_UNIT_KEYBOARD_UTILITY_BUTTON_EVENT_DETECTOR_HPP
 
#include <cstdint>
 
namespace m5 {
namespace unit {
namespace keyboard_bitwise {
 
enum class ButtonEvent : uint8_t {
    None,
    PressDown,
    PressUp,
    SingleClick,
    DoubleClick,
    LongPressStart,
    LongPressUp,
};
 
class ButtonEventDetector {
public:
    struct config_t {
        uint32_t short_press_ms{200};  
        uint32_t long_press_ms{400};   
    };
 
    ButtonEventDetector() : _cfg()
    {
    }
 
    explicit ButtonEventDetector(const config_t& cfg) : _cfg(cfg)
    {
    }
 
    inline void reset()
    {
        _state  = State::Idle;
        _repeat = 0;
        _t0     = 0U;
    }
 
    ButtonEvent edge(const bool pressed, const uint32_t now_ms)
    {
        switch (_state) {
            case State::Idle:
                if (pressed) {
                    _repeat = 1;
                    _t0     = now_ms;
                    _state  = State::Down;
                    return ButtonEvent::PressDown;
                }
                return ButtonEvent::None;
 
            case State::Down:
                if (!pressed) {
                    _t0    = now_ms;
                    _state = State::WaitRepeat;
                    return ButtonEvent::PressUp;
                }
                return ButtonEvent::None;  // hardware repeat — ignore
 
            case State::WaitRepeat:
                if (pressed) {
                    ++_repeat;
                    _t0    = now_ms;
                    _state = State::RepeatDown;
                    return ButtonEvent::PressDown;
                }
                return ButtonEvent::None;
 
            case State::RepeatDown:
                if (!pressed) {
                    _t0    = now_ms;
                    _state = State::WaitRepeat;
                    return ButtonEvent::PressUp;
                }
                return ButtonEvent::None;
 
            case State::LongHold:
                if (!pressed) {
                    _state = State::Idle;
                    return ButtonEvent::LongPressUp;
                }
                return ButtonEvent::None;
        }
        return ButtonEvent::None;
    }
 
    ButtonEvent poll(const uint32_t now_ms)
    {
        switch (_state) {
            case State::Down:
                if (now_ms - _t0 >= _cfg.long_press_ms) {
                    _state = State::LongHold;
                    return ButtonEvent::LongPressStart;
                }
                return ButtonEvent::None;
 
            case State::WaitRepeat:
                if (now_ms - _t0 > _cfg.short_press_ms) {
                    const uint8_t repeat = _repeat;
                    _repeat              = 0;
                    _state               = State::Idle;
                    if (repeat == 1) return ButtonEvent::SingleClick;
                    if (repeat == 2) return ButtonEvent::DoubleClick;
                    return ButtonEvent::None;
                }
                return ButtonEvent::None;
 
            default:
                return ButtonEvent::None;
        }
    }
 
private:
    enum class State : uint8_t { Idle, Down, WaitRepeat, RepeatDown, LongHold };
 
    config_t _cfg{};
    State _state{State::Idle};
    uint8_t _repeat{0};
    uint32_t _t0{0};
};
 
}  // namespace keyboard_bitwise
}  // namespace unit
}  // namespace m5
 
#endif