Struct Builder 

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

PID controller builder

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

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

Implementations

impl<T: Float> Builder<T>

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

Feedback term order

Arguments

• order: The maximum feedback term order.

pub fn gain(self, action: Action, gain: T) -> 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> = pid::Builder::default().gain(pid::Action::I, ki).build(&tau);
let x0 = 5.0;
let y0 = i.process(&mut DirectForm1::default(), x0);
assert!((y0 / (x0 * tau * ki) - 1.0).abs() < 2.0 * f32::EPSILON);

Arguments

• action: Action to control
• gain: Gain value

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

Gain limit for a given action

Gain limit units are output/input. See also Builder::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::Builder::default()
    .gain(pid::Action::I, 8.0)
    .limit(pid::Action::I, ki_limit)
    .build(&1.0);
let mut xy = DirectForm1::default();
let x0 = 5.0;
for _ in 0..1000 {
    i.process(&mut xy, x0);
}
let y0 = i.process(&mut xy, x0);
assert!((y0 / (x0 * ki_limit) - 1.0f32).abs() < 1e-3);

Arguments

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

Trait Implementations

impl<T, C> Build<[C; 5]> for Builder<T>

where C: 'static + Copy + SubAssign + AddAssign, T: Float + AsPrimitive<C>,

fn build(&self, period: &T) -> [C; 5]

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> = pid::Builder::default()
    .gain(pid::Action::P, 3.0)
    .order(pid::Order::P)
    .build(&1.0);
assert_eq!(i, Biquad::proportional(3.0f32));

Arguments

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

Panic

Will panic in debug mode on fixed point coefficient overflow.

type Context = T

The context of the convesion.

impl<C, T> Build<Biquad<C>> for Builder<T>

where Self: Build<[C; 5]>, Biquad<C>: From<[C; 5]>,

type Context = <Builder<T> as Build<[C; 5]>>::Context

The context of the convesion.

fn build(&self, ctx: &Self::Context) -> Biquad<C>

Perform the conversion

impl<T: Clone> Clone for Builder<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Builder<T>

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

Formats the value using the given formatter.

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

fn default() -> Self

Returns the “default value” for a type.

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

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

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

impl<T> StructuralPartialEq for Builder<T>