pid

https://docs.rs/pid/4.0.0/
Admin
A proportional-integral-derivative (PID) controller library for Rust that provides adjustable...
Tokens:12,118
Snippets:57
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Rust PID Controller Setup and Usage Example

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Demonstrates how to set up and use the PID controller in Rust. It shows initializing the controller, setting the P, I, and D gains and limits, and then calculating the control output for a given measurement. The output includes the contribution of each term.

```rust
use pid::{Pid, ControlOutput};

// Setup controller
let mut pid = Pid::new(15.0, 100.0);
pid.p(10.0, 100.0).i(1.0, 100.0).d(2.0, 100.0);

// Input an example value and get a report for an output iteration
let output = pid.next_control_output(26.2456);
println!("P: {}\nI: {}\nD: {}\nFinal Output: {}", output.p, output.i, output.d, output.output);
```

--------------------------------

### PID Controller Example in Rust

Source: https://docs.rs/pid/4.0.0/index

Demonstrates how to create and use a PID controller. It shows setting the proportional, integral, and derivative gains, and how the controller output changes with different inputs and controller configurations. The example includes assertions to verify the output values.

```Rust
use pid::Pid;

// Create a new proportional-only PID controller with a setpoint of 15
let mut pid = Pid::new(15.0, 100.0);
pid.p(10.0, 100.0);

// Input a measurement with an error of 5.0 from our setpoint
let output = pid.next_control_output(10.0);

// Show that the error is correct by multiplying by our kp
assert_eq!(output.output, 50.0); // <-
assert_eq!(output.p, 50.0);

// It won't change on repeat; the controller is proportional-only
let output = pid.next_control_output(10.0);
assert_eq!(output.output, 50.0); // <-
assert_eq!(output.p, 50.0);

// Add a new integral term to the controller and input again
pid.i(1.0, 100.0);
let output = pid.next_control_output(10.0);

// Now that the integral makes the controller stateful, it will change
assert_eq!(output.output, 55.0); // <-
assert_eq!(output.p, 50.0);
assert_eq!(output.i, 5.0);

// Add our final derivative term and match our setpoint target
pid.d(2.0, 100.0);
let output = pid.next_control_output(15.0);

// The output will now say to go down due to the derivative
assert_eq!(output.output, -5.0); // <-
assert_eq!(output.p, 0.0);
assert_eq!(output.i, 5.0);
assert_eq!(output.d, -10.0);
```

--------------------------------

### PID Controller Example in Rust

Source: https://docs.rs/pid/4.0.0/pid

Demonstrates how to create and use a PID controller. It shows setting the proportional, integral, and derivative gains, and how the controller output changes with different inputs and controller configurations. The example includes assertions to verify the output values.

```Rust
use pid::Pid;

// Create a new proportional-only PID controller with a setpoint of 15
let mut pid = Pid::new(15.0, 100.0);
pid.p(10.0, 100.0);

// Input a measurement with an error of 5.0 from our setpoint
let output = pid.next_control_output(10.0);

// Show that the error is correct by multiplying by our kp
assert_eq!(output.output, 50.0); // <-
assert_eq!(output.p, 50.0);

// It won't change on repeat; the controller is proportional-only
let output = pid.next_control_output(10.0);
assert_eq!(output.output, 50.0); // <-
assert_eq!(output.p, 50.0);

// Add a new integral term to the controller and input again
pid.i(1.0, 100.0);
let output = pid.next_control_output(10.0);

// Now that the integral makes the controller stateful, it will change
assert_eq!(output.output, 55.0); // <-
assert_eq!(output.p, 50.0);
assert_eq!(output.i, 5.0);

// Add our final derivative term and match our setpoint target
pid.d(2.0, 100.0);
let output = pid.next_control_output(15.0);

// The output will now say to go down due to the derivative
assert_eq!(output.output, -5.0); // <-
assert_eq!(output.p, 0.0);
assert_eq!(output.i, 5.0);
assert_eq!(output.d, -10.0);
```

--------------------------------

### PID Controller Example in Rust

Source: https://docs.rs/pid/4.0.0/pid/index

