Struct Encoder

pub struct Encoder<SwitchA: InputSwitch, SwitchB: InputSwitch, Config: EncoderConfig> { /* private fields */ }

Concrete implementation of encoder.

Type Params

SwitchA - InputSwitch that provides input A channel.

SwitchB - InputSwitch that provides input B channel.

Config - EncoderConfig that provides configs for encoder.

Example

encoder_config!(
    SomeEncoderConfig,
    debounce_timer: MyElapsedTimer = MyElapsedTimer::new(2.millis()),
    counts_div: i8 = 4
);

type MyEncoder<SwitchA, SwitchB> = Encoder<SwitchA, SwitchB, SomeEncoderConfig>;

let mut encoder = MyEncoder::new(
    pin_a.into_active_low_switch(),
    pin_b.into_active_low_switch(),
);

loop {
    match encoder.update().unwrap() {
        EncoderEvent::NoTurn => do_something_when_no_turn(),
        EncoderEvent::ClockwiseTurn => do_something_upon_clockwise_turn(),
        EncoderEvent::CounterClockwiseTurn => do_something_upon_counter_clockwise_turn(),
    }
}

Implementations

impl<SwitchA: InputSwitch, SwitchB: InputSwitch, Config: EncoderConfig> Encoder<SwitchA, SwitchB, Config>

pub fn new(input_switch_a: SwitchA, input_switch_b: SwitchB) -> Self

Creates a new Encoder<SwitchA, SwitchB, Config> from concretes SwitchA, SwitchB.

pub fn release_input_switches(self) -> (SwitchA, SwitchB)

Consumses self and release (SwitchA, SwitchB).

Trait Implementations

impl<SwitchA: InputSwitch, SwitchB: InputSwitch, Config: EncoderConfig> Control for Encoder<SwitchA, SwitchB, Config>

where <DebouncedInput<SwitchA, Config> as Control>::Error: From<<DebouncedInput<SwitchB, Config> as Control>::Error>,

type Event = EncoderEvent

type Error = <DebouncedInput<SwitchA, Config> as Control>::Error

fn update(&mut self) -> Result<Self::Event, Self::Error>

Update a control and return an current event or error after update.