Struct embedded_controls::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 clock = SysClock::new();
let mut encoder = MyEncoder::new(
    pin_a.into_active_low_switch(),
    pin_b.into_active_low_switch(),
);

loop {
    match encoder.update(clock.now()).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
    SwitchA::Error: From<SwitchB::Error>,

type Timestamp = <<Config as DebouncedInputConfig>::Timer as ElapsedTimer>::Timestamp

type Event = EncoderEvent

type Error = <SwitchA as InputSwitch>::Error

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

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