Demonstrates how to create and use a PID controller. It shows setting the proportional, integral, and derivative gains, and how the controller output changes with different inputs and controller configurations. The example includes assertions to verify the output values.

```Rust
use pid::Pid;

// Create a new proportional-only PID controller with a setpoint of 15
let mut pid = Pid::new(15.0, 100.0);
pid.p(10.0, 100.0);

// Input a measurement with an error of 5.0 from our setpoint
let output = pid.next_control_output(10.0);

// Show that the error is correct by multiplying by our kp
assert_eq!(output.output, 50.0); // <-
assert_eq!(output.p, 50.0);

// It won't change on repeat; the controller is proportional-only
let output = pid.next_control_output(10.0);
assert_eq!(output.output, 50.0); // <-
assert_eq!(output.p, 50.0);

// Add a new integral term to the controller and input again
pid.i(1.0, 100.0);
let output = pid.next_control_output(10.0);

// Now that the integral makes the controller stateful, it will change
assert_eq!(output.output, 55.0); // <-
assert_eq!(output.p, 50.0);
assert_eq!(output.i, 5.0);

// Add our final derivative term and match our setpoint target
pid.d(2.0, 100.0);
let output = pid.next_control_output(15.0);

// The output will now say to go down due to the derivative
assert_eq!(output.output, -5.0); // <-
assert_eq!(output.p, 0.0);
assert_eq!(output.i, 5.0);
assert_eq!(output.d, -10.0);
```

--------------------------------

### Rust PID Controller Full Configuration Example

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Shows how to configure a PID controller with proportional, integral, and derivative terms using the builder pattern. It includes setting the setpoint, output limit, and individual gains and limits for P, I, and D components.

```Rust
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);
```

--------------------------------

### Rust PID Controller Basic Example

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Demonstrates the creation and usage of a proportional-only PID controller. It shows how to set the setpoint, proportional gain, and input measurements to calculate the control output and its proportional component.

```Rust
use pid::Pid;

// Create a new proportional-only PID controller with a setpoint of 15
let mut pid = Pid::new(15.0, 100.0);
pid.p(10.0, 100.0);

// Input a measurement with an error of 5.0 from our setpoint
let output = pid.next_control_output(10.0);

// Show that the error is correct by multiplying by our kp
assert_eq!(output.output, 50.0); // <-
assert_eq!(output.p, 50.0);
```

--------------------------------

### Rust PID Controller Builder Pattern Example

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Demonstrates using the builder pattern to create a PID controller with a proportional term. It shows how to initialize the controller with a setpoint and output limit, and then configure the proportional gain and its limit.

```Rust
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);
```

--------------------------------

### Create and Configure Full PID Controller

Source: https://docs.rs/pid/4.0.0/pid/struct

Illustrates the creation of a full PID controller, configuring proportional, integral, and derivative terms with their respective gains and limits, and then calculating a control output.

```Rust
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);
```

--------------------------------

### Rust PID Controller Initialization

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Provides the method for creating a new PID controller instance in Rust. It takes the target setpoint and the output limit as arguments.

```rust
pub fn new(setpoint: impl Into<T>, output_limit: impl Into<T>) -> Self {
    Self {
        setpoint: setpoint.into(),
        output_limit: output_limit.into(),
        kp: T::zero(),
        ki: T::zero(),
        kd: T::zero(),
        p_limit: T::zero(),
        i_limit: T::zero(),
        d_limit: T::zero(),
        integral_term: T::zero(),
        prev_measurement: None,
    }
}
```

--------------------------------

### Rustdoc Keyboard Shortcuts

Source: https://docs.rs/pid/4.0.0/help

This snippet lists the primary keyboard shortcuts available in Rustdoc for interacting with the documentation interface, including showing help, focusing search, navigating results, and managing sections.

```Rustdoc
`?`
    Show this help dialog 

`S` / `/` 
    Focus the search field 

`↑`
    Move up in search results 

`↓`
    Move down in search results 

`←` / `→` 
    Switch result tab (when results focused) 

`⏎`
    Go to active search result 

`+`
    Expand all sections 

`-`
    Collapse all sections
```

--------------------------------

### Create and Configure Proportional-Only PID Controller

Source: https://docs.rs/pid/4.0.0/pid/struct

