Struct Button 

pub struct Button<PIN> { /* private fields */ }

Debounced wrapper around an embedded-hal input pin.

Call Button::update regularly and pass a monotonic millisecond timestamp. The timestamp can come from a hardware timer, a system tick, or any other counter that never goes backwards.

Implementations

impl<PIN> Button<PIN>

pub const fn new(pin: PIN) -> Self

Creates an active-low button with default timings.

pub const fn with_config(pin: PIN, config: ButtonConfig) -> Self

Creates a button with custom timings and polarity.

pub const fn config(&self) -> ButtonConfig

Returns the current configuration.

pub fn set_config(&mut self, config: ButtonConfig)

Replaces the whole configuration.

pub const fn debounce_ms(&self) -> Millis

Returns the current debounce time.

pub fn set_debounce_ms(&mut self, debounce_ms: Millis)

Sets the debounce time.

pub const fn double_click_ms(&self) -> Millis

Returns the current double-click interval.

pub fn set_double_click_ms(&mut self, double_click_ms: Millis)

Sets the double-click interval.

pub const fn hold_ms(&self) -> Millis

Returns the current hold threshold.

pub fn set_hold_ms(&mut self, hold_ms: Millis)

Sets the hold threshold.

pub const fn state(&self) -> ButtonState

Returns the stable debounced state.

pub const fn is_pressed(&self) -> bool

Returns true if the stable debounced state is ButtonState::Pressed.

pub const fn is_released(&self) -> bool

Returns true if the stable debounced state is ButtonState::Released.

pub fn held_ms(&self, now_ms: Millis) -> Option<Millis>

Returns the current debounced hold time.

pub fn pin_mut(&mut self) -> &mut PIN

Returns a mutable reference to the inner pin.

pub fn into_inner(self) -> PIN

Returns the inner pin.

impl<PIN> Button<PIN>

where PIN: InputPin,

pub fn update(&mut self, now_ms: Millis) -> Result<ButtonUpdate, PIN::Error>

Reads the pin once, updates the debouncer, and returns the current state with events.

This method does not block and does not wait for debounce to finish. It should be called regularly with a fresh monotonic timestamp in now_ms.

One call:

1. Reads the physical pin through InputPin::is_high.
2. Converts the electrical level to ButtonState using ActiveLevel.
3. Records a raw state change and its timestamp.
4. Accepts a raw state as stable when it has been unchanged for at least debounce_ms.
5. Emits events.pressed when the stable state becomes ButtonState::Pressed.
6. Emits events.released and released_after_ms when the stable state becomes ButtonState::Released.
7. Stores a pending single click after a short release.
8. Emits events.double_click if a second short click arrives inside double_click_ms, without emitting an earlier events.click.
9. Emits events.click once if the pending click is not followed by a second click before double_click_ms expires.
10. Updates held_ms while the button is pressed and emits events.hold once the hold threshold is reached.

Event flags are valid only for the returned update. Read the stable state from ButtonUpdate::state.