Struct State 

pub struct State {
    pub position: f32,
    pub velocity: f32,
    pub acceleration: f32,
}

A one-dimensional motion state with position, velocity, and acceleration.

Fields

position: f32

Where you are. This should be in millimeters.

velocity: f32

How fast you’re going. This should be in millimeters per second.

acceleration: f32

How fast how fast you’re going’s changing. This should be in millimeters per second squared.

Implementations

impl State

pub const fn new( position: Quantity, velocity: Quantity, acceleration: Quantity, ) -> Self

Constructor for State using Quantity objects for position, velocity, and acceleration.

pub const fn new_raw(position: f32, velocity: f32, acceleration: f32) -> Self

Constructor for State using raw f32s for position, velocity, and acceleration.

Examples found in repository

examples/devices.rs (line 6)

const STATE: State = State::new_raw(0.0, 0.0, 0.0);

pub fn update(&mut self, delta_time: Time)

Calculate the future state assuming a constant acceleration.

pub const fn set_constant_acceleration( &mut self, acceleration: Quantity, ) -> Result<(), ()>

Set the acceleration with a Quantity. With dimension checking enabled, sets the acceleration and returns Ok if the argument’s Unit is correct, otherwise leaves it unchanged and returns Err. With dimension checking disabled, always sets the acceleration to the Quantity’s value and returns Ok, ignoring the Unit.

pub const fn set_constant_acceleration_raw(&mut self, acceleration: f32)

Set the acceleration with an f32 of millimeters per second squared.

pub const fn set_constant_velocity( &mut self, velocity: Quantity, ) -> Result<(), ()>

Set the velocity to a given value with a Quantity, and set acceleration to zero. With dimension checking enabled, sets the velocity and acceleration and returns Ok if the argument’s Unit is correct, otherwise leaves them unchanged and returns Err. With dimension checking disabled, ignores the Unit and always sets velocity and acceleration and returns Ok.

pub const fn set_constant_velocity_raw(&mut self, velocity: f32)

Set the velocity to a given value with an f32 of millimeters per second, and set acceleration to zero.

pub const fn set_constant_position( &mut self, position: Quantity, ) -> Result<(), ()>

Set the position to a given value with a Quantity, and set velocity and acceleration to zero. With dimension checking enabled, sets the position, velocity, and acceleration and returns Ok if the argument’s Unit is correct, otherwise leaves them unchanged and returns Err. With dimension checking disabled, always sets the position, velocity, and acceleration and returns Ok, ignoring the Unit.

pub const fn set_constant_position_raw(&mut self, position: f32)

Set the position to a given value with an f32 of millimeters, and set velocity and acceleration to zero.

pub const fn get_position(&self) -> Quantity

Get the position as a Quantity.

pub const fn get_velocity(&self) -> Quantity

Get the velocity as a Quantity.

pub const fn get_acceleration(&self) -> Quantity

Get the acceleration as a Quantity.

pub fn get_value(&self, position_derivative: PositionDerivative) -> Quantity

State contains a position, velocity, and acceleration. This gets the respective field of a given position derivative.

Trait Implementations

impl Add for State

type Output = State

The resulting type after applying the + operator.

fn add(self, other: State) -> Self

Performs the + operation.

impl AddAssign for State

fn add_assign(&mut self, other: State)

Performs the += operation.

impl Clone for State

fn clone(&self) -> State

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for State

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for State

fn default() -> State

Returns the “default value” for a type.

impl Div<f32> for State

type Output = State

The resulting type after applying the / operator.

fn div(self, dvsr: f32) -> Self

Performs the / operation.

impl DivAssign<f32> for State

fn div_assign(&mut self, dvsr: f32)

Performs the /= operation.

impl From<State> for Command

fn from(state: State) -> Self

Converts to this type from the input type.

impl<G: Getter<Quantity, E> + ?Sized, E: Copy + Debug> Getter<State, E> for AccelerationToState<G, E>

fn get(&self) -> Output<State, E>

Get something.

impl<G: Getter<Quantity, E> + ?Sized, E: Copy + Debug> Getter<State, E> for PositionToState<G, E>

fn get(&self) -> Output<State, E>

Get something.

impl<E: Copy + Debug> Getter<State, E> for Terminal<'_, E>

fn get(&self) -> Output<State, E>

Get something.

impl<G: Getter<Quantity, E> + ?Sized, E: Copy + Debug> Getter<State, E> for VelocityToState<G, E>

fn get(&self) -> Output<State, E>

Get something.

impl Mul<f32> for State

type Output = State

The resulting type after applying the * operator.

fn mul(self, coef: f32) -> Self

Performs the * operation.

impl MulAssign<f32> for State

fn mul_assign(&mut self, coef: f32)

Performs the *= operation.

impl Neg for State

type Output = State

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl PartialEq for State

fn eq(&self, other: &State) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Sub for State

type Output = State

The resulting type after applying the - operator.

fn sub(self, other: State) -> Self

Performs the - operation.

impl SubAssign for State

fn sub_assign(&mut self, other: State)

Performs the -= operation.

impl Copy for State

impl StructuralPartialEq for State