Demonstrates creating a PID controller with only a proportional term, setting its gain and limit, and then calculating the first control output.

```Rust
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);
```

--------------------------------

### Rustdoc Search Tricks

Source: https://docs.rs/pid/4.0.0/help

This snippet outlines advanced search functionalities in Rustdoc, enabling users to refine searches by item kind (e.g., functions, modules), type signatures, exact names, and item paths.

```Rustdoc
Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given item kind.
Accepted kinds are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.
Search functions by type signature (e.g., `vec -> usize` or `-> vec` or `String, enum:Cow -> bool`)
You can look for items with an exact name by putting double quotes around your request: `"string"`
Look for functions that accept or return slices and arrays by writing square brackets (e.g., `-> [u8]` or `[] -> Option`)
Look for items inside another one by searching for a path: `vec::Vec`
```

--------------------------------

### Rust PID Controller with Integral and Derivative

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Illustrates adding integral and derivative terms to a PID controller. It shows how to configure the integral and derivative gains and how these affect the control output, including the integral and derivative components.

```Rust
use pid::Pid;

// Create a new proportional-only PID controller with a setpoint of 15
let mut pid = Pid::new(15.0, 100.0);
pid.p(10.0, 100.0);

// Input a measurement with an error of 5.0 from our setpoint
let output = pid.next_control_output(10.0);

// Show that the error is correct by multiplying by our kp
assert_eq!(output.output, 50.0); // <-
assert_eq!(output.p, 50.0);

// It won't change on repeat; the controller is proportional-only
let output = pid.next_control_output(10.0);
assert_eq!(output.output, 50.0); // <-
assert_eq!(output.p, 50.0);

// Add a new integral term to the controller and input again
pid.i(1.0, 100.0);
let output = pid.next_control_output(10.0);

// Now that the integral makes the controller stateful, it will change
assert_eq!(output.output, 55.0); // <-
assert_eq!(output.p, 50.0);
assert_eq!(output.i, 5.0);

// Add our final derivative term and match our setpoint target
pid.d(2.0, 100.0);
let output = pid.next_control_output(15.0);

// The output will now say to go down due to the derivative
assert_eq!(output.output, -5.0); // <-
assert_eq!(output.p, 0.0);
assert_eq!(output.i, 5.0);
assert_eq!(output.d, -10.0);
```

--------------------------------

### Pid::new - Constructor

Source: https://docs.rs/pid/4.0.0/pid/struct

Creates a new PID controller instance with a specified setpoint and output limit. It also provides builder methods to configure the proportional, integral, and derivative terms.

```Rust
pub fn new(setpoint: impl Into<T>, output_limit: impl Into<T>) -> Self>
```

--------------------------------

### Test PID Controller Output Limits

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Verifies the output limiting behavior of the PID controller across multiple control loop iterations.

```Rust
/// Checks that a full PID controller's limits work properly through multiple output iterations
#[test]
fn output_limit() {
    let mut pid = Pid::new(10.0, 1.0);
    pid.p(1.0, 100.0).i(0.0, 100.0).d(0.0, 100.0);

    let out = pid.next_control_output(0.0);
    assert_eq!(out.p, 10.0); // 1.0 * 10.0
    assert_eq!(out.output, 1.0);

    let out = pid.next_control_output(20.0);
    assert_eq!(out.p, -10.0); // 1.0 * (10.0 - 20.0)
    assert_eq!(out.output, -1.0);
}
```

--------------------------------

### PID Setpoint Targeting Test

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Verifies the PID controller's ability to reach and maintain a target setpoint after a specified number of control output iterations. This test checks the proportional (p), integral (i), and derivative (d) components, as well as the final output value.

```rust
/// See if the controller can properly target to the setpoint after 2 output iterations
#[test]
fn setpoint() {
    let mut pid = Pid::new(10.0, 100.0);
    pid.p(1.0, 100.0).i(0.1, 100.0).d(1.0, 100.0);

    let out = pid.next_control_output(0.0);
    assert_eq!(out.p, 10.0); // 1.0 * 10.0
    assert_eq!(out.i, 1.0); // 0.1 * 10.0
    assert_eq!(out.d, 0.0); // -(1.0 * 0.0)
    assert_eq!(out.output, 11.0);

    pid.setpoint(0.0);

    assert_eq!(
        pid.next_control_output(0.0),
        ControlOutput {
            p: 0.0,
            i: 1.0,
            d: -0.0,
            output: 1.0
        }
    );
}
```

