Struct rotary_encoder_embedded::RotaryEncoder

pub struct RotaryEncoder<DT, CLK> { /* fields omitted */ }

Rotary Encoder

Implementations

impl<DT, CLK> RotaryEncoder<DT, CLK> where
    DT: InputPin,
    CLK: InputPin, 

pub fn new(
    pin_dt: DT,
    pin_clk: CLK,
    velocity_inc_factor: Option<f32>,
    velocity_dec_factor: Option<f32>,
    velocity_action_ms: Option<i64>
) -> Self

Initiates a new Rotary Encoder, taking two InputPins InputPin. Optionally the behaviour of the angular velocity can be modified: velocity_inc_factor: How quickly the velocity increases to 1.0. velocity_dec_factor: How quickly the velocity decreases or cools-down velocity_action_ms: The window of duration (milliseconds) that the velocity will increase

pub fn tick(&mut self)

This function should be called periodically, either via a timer or the main loop. This function will reduce the angular velocity over time, the amount is configurable via the constructor

pub fn borrow_pins(&mut self) -> (&mut DT, &mut CLK)

Borrow a mutable reference to the underlying InputPins. This is useful for clearing hardware interrupts.

pub fn release(self) -> (DT, CLK)

Release the underying resources such as the InputPins back to the initiator

pub fn update(&mut self, current_time: NaiveDateTime)

Update the state machine of the RotaryEncoder. This should be called ideally from an interrupt vector when either the DT or CLK pins state changes. This function will update the RotaryEncoder’s Direction and current Angular Velocity.

pub fn direction(&self) -> Direction

Returns the current Direction of the RotaryEncoder

pub fn velocity(&self) -> Velocity

Returns the current angular velocity of the RotaryEncoder The Angular Velocity is a value between 0.0 and 1.0 This is useful for incrementing/decrementing a value in an exponential fashion