Struct PID

pub struct PID<F, const W: usize> {
    pub kp: F,
    pub ki: F,
    pub kd: F,
    pub kf: F,
    pub kv: F,
    /* private fields */
}

PID controller

Examples

use pid_loop::PID;

let target = 42.0;
let mut controller = PID::<f64, 1>::new(2.0, 0.7, 0.3, 0.0, 0.0);
let correction = controller.next(target, measure());

fn measure() -> f64 { todo!() }

Fields

kp: F

Proportional gain.

ki: F

Integral gain.

kd: F

Derivative gain.

kf: F

Feed forward gain

kv: F

Velocity

Implementations

impl<F, const W: usize> PID<F, W>

where F: Default + Add<Output = F> + Sub<Output = F> + Mul<Output = F> + PartialOrd + Copy,

pub fn new( kp: impl Into<F>, ki: impl Into<F>, kd: impl Into<F>, kf: impl Into<F>, kv: impl Into<F>, ) -> Self

Create a new instance of PID.

Examples

#![allow(unused_assignments)]
use pid_loop::PID;

let mut controller = PID::<f32, 1>::new(0.7, 0.034, 0.084, 0.1, 0.0);

pub fn reset(&mut self)

Reset controller internal state.

Examples

#![allow(unused_assignments)]
use pid_loop::PID;

let target = 30.0;
let mut controller = PID::<f32, 1>::new(0.7, 0.034, 0.084, 0.1, 0.0);
controller.next(target, 42.0);
controller.reset();

pub fn next(&mut self, sp: impl Into<F>, fb: impl Into<F>) -> F

Push next measurement into the controller and return correction.

Examples

#![allow(unused_assignments)]
use pid_loop::PID;

let target = 30.0;
let mut controller = PID::<f64, 1>::new(0.7, 0.034, 0.084, 0.1, 0.1);
let correction = controller.next(target, 42.0);