--------------------------------

### Test Combined PID Controller Operation

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Tests the integrated behavior of a full PID controller, including proportional, integral, and derivative components, and their combined effect on the output.

```Rust
/// Combined PID operation
#[test]
fn pid() {
    let mut pid = Pid::new(10.0, 100.0);
    pid.p(1.0, 100.0).i(0.1, 100.0).d(1.0, 100.0);

    let out = pid.next_control_output(0.0);
    assert_eq!(out.p, 10.0); // 1.0 * 10.0
    assert_eq!(out.i, 1.0); // 0.1 * 10.0
    assert_eq!(out.d, 0.0); // -(1.0 * 0.0)
    assert_eq!(out.output, 11.0);

    let out = pid.next_control_output(5.0);
    assert_eq!(out.p, 5.0); // 1.0 * 5.0
    assert_eq!(out.i, 1.5); // 0.1 * (10.0 + 5.0)
    assert_eq!(out.d, -5.0); // -(1.0 * 5.0)
    assert_eq!(out.output, 1.5);

    let out = pid.next_control_output(11.0);
    assert_eq!(out.p, -1.0); // 1.0 * -1.0
    assert_eq!(out.i, 1.4); // 0.1 * (10.0 + 5.0 - 1)
    assert_eq!(out.d, -6.0); // -(1.0 * 6.0)
    assert_eq!(out.output, -5.6);

    let out = pid.next_control_output(10.0);
    assert_eq!(out.p, 0.0); // 1.0 * 0.0
    assert_eq!(out.i, 1.4); // 0.1 * (10.0 + 5.0 - 1.0 + 0.0)
    assert_eq!(out.d, 1.0); // -(1.0 * -1.0)
    assert_eq!(out.output, 2.4);
}
```

--------------------------------

### Rust PID Controller Calculate Next Output

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Calculates the next control output based on a new measurement. This method handles the PID calculations, including proportional, integral, and derivative terms, and applies output limits. It also manages integral windup and derivative kick.

```rust
pub fn next_control_output(&mut self, measurement: T) -> ControlOutput<T> {
    // Calculate the error between the ideal setpoint and the current
    // measurement to compare against
    let error = self.setpoint - measurement;

    // Calculate the proportional term and limit to it's individual limit
    let p_unbounded = error * self.kp;
    let p = apply_limit(self.p_limit, p_unbounded);

    // Mitigate output jumps when ki(t) != ki(t-1).
    // While it's standard to use an error_integral that's a running sum of
    // just the error (no ki), because we support ki changing dynamically,
    // we store the entire term so that we don't need to remember previous
    // ki values.
    self.integral_term = self.integral_term + error * self.ki;

    // Mitigate integral windup: Don't want to keep building up error
    // beyond what i_limit will allow.
    self.integral_term = apply_limit(self.i_limit, self.integral_term);

    // Mitigate derivative kick: Use the derivative of the measurement
    // rather than the derivative of the error.
    let d_unbounded = -match self.prev_measurement.as_ref() {
        Some(prev_measurement) => measurement - *prev_measurement,
        None => T::zero(),
    } * self.kd;
    self.prev_measurement = Some(measurement);
    let d = apply_limit(self.d_limit, d_unbounded);

    // Calculate the final output by adding together the PID terms, then
    // apply the final defined output limit
    let output = p + self.integral_term + d;
    let output = apply_limit(self.output_limit, output);
    
    ControlOutput { p, i: self.integral_term, d, output }
```

--------------------------------

### Pid::next_control_output - Calculate Output

Source: https://docs.rs/pid/4.0.0/pid/struct

Calculates the next control output based on the current measurement and the configured PID parameters. This is the core method for applying the PID algorithm.

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

--------------------------------

### Apply Limit to Value

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Saturates an input value within a specified absolute limit. The output will be between -limit and +limit, preserving the sign of the original value.

