Struct comfy_wgpu::Pid

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

Adjustable proportional-integral-derivative (PID) controller.

Examples

This controller provides a builder pattern interface which allows you to pick-and-choose which PID inputs you’d like to use during operation. Here’s what a basic proportional-only controller could look like:

use pid::Pid;

// Create limited controller
let mut p_controller = Pid::new(15.0, 100.0);
p_controller.p(10.0, 100.0);

// Get first output
let p_output = p_controller.next_control_output(400.0);

This controller would give you set a proportional controller to 10.0 with a target of 15.0 and an output limit of 100.0 per output iteration. The same controller with a full PID system built in looks like:

use pid::Pid;

// Create full PID controller
let mut full_controller = Pid::new(15.0, 100.0);
full_controller.p(10.0, 100.0).i(4.5, 100.0).d(0.25, 100.0);

// Get first output
let full_output = full_controller.next_control_output(400.0);

This next_control_output method is what’s used to input new values into the controller to tell it what the current state of the system is. In the examples above it’s only being used once, but realistically this will be a hot method. Please see [ControlOutput] for examples of how to handle these outputs; it’s quite straight forward and mirrors the values of this structure in some ways.

The last item of note is that these p, i, and d methods can be used during operation which lets you add and/or modify these controller values if need be.

Fields

setpoint: T

Ideal setpoint to strive for.

output_limit: T

Defines the overall output filter limit.

kp: T

Proportional gain.

ki: T

Integral gain.

kd: T

Derivative gain.

p_limit: T

Limiter for the proportional term: -p_limit <= P <= p_limit.

i_limit: T

Limiter for the integral term: -i_limit <= I <= i_limit.

d_limit: T

Limiter for the derivative term: -d_limit <= D <= d_limit.

Implementations

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

pub fn new(setpoint: impl Into<T>, output_limit: impl Into<T>) -> Pid<T>

Creates a new controller with the target setpoint and the output limit

To set your P, I, and D terms into this controller, please use the following builder methods:

• Self::p(): Proportional term setting
• Self::i(): Integral term setting
• Self::d(): Derivative term setting

pub fn p(&mut self, gain: impl Into<T>, limit: impl Into<T>) -> &mut Pid<T>

Sets the Self::p term for this controller.

pub fn i(&mut self, gain: impl Into<T>, limit: impl Into<T>) -> &mut Pid<T>

Sets the Self::i term for this controller.

pub fn d(&mut self, gain: impl Into<T>, limit: impl Into<T>) -> &mut Pid<T>

Sets the Self::d term for this controller.

pub fn setpoint(&mut self, setpoint: impl Into<T>) -> &mut Pid<T>

Sets the Pid::setpoint to target for this controller.

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

pub fn reset_integral_term(&mut self)

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

Trait Implementations

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

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 for Pid<T>where T: Debug + FloatCore,

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

Formats the value using the given formatter.

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

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

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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