Struct PidBuilder

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

PID controller builder

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

let b: Biquad<f32> = PidBuilder::default()
    .period(1e-3)
    .gain(Action::I, 1e-3)
    .gain(Action::P, 1.0)
    .gain(Action::D, 1e2)
    .limit(Action::I, 1e3)
    .limit(Action::D, 1e1)
    .build()
    .into();

Implementations

impl<T: Float> PidBuilder<T>

pub fn order(&mut self, order: Order) -> &mut Self

Feedback term order

Arguments

• order: The maximum feedback term order.

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.)

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> = PidBuilder::default()
    .period(tau)
    .gain(Action::I, ki)
    .build()
    .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 PidBuilder::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> = PidBuilder::default()
    .gain(Action::I, 8.0)
    .limit(Action::I, ki_limit)
    .build()
    .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>(&self) -> [C; 5]

where C: Coefficient + AsPrimitive<T>, T: AsPrimitive<C>,

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 unused gain actions or for proportional action are ignored.

let i: Biquad<f32> = PidBuilder::default()
    .gain(Action::P, 3.0)
    .order(Order::P)
    .build()
    .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 PidBuilder<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for PidBuilder<T>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for PidBuilder<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 PidBuilder<T>

fn eq(&self, other: &PidBuilder<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 PidBuilder<T>

fn partial_cmp(&self, other: &PidBuilder<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 PidBuilder<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 PidBuilder<T>

impl<T> StructuralPartialEq for PidBuilder<T>