```Rust
/// Saturating the input `value` according the absolute `limit` (`-limit <= output <= limit`).
fn apply_limit<T: FloatCore>(limit: T, value: T) -> T {
    limit.min(value.abs()) * value.signum()
}
```

--------------------------------

### Pid Struct Definition

Source: https://docs.rs/pid/4.0.0/pid/struct

Defines the structure of the `Pid` controller, including fields for setpoint, output limits, proportional, integral, and derivative gains.

```Rust
pub struct Pid<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 */
}
```

--------------------------------

### Rust From Conversion to Pid

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the From trait, allowing conversion from another type into a Pid. This is a common way to create new Pid instances.

```Rust
fn from(t: T) -> T
```

--------------------------------

### Rust PID Controller Set I Term

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Method to set the integral (I) gain and limit for the PID controller. Returns a mutable reference to the controller for chaining.

```rust
pub fn i(&mut self, gain: impl Into<T>, limit: impl Into<T>) -> &mut Self {
    self.ki = gain.into();
    self.i_limit = limit.into();
    self
}
```

--------------------------------

### Rust PID Controller Set P Term

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Method to set the proportional (P) gain and limit for the PID controller. Returns a mutable reference to the controller for chaining.

```rust
pub fn p(&mut self, gain: impl Into<T>, limit: impl Into<T>) -> &mut Self {
    self.kp = gain.into();
    self.p_limit = limit.into();
    self
}
```

--------------------------------

### Test Proportional-Only PID Operation

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Tests the proportional component of the PID controller, including its response to setpoint changes and proportional limits.

```Rust
/// Proportional-only controller operation and limits
#[test]
fn proportional() {
    let mut pid = Pid::new(10.0, 100.0);
    pid.p(2.0, 100.0).i(0.0, 100.0).d(0.0, 100.0);
    assert_eq!(pid.setpoint, 10.0);

    // Test simple proportional
    assert_eq!(pid.next_control_output(0.0).output, 20.0);

    // Test proportional limit
    pid.p_limit = 10.0;
    assert_eq!(pid.next_control_output(0.0).output, 10.0);
}
```

--------------------------------

### PID f32/f64 Precision Test

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Tests the PID controller's operation with mixed single-precision (f32) and double-precision (f64) floating-point numbers. It verifies that the controller maintains accuracy when inputs and internal states are represented in different precisions.

```rust
/// Full PID operation with mixed f32/f64 checking to make sure they're equal
#[test]
fn f32_and_f64() {
    let mut pid32 = Pid::new(10.0f32, 100.0);
    pid32.p(0.0, 100.0).i(0.0, 100.0).d(0.0, 100.0);

    let mut pid64 = Pid::new(10.0, 100.0f64);
    pid64.p(0.0, 100.0).i(0.0, 100.0).d(0.0, 100.0);

    assert_eq!(
        pid32.next_control_output(0.0).output,
        pid64.next_control_output(0.0).output as f32
    );
    assert_eq!(
        pid32.next_control_output(0.0).output as f64,
        pid64.next_control_output(0.0).output
    );
}
```

--------------------------------

### Rust PID Controller Set Setpoint

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Method to update the target setpoint for the PID controller. Returns a mutable reference to the controller for chaining.

```rust
pub fn setpoint(&mut self, setpoint: impl Into<T>) -> &mut Self {
    self.setpoint = setpoint.into();
    self
}
```

--------------------------------

### Pid::setpoint - Update Setpoint

Source: https://docs.rs/pid/4.0.0/pid/struct

Updates the target setpoint for the PID controller. This method allows dynamic adjustment of the desired value the controller aims to achieve.

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

--------------------------------

### Test Integral-Only PID Operation

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Tests the integral component of the PID controller, covering basic integration, integral limits, and accumulation of negative error values.

