Detect a long press without releasing the button

[avsaase]

I would like to be able to detect long presses without releasing the button.

I tried this:

loop {
    button.tick();
    if let Some(dur) = button.current_holding_time() {
        if dur >= Duration::from_secs(2) {
            info!("Long press");
        }
    }
    button.reset();
    Timer::after_millis(2).await;
}

This works but after the initial delay it repeatedly prints "Long press" until the button is released. I would like it to ignore the button position until it is released so that the "event" is only fired once.

Looking at the code I think the easiest way to enable this behavior is to add a new State:PendingRelease that can be set by the user and a match pattern in tick() like this:

State::PendingRelease if self.is_pin_released() => self.state = State::Released,

WDTY? Does it make sense to add this to your library? I can make a PR with this change or another solution if you want.

[maxwase]

Hmm, it's a good question, let me try to express how I see it:
There are 3 usage scenarios:

1. Measure pressed - released time, then do something based on the duration value
2. Observe current press duration for for ex. printing to the screen
3. (currently missing) Observe current press duration until some threshold, then do some action and reset the threshold awaiting before the release

I hope I caught this right, I agree that this is a valuable feature, it's easier for me to think about it as an alarm.

From the implementation point of view, I don't see a good way straight away, I did't fully understand your suggestion tho, for me State::Held and State::PendingRelease are quite similar...

My first thought was something like this:

loop {
    button.tick();
    button.set_alarm(Duration::from_secs(2));
    if button.is_alarm_gone_off() {
        println!("Long press");
    }
    button.reset();
}

But then I realized that it is impossible to define multiple different alarms with this approach. Of course it is possible to use some kind of HashMap with alarms, but it sounds like an overkill for embedded button handling

So yes, PRs are welcome :)

[avsaase]

My current approach is to do it like this https://github.com/avsaase/button-driver/commit/8e3c8a8e8d9889731ad620191d9a4d87f8d14e58 and then use it like this:

loop {
    button.tick();
    if let Some(dur) = button.current_holding_time()
        && dur >= Duration::from_secs(2)
    {
        button.ignore_untill_release();
        // Fire LongClick event
    }
    button.reset();
}

This lets the library user figure out how they want to detect long presses. I did it this way because the library already exposes the time the button is held but it has some limitations because it stops the timer. It also doesn't allow setting multiple long press thresholds but I think that's unavoidable once you start detecting long presses without releases. I can think about it some more later. Maybe I can come up with something better.

[avsaase]

I ended up creating my own library with a different API that implements this behavior and works in an async context: https://github.com/avsaase/async-button. Feel free to use any of it for inspiration 🙂