Struct SoftwareMotionControl 

pub struct SoftwareMotionControl<Driver, Timer, Profile: MotionProfile, Convert, const TIMER_HZ: u32> { /* private fields */ }

Software implementation of motion control capability

Some driver natively support motion control capability. This is a software implementation of the MotionControl trait for those drivers that don’t. It wraps a driver that implements SetDirection and Step, and in turn acts like a driver itself, adding to the wrapped driver’s capabilities.

You can use SoftwareMotionControl directly, but like a driver, it is designed to be used through the Stepper API.

Implementations

impl<Driver, Timer, Profile, Convert, const TIMER_HZ: u32> SoftwareMotionControl<Driver, Timer, Profile, Convert, TIMER_HZ>

where Profile: MotionProfile,

pub fn new( driver: Driver, timer: Timer, profile: Profile, convert: Convert, ) -> Self

Construct a new instance of SoftwareMotionControl

Instead of using this constructor directly, you can instead use Stepper::enable_motion_control with any driver that implements SetDirection and Step, providing timer and a motion profile. This module provides a blanket implementation of EnableMotionControl to make this work.

pub fn driver(&self) -> Option<&Driver>

Access a reference to the wrapped driver

This is only possible if there is no ongoing movement.

pub fn driver_mut(&mut self) -> Option<&mut Driver>

Access a mutable reference to the wrapped driver

This is only possible if there is no ongoing movement.

pub fn timer(&self) -> Option<&Timer>

Access a reference to the wrapped timer

This is only possible if there is no ongoing movement.

pub fn timer_mut(&mut self) -> Option<&mut Timer>

Access a mutable reference to the wrapped timer

This is only possible if there is no ongoing movement.

pub fn profile(&self) -> &Profile

Access a reference to the wrapped motion profile

pub fn profile_mut(&mut self) -> &mut Profile

Access a mutable reference to the wrapped motion profile

pub fn current_step(&self) -> i32

Access the current step

pub fn current_direction(&self) -> Direction

Access the current direction

pub fn set_step_mode( &mut self, step_mode: Driver::StepMode, ) -> Result<SetStepModeFuture<RefMut<'_, Driver>, RefMut<'_, Timer>, TIMER_HZ>, BusyError<Infallible>>

where Driver: SetStepMode, Timer: TimerTrait<TIMER_HZ>,

Set step mode of the wrapped driver

This method is a more convenient alternative to Stepper::set_step_mode, which requires a timer, while this methods reuses the timer that SoftwareMotionControl already owns.

However, while Stepper::set_step_mode is part of the generic API, this method is only available, if you statically know that you’re working with a driver wrapped by SoftwareMotionControl.

Errors

Returns BusyError::Busy, if a motion is ongoing.

pub fn set_direction( &mut self, direction: Direction, ) -> Result<SetDirectionFuture<RefMut<'_, Driver>, RefMut<'_, Timer>, TIMER_HZ>, BusyError<Infallible>>

where Driver: SetDirection, Timer: TimerTrait<TIMER_HZ>,

Set direction of the wrapped driver

This method is a more convenient alternative to Stepper::set_direction, which requires a timer, while this methods reuses the timer that SoftwareMotionControl already owns.

However, while Stepper::set_direction is part of the generic API, this method is only available, if you statically know that you’re working with a driver wrapped by SoftwareMotionControl.

Errors

Returns BusyError::Busy, if a motion is ongoing.

pub fn step( &mut self, ) -> Result<StepFuture<RefMut<'_, Driver>, RefMut<'_, Timer>, TIMER_HZ>, BusyError<Infallible>>

where Driver: Step, Timer: TimerTrait<TIMER_HZ>,

Tell the wrapped driver to move the motor one step

This method is a more convenient alternative to Stepper::step, which requires a timer, while this methods reuses the timer that SoftwareMotionControl already owns.

However, while Stepper::step is part of the generic API, this method is only available, if you statically know that you’re working with a driver wrapped by SoftwareMotionControl.

Errors

Returns BusyError::Busy, if a motion is ongoing.

Trait Implementations

impl<Driver, Timer, Profile, Convert, const TIMER_HZ: u32> MotionControl for SoftwareMotionControl<Driver, Timer, Profile, Convert, TIMER_HZ>

where Driver: SetDirection + Step, Profile: MotionProfile, Timer: TimerTrait<TIMER_HZ>, Profile::Velocity: Copy, Convert: DelayToTicks<Profile::Delay, TIMER_HZ>,

type Velocity = <Profile as MotionProfile>::Velocity

The type used by the driver to represent velocity

type Error = Error<<Driver as SetDirection>::Error, <<Driver as SetDirection>::Dir as ErrorType>::Error, <Driver as Step>::Error, <<Driver as Step>::Step as ErrorType>::Error, <Timer as Timer<TIMER_HZ>>::Error, <Convert as DelayToTicks<<Profile as MotionProfile>::Delay, TIMER_HZ>>::Error>

The type error that can happen when using this trait

fn move_to_position( &mut self, max_velocity: Self::Velocity, target_step: i32, ) -> Result<(), Self::Error>

Move to the given position

fn reset_position(&mut self, step: i32) -> Result<(), Self::Error>

Reset internal position to the given value

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

Update an ongoing motion

impl<Driver, Timer, Profile, Convert, const TIMER_HZ: u32> SetDirection for SoftwareMotionControl<Driver, Timer, Profile, Convert, TIMER_HZ>

where Driver: SetDirection, Profile: MotionProfile,

const SETUP_TIME: Nanoseconds = Driver::SETUP_TIME

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

type Dir = <Driver as SetDirection>::Dir

The type of the DIR pin

type Error = BusyError<<Driver as SetDirection>::Error>

The error that can occur while accessing the DIR pin

fn dir(&mut self) -> Result<&mut Self::Dir, Self::Error>

Provides access to the DIR pin

impl<Driver, Timer, Profile, Convert, const TIMER_HZ: u32> SetStepMode for SoftwareMotionControl<Driver, Timer, Profile, Convert, TIMER_HZ>

where Driver: SetStepMode, Profile: MotionProfile,

const SETUP_TIME: Nanoseconds = Driver::SETUP_TIME

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

const HOLD_TIME: Nanoseconds = Driver::HOLD_TIME

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

type Error = BusyError<<Driver as SetStepMode>::Error>

The error that can occur while using this trait

type StepMode = <Driver as SetStepMode>::StepMode

The type that defines the microstepping mode

fn apply_mode_config( &mut self, step_mode: Self::StepMode, ) -> Result<(), Self::Error>

Apply the new step mode configuration

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

Re-enable the driver after the mode has been set

impl<Driver, Timer, Profile, Convert, const TIMER_HZ: u32> Step for SoftwareMotionControl<Driver, Timer, Profile, Convert, TIMER_HZ>

where Driver: Step, Profile: MotionProfile,

const PULSE_LENGTH: Nanoseconds = Driver::PULSE_LENGTH

The minimum length of a STEP pulse

type Step = <Driver as Step>::Step

The type of the STEP pin

type Error = BusyError<<Driver as Step>::Error>

The error that can occur while accessing the STEP pin

fn step(&mut self) -> Result<&mut Self::Step, Self::Error>

Provides access to the STEP pin