```Rust
/// Integral-only controller operation and limits
#[test]
fn integral() {
    let mut pid = Pid::new(10.0, 100.0);
    pid.p(0.0, 100.0).i(2.0, 100.0).d(0.0, 100.0);

    // Test basic integration
    assert_eq!(pid.next_control_output(0.0).output, 20.0);
    assert_eq!(pid.next_control_output(0.0).output, 40.0);
    assert_eq!(pid.next_control_output(5.0).output, 50.0);

    // Test limit
    pid.i_limit = 50.0;
    assert_eq!(pid.next_control_output(5.0).output, 50.0);
    // Test that limit doesn't impede reversal of error integral
    assert_eq!(pid.next_control_output(15.0).output, 40.0);

    // Test that error integral accumulates negative values
    let mut pid2 = Pid::new(-10.0, 100.0);
    pid2.p(0.0, 100.0).i(2.0, 100.0).d(0.0, 100.0);
    assert_eq!(pid2.next_control_output(0.0).output, -20.0);
    assert_eq!(pid2.next_control_output(0.0).output, -40.0);

    pid2.i_limit = 50.0;
    assert_eq!(pid2.next_control_output(-5.0).output, -50.0);
    // Test that limit doesn't impede reversal of error integral
    assert_eq!(pid2.next_control_output(-15.0).output, -40.0);
}
```

--------------------------------

### Rust PID Clone From Method

Source: https://docs.rs/pid/4.0.0/pid/struct

Enables copy-assignment from a source Pid value to the current one. This is an efficient way to update the state of a Pid instance.

```Rust
const fn clone_from(&mut self, source: &Self)
```

--------------------------------

### Test Derivative-Only PID Operation

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Tests the derivative component of the PID controller, verifying its behavior on the first measurement and subsequent changes, including derivative limits.

```Rust
/// Derivative-only controller operation and limits
#[test]
fn derivative() {
    let mut pid = Pid::new(10.0, 100.0);
    pid.p(0.0, 100.0).i(0.0, 100.0).d(2.0, 100.0);

    // Test that there's no derivative since it's the first measurement
    assert_eq!(pid.next_control_output(0.0).output, 0.0);

    // Test that there's now a derivative
    assert_eq!(pid.next_control_output(5.0).output, -10.0);

    // Test derivative limit
    pid.d_limit = 5.0;
    assert_eq!(pid.next_control_output(10.0).output, -5.0);
}
```

--------------------------------

### Rust PID Equality Check

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the PartialEq trait for the Pid struct, enabling equality comparisons between Pid instances. This is fundamental for checking if two values are the same.

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

--------------------------------

### Rust TryFrom Conversion to Pid

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the TryFrom trait for fallible conversions into a Pid. This allows for conversions that might fail, returning a Result.

```Rust
type Error = Infallible
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
```

--------------------------------

### Rust PID Controller Set D Term

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Method to set the derivative (D) gain and limit for the PID controller. Returns a mutable reference to the controller for chaining.

```rust
pub fn d(&mut self, gain: impl Into<T>, limit: impl Into<T>) -> &mut Self {
    self.kd = gain.into();
    self.d_limit = limit.into();
    self
}
```

--------------------------------

### Rust Into Conversion from Pid

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the Into trait, allowing conversion from a Pid into another type that implements From. This is the reciprocal of the From trait.

```Rust
fn into(self) -> U
```

--------------------------------

### Rust PID Less Than or Equal To Comparison

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the less than or equal to operator (`<=`) for the Pid struct, enabling checks to see if the first value is less than or equal to the second.

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

--------------------------------

### Rust TryInto Conversion from Pid

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the TryInto trait for fallible conversions from a Pid into another type. This is the fallible counterpart to the Into trait.

```Rust
type Error = <U as TryFrom<T>>::Error
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
```

--------------------------------

### Rust PID Less Than Comparison

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the less than operator (`<`) for the Pid struct, allowing direct comparison of two values to see if the first is less than the second.

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

--------------------------------

### Rust PID Clone Method

Source: https://docs.rs/pid/4.0.0/pid/struct

Provides a method to create a duplicate of the Pid value. This is a fundamental operation for managing data ownership and manipulation in Rust.

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

--------------------------------

### Pid::p - Set Proportional Term

Source: https://docs.rs/pid/4.0.0/pid/struct

Sets the proportional term (P) for the PID controller, including its gain and limit. This method is part of the builder pattern for configuring the controller.

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

--------------------------------

### Rust PID Min Value

Source: https://docs.rs/pid/4.0.0/pid/struct

Provides a method to determine the minimum of two Pid values. This is useful in scenarios where you need to select the smaller of two values.

