tap_hold.hpp

Go to the documentation of this file.

// sbl/components/control/tap_hold.hpp — Tap vs hold detector
//
// Wraps a Button's pressed/released state to distinguish short taps
// from long holds. Feed it pressed() and just_released() each tick.
//
// - tapped():             true once after a short press (< threshold)
// - held():               true once when hold threshold is reached
// - released_from_hold(): true once when released after a hold
//
// All edge reads are consuming — they return true once then reset.
//
// Usage:
//   sbl::components::control::TapHold th(60);  // 300ms at 200 Hz
//   // In your control loop:
//   th.update(button.pressed(), button.just_released());
//   if (th.tapped()) { /* short press action */ }
//   if (th.held())   { /* long press action */ }
 
#pragma once
 
#include <cstdint>
 
namespace sbl {
namespace components {
namespace control {
 
class TapHold {
public:
    /// @param hold_threshold Ticks before press becomes a hold.
    explicit TapHold(uint16_t hold_threshold = 60)
        : threshold_(hold_threshold) {}
 
    /// Call every tick with the button's current pressed state and release edge.
    void update(bool pressed, bool just_released) {
        if (pressed) {
            ticks_++;
            if (!hold_fired_ && ticks_ >= threshold_) {
                hold_edge_ = true;
                hold_fired_ = true;
            }
        }
 
        if (just_released) {
            if (!hold_fired_ && ticks_ > 0) {
                tap_edge_ = true;
            }
            if (hold_fired_) {
                release_from_hold_edge_ = true;
            }
            ticks_ = 0;
            hold_fired_ = false;
        }
    }
 
    /// True once after a short press (released before hold threshold).
    bool tapped() {
        bool e = tap_edge_;
        tap_edge_ = false;
        return e;
    }
 
    /// True once when hold threshold is reached (while still pressed).
    bool held() {
        bool e = hold_edge_;
        hold_edge_ = false;
        return e;
    }
 
    /// True once when released after a hold.
    bool released_from_hold() {
        bool e = release_from_hold_edge_;
        release_from_hold_edge_ = false;
        return e;
    }
 
    /// Currently in held state (pressed past threshold, not yet released).
    bool holding() const { return hold_fired_; }
 
    /// Current tick count (0 when not pressed).
    uint16_t hold_ticks() const { return ticks_; }
 
    void reset() {
        ticks_ = 0;
        hold_fired_ = false;
        tap_edge_ = false;
        hold_edge_ = false;
        release_from_hold_edge_ = false;
    }
 
private:
    uint16_t threshold_;
    uint16_t ticks_ = 0;
    bool hold_fired_ = false;
    bool tap_edge_ = false;
    bool hold_edge_ = false;
    bool release_from_hold_edge_ = false;
};
 
} // namespace control
} // namespace components
} // namespace sbl