Struct Flat 

pub struct Flat<Num = DefaultNum> { /* private fields */ }

Flat motion profile

This is the simplest possible motion profile, as it produces just a constant velocity. Please note that this is of limited use, and should probably be restricted to testing.

Theoretically, this profile produces infinite acceleration/deceleration at the beginning and end of the movement. In practice, you might get away with this, if the velocity and the load on the motor are low enough. Otherwise, this will definitely produce missed steps.

Create an instance of this struct using Flat::new, then use the API defined by MotionProfile (which this struct implements) to generate the acceleration ramp.

Unit of Time

This code is agnostic on which unit of time is used. If you provide the target velocity in steps per second, the unit of the delay returned will be seconds.

This allows you to pass the target velocity in steps per number of timer counts for the timer you’re using, completely eliminating any conversion overhead for the delay.

Type Parameter

The type parameter Num defines the type that is used to represent the target velocity and the delay per step. It is set to a 32-bit fixed-point number type by default.

This default is appropriate for 32-bit microcontrollers, but it might not be ideal for 8- or 16-bit microcontrollers, or target platforms where hardware support for floating point numbers is available. You can override it with other types from the fixed crate, or f32/f64, for example.

Implementations

impl<Num> Flat<Num>

pub fn new() -> Self

Create a new instance of Flat

Trait Implementations

impl Default for Flat<f32>

fn default() -> Self

Returns the “default value” for a type.

impl<Num> MotionProfile for Flat<Num>

where Num: Copy + Zero + Inv<Output = Num>,

type Velocity = Num

The type used for representing velocities

type Delay = Num

The type used for representing delay values

fn enter_position_mode(&mut self, max_velocity: Self::Velocity, num_steps: u32)

Enter position mode

fn next_delay(&mut self) -> Option<Self::Delay>

Return the next step delay

fn delays(&mut self) -> Delays<'_, Self>

Return an iterator over delay values of each step

fn velocities(&mut self) -> Velocities<'_, Self>

Return an iterator over velocity values of each step

fn accelerations<Accel>(&mut self) -> Accelerations<'_, Self, Accel>

Return an iterator over the acceleration values between steps