Struct drv8825::util::ref_mut::RefMut

pub struct RefMut<'r, T>(pub &'r mut T);

Generic wrapper around a mutable reference

This is used as a means of implementing traits that are already implemented for T for &mut T too. While this is redundant for the traits from this crate, we couldn’t do this for embedded_hal::timer::CountDown without a crate-local type.

The purpose of this is to make the future types more flexible, making it possible to move types into them, or just provide mutable references.

Tuple Fields

0: &'r mut T

Trait Implementations

impl<'r, T> MotionControl for RefMut<'r, T> where
    T: MotionControl, 

type Velocity = <T as MotionControl>::Velocity

The type used by the driver to represent velocity

type Error = <T as MotionControl>::Error

The type error that can happen when using this trait

fn move_to_position(
    &mut self,
    max_velocity: <RefMut<'r, T> as MotionControl>::Velocity,
    target_step: i32
) -> Result<(), <RefMut<'r, T> as MotionControl>::Error>

Move to the given position

fn reset_position(
    &mut self,
    step: i32
) -> Result<(), <RefMut<'r, T> as MotionControl>::Error>

Reset internal position to the given value

fn update(&mut self) -> Result<bool, <RefMut<'r, T> as MotionControl>::Error>

Update an ongoing motion

impl<'r, T> SetDirection for RefMut<'r, T> where
    T: SetDirection, 

const SETUP_TIME: Duration<u32, 1, 1000000000> = T::SETUP_TIME

The time that the DIR signal must be held for a change to apply

type Dir = <T as SetDirection>::Dir

The type of the DIR pin

type Error = <T as SetDirection>::Error

The error that can occur while accessing the DIR pin

fn dir(
    &mut self
) -> Result<&mut <RefMut<'r, T> as SetDirection>::Dir, <RefMut<'r, T> as SetDirection>::Error>

Provides access to the DIR pin

impl<'r, T> SetStepMode for RefMut<'r, T> where
    T: SetStepMode, 

const SETUP_TIME: Duration<u32, 1, 1000000000> = T::SETUP_TIME

The time the mode signals need to be held before re-enabling the driver

const HOLD_TIME: Duration<u32, 1, 1000000000> = T::HOLD_TIME

The time the mode signals need to be held after re-enabling the driver

type Error = <T as SetStepMode>::Error

The error that can occur while using this trait

type StepMode = <T as SetStepMode>::StepMode

The type that defines the microstepping mode

fn apply_mode_config(
    &mut self,
    step_mode: <RefMut<'r, T> as SetStepMode>::StepMode
) -> Result<(), <RefMut<'r, T> as SetStepMode>::Error>

Apply the new step mode configuration

fn enable_driver(&mut self) -> Result<(), <RefMut<'r, T> as SetStepMode>::Error>

Re-enable the driver after the mode has been set

impl<'r, T> Step for RefMut<'r, T> where
    T: Step, 

const PULSE_LENGTH: Duration<u32, 1, 1000000000> = T::PULSE_LENGTH

The minimum length of a STEP pulse

type Step = <T as Step>::Step

The type of the STEP pin

type Error = <T as Step>::Error

The error that can occur while accessing the STEP pin

fn step(
    &mut self
) -> Result<&mut <RefMut<'r, T> as Step>::Step, <RefMut<'r, T> as Step>::Error>

Provides access to the STEP pin

impl<'r, T, const TIMER_HZ: u32> Timer<TIMER_HZ> for RefMut<'r, T> where
    T: Timer<TIMER_HZ>, 

type Error = <T as Timer<TIMER_HZ>>::Error

An error that might happen during waiting

fn now(&mut self) -> Instant<u32, 1, TIMER_HZ>

Return current time Instant

fn start(
    &mut self,
    duration: Duration<u32, 1, TIMER_HZ>
) -> Result<(), <RefMut<'r, T> as Timer<TIMER_HZ>>::Error>

Start timer with a duration

fn cancel(&mut self) -> Result<(), <RefMut<'r, T> as Timer<TIMER_HZ>>::Error>

Tries to stop this timer. An error will be returned if the timer has already been canceled or was never started. An error is also returned if the timer is not Periodic and has already expired.

fn wait(
    &mut self
) -> Result<(), Error<<RefMut<'r, T> as Timer<TIMER_HZ>>::Error>>

Wait until timer duration has expired. Must return nb::Error::WouldBlock if timer duration is not yet over. Must return OK(()) as soon as timer duration has expired.