Struct Pid

pub struct Pid<T> { /* private fields */ }

PID controller builder

Builds Biquad from action gains, gain limits, input offset and output limits.

let b: Biquad<f32> = Pid::default()
    .period(1e-3)
    .gain(Action::Ki, 1e-3)
    .gain(Action::Kp, 1.0)
    .gain(Action::Kd, 1e2)
    .limit(Action::Ki, 1e3)
    .limit(Action::Kd, 1e1)
    .build()
    .unwrap()
    .into();

Implementations

impl<T: Float> Pid<T>

pub fn period(&mut self, period: T) -> &mut Self

Sample period

Arguments

• period: Sample period in some units, e.g. SI seconds

pub fn gain(&mut self, action: Action, gain: T) -> &mut Self

Gain for a given action

Gain units are output/input * time.powi(order) where

• output are output (y) units
• input are input (x) units
• time are sample period units, e.g. SI seconds
• order is the action order: the frequency exponent (-1 for integrating, 0 for proportional, etc.)

Note that inverse time units correspond to angular frequency units. Gains are accurate in the low frequency limit. Towards Nyquist, the frequency response is warped.

Note that limit signs and gain signs should match.

let tau = 1e-3;
let ki = 1e-4;
let i: Biquad<f32> = Pid::default()
    .period(tau)
    .gain(Action::Ki, ki)
    .build()
    .unwrap()
    .into();
let x0 = 5.0;
let y0 = i.update(&mut [0.0; 4], x0);
assert!((y0 / (x0 * tau * ki) - 1.0).abs() < 2.0 * f32::EPSILON);

Arguments

• action: Action to control
• gain: Gain value

pub fn limit(&mut self, action: Action, limit: T) -> &mut Self

Gain limit for a given action

Gain limit units are output/input. See also Pid::gain(). Multiple gains and limits may interact and lead to peaking.

Note that limit signs and gain signs should match and that the default limits are positive infinity.

let ki_limit = 1e3;
let i: Biquad<f32> = Pid::default()
    .gain(Action::Ki, 8.0)
    .limit(Action::Ki, ki_limit)
    .build()
    .unwrap()
    .into();
let mut xy = [0.0; 4];
let x0 = 5.0;
for _ in 0..1000 {
    i.update(&mut xy, x0);
}
let y0 = i.update(&mut xy, x0);
assert!((y0 / (x0 * ki_limit) - 1.0f32).abs() < 1e-3);

Arguments

• action: Action to limit in gain
• limit: Gain limit

pub fn build<C: Coefficient + AsPrimitive<T>>(&self) -> Result<[C; 5], PidError>

where T: AsPrimitive<C>,

Perform checks, compute coefficients and return Biquad.

No attempt is made to detect NaNs, non-finite gains, non-positive period, zero gain limits, or gain/limit sign mismatches. These will consequently result in NaNs/infinities, peaking, or notches in the Biquad coefficients.

Gain limits for zero gain actions or for proportional action are ignored.

let i: Biquad<f32> = Pid::default().gain(Action::Kp, 3.0).build().unwrap().into();
assert_eq!(i, Biquad::proportional(3.0));

Panic

Will panic in debug mode on fixed point coefficient overflow.

Trait Implementations

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<T: Float> Default for Pid<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for Pid<T>

where T: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

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

fn eq(&self, other: &Pid<T>) -> 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<T: PartialOrd> PartialOrd for Pid<T>

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

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<T> Serialize for Pid<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

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

impl<T> StructuralPartialEq for Pid<T>