Struct pid::Pid

pub struct Pid<T: FloatCore> {
    pub kp: T,
    pub ki: T,
    pub kd: T,
    pub p_limit: T,
    pub i_limit: T,
    pub d_limit: T,
    pub output_limit: T,
    pub setpoint: T,
    // some fields omitted
}

Fields

kp: T

Proportional gain.

ki: T

Integral gain.

kd: T

Derivative gain.

p_limit: T

Limit of contribution of P term: (-p_limit <= P <= p_limit)

i_limit: T

Limit of contribution of I term (-i_limit <= I <= i_limit)

d_limit: T

Limit of contribution of D term (-d_limit <= D <= d_limit)

output_limit: T

Limit of output (-output_limit <= output <= output_limit)

setpoint: T

Implementations

impl<T> Pid<T> where
    T: FloatCore, 

pub fn new(
    kp: T,
    ki: T,
    kd: T,
    p_limit: T,
    i_limit: T,
    d_limit: T,
    output_limit: T,
    setpoint: T
) -> Self

pub fn reset_integral_term(&mut self)

Resets the integral term back to zero. This may drastically change the control output.

pub fn next_control_output(&mut self, measurement: T) -> ControlOutput<T>

Given a new measurement, calculates the next control output.

Panics

If a setpoint has not been set via update_setpoint().

Trait Implementations

impl<T: Clone + FloatCore> Clone for Pid<T>

pub fn clone(&self) -> Pid<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy + FloatCore> Copy for Pid<T>

impl<T: Debug + FloatCore> Debug for Pid<T>

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

Formats the value using the given formatter.

impl<T: Eq + FloatCore> Eq for Pid<T>

impl<T: Ord + FloatCore> Ord for Pid<T>

pub fn cmp(&self, other: &Pid<T>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: PartialEq + FloatCore> PartialEq<Pid<T>> for Pid<T>

pub fn eq(&self, other: &Pid<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

pub fn ne(&self, other: &Pid<T>) -> bool

This method tests for !=.

impl<T: PartialOrd + FloatCore> PartialOrd<Pid<T>> for Pid<T>

pub fn partial_cmp(&self, other: &Pid<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &Pid<T>) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &Pid<T>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &Pid<T>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &Pid<T>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: FloatCore> StructuralEq for Pid<T>

impl<T: FloatCore> StructuralPartialEq for Pid<T>