```Rust
fn min(self, other: Self) -> Self
where Self: Sized,
```

--------------------------------

### Rust PID Inequality Check

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the inequality check for the Pid struct, allowing for comparisons to determine if two values are not equal. This is the counterpart to the equality check.

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

--------------------------------

### Rust PID Partial Comparison

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the PartialOrd trait for the Pid struct, providing partial ordering comparisons. This returns an Option<Ordering> and is used for operators like `<`, `<=`, `>`, and `>=`.

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

--------------------------------

### Rust PID Ord Comparison

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the Ord trait for the Pid struct, enabling total ordering comparisons between Pid instances. This allows for sorting and other operations that rely on a defined order.

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

--------------------------------

### Rust PID Debug Formatting

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the Debug trait for the Pid struct, allowing it to be formatted for debugging purposes. This is crucial for inspecting the state of Pid instances during development.

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

--------------------------------

### Pid::i - Set Integral Term

Source: https://docs.rs/pid/4.0.0/pid/struct

Sets the integral term (I) for the PID controller, including its gain and limit. This method is part of the builder pattern for configuring the controller.

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

--------------------------------

### Rust PID Greater Than or Equal To Comparison

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the greater than or equal to operator (`>=`) for the Pid struct, enabling checks to see if the first value is greater than or equal to the second.

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

--------------------------------

### Rust Unsafe Clone to Uninit

Source: https://docs.rs/pid/4.0.0/pid/struct

An unsafe method for cloning the Pid value into uninitialized memory. This is a low-level operation typically used in performance-critical scenarios.

```Rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### Rust PID Clamp Value

Source: https://docs.rs/pid/4.0.0/pid/struct

Restricts a Pid value to a specified interval between a minimum and maximum value. This is commonly used for boundary checks and normalization.

```Rust
fn clamp(self, min: Self, max: Self) -> Self
where Self: Sized,
```

--------------------------------

### Rust Borrowing from Pid

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the Borrow trait, allowing immutable borrowing of the Pid value. This enables accessing the data without taking ownership.

```Rust
fn borrow(&self) -> &T
```

--------------------------------

### Pid::d - Set Derivative Term

Source: https://docs.rs/pid/4.0.0/pid/struct

Sets the derivative term (D) for the PID controller, including its gain and limit. This method is part of the builder pattern for configuring the controller.

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

--------------------------------

### Rust PID Greater Than Comparison

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the greater than operator (`>`) for the Pid struct, allowing direct comparison of two values to see if the first is greater than the second.

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

--------------------------------

### PID Controller Integral Term Reset

Source: https://docs.rs/pid/4.0.0/src/pid/lib

Resets the integral term of the PID controller to zero. This action can significantly alter the controller's output.

```Rust
/// Resets the integral term back to zero, this may drastically change the
/// control output.
pub fn reset_integral_term(&mut self) {
    self.integral_term = T::zero();
}
```

--------------------------------

### Rust PID Max Value

Source: https://docs.rs/pid/4.0.0/pid/struct

Provides a method to determine the maximum of two Pid values. This is useful in scenarios where you need to select the larger of two values.

```Rust
fn max(self, other: Self) -> Self
where Self: Sized,
```

--------------------------------

### Rust Mutable Borrowing of Pid

Source: https://docs.rs/pid/4.0.0/pid/struct

Implements the BorrowMut trait, allowing mutable borrowing of the Pid value. This enables modifying the data while maintaining ownership rules.

```Rust
fn borrow_mut(&mut self) -> &mut T
```

--------------------------------

### Pid::reset_integral_term - Reset Integral

Source: https://docs.rs/pid/4.0.0/pid/struct

Resets the integral term of the PID controller to zero. This action can significantly alter the controller's output and is often used to correct accumulated errors.

```Rust
pub fn reset_integral_term(&mut self)
```

--------------------------------

### Rust PID Type ID Retrieval

Source: https://docs.rs/pid/4.0.0/pid/struct

Retrieves the unique TypeId of the Pid struct. This is part of the Any trait implementation and is useful for runtime type introspection.

```Rust
fn type_id(&self) -> TypeId
```
Tokens:
Raw