Struct PidIn

pub struct PidIn<T: FloatCore + Default> { /* private fields */ }

Implementations

impl<T: FloatCore + Default> PidIn<T>

pub fn new(measurement: T, tdelta: T) -> Self

Examples found in repository

examples/case.rs (line 10)

fn main() {
    let mut pid = pid::PidCtrl::new_with_pid(0.5, 0.1, 0.1);
    let mut measurement = 0.0;
    let mut width:usize;
    pid.init(7.5, measurement);

    for _i in 1..21 {
        measurement += pid.step(pid::PidIn::new(measurement, 1.0)).out;
        width = (measurement * 10.0) as usize;

        println!("{measurement:>0$.2}", width);
    }
}

examples/usage.rs (line 16)

fn main() {
    let mut pid = pid_ctrl::PidCtrl::new_with_pid(3.0, 2.0, 1.0);

    let setpoint = 5.0;
    let prev_measurement = 0.0;
    // calling init optional. Setpoint and prev_measurement set to 0.0 by default.
    // Recommended to avoid derivative kick on startup
    pid.init(setpoint, prev_measurement);

    let measurement = 0.0;
    let time_delta = 1.0;
    assert_eq!(
        pid.step(pid_ctrl::PidIn::new(measurement, time_delta)), 
        pid_ctrl::PidOut::new(15.0, 10.0, 0.0, 25.0)
    );

    // changing pid constants
    pid.kp.set_scale(4.0);
    assert_eq!(
        pid.step(pid_ctrl::PidIn::new(measurement, time_delta)), 
        pid_ctrl::PidOut::new(20.0, 20.0, 0.0, 40.0)
    );

    // setting symmetrical limits around zero
    pid.kp.limits.set_limit(10.0);
    assert_eq!(
        pid.step(pid_ctrl::PidIn::new(measurement, time_delta)), 
        pid_ctrl::PidOut::new(10.0, 30.0, 0.0, 40.0)
    );

    let time_delta = 0.5;
    assert_eq!(
        pid.step(pid_ctrl::PidIn::new(measurement, time_delta)), 
        pid_ctrl::PidOut::new(10.0, 35.0, 0.0, 45.0)
    );

    // setting upper limits returns error if new value conflicts with lower limit
    pid.ki.limits.try_set_upper(28.0).unwrap();  
    assert_eq!(
        pid.step(pid_ctrl::PidIn::new(measurement, time_delta)), 
        pid_ctrl::PidOut::new(10.0, 28.0, 0.0, 38.0)
    );

    // time_delta gets clamped to Float::epsilon() - Float::infinity()
    let measurement = 1.0;
    let time_delta = -7.0;
    pid.kd.set_scale(num_traits::float::FloatCore::epsilon());
    assert_eq!(pid.step(
        pid_ctrl::PidIn::new(measurement, time_delta)), 
        pid_ctrl::PidOut::new(10.0, 28.0, -1.0, 37.0)
    );

    // configure setpoint directly
    pid.setpoint = 1.0;
    assert_eq!(pid.step(
        pid_ctrl::PidIn::new(measurement, time_delta)), 
        pid_ctrl::PidOut::new(0.0, 28.0, 0.0, 28.0)
    );
}

Trait Implementations

impl<T: Clone + FloatCore + Default> Clone for PidIn<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + FloatCore + Default> Debug for PidIn<T>

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

Formats the value using the given formatter.

impl<T: Default + FloatCore + Default> Default for PidIn<T>

fn default() -> PidIn<T>

Returns the “default value” for a type.

impl<T: Hash + FloatCore + Default> Hash for PidIn<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq + FloatCore + Default> PartialEq for PidIn<T>

fn eq(&self, other: &PidIn<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 + FloatCore + Default> PartialOrd for PidIn<T>

fn partial_cmp(&self, other: &PidIn<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: Copy + FloatCore + Default> Copy for PidIn<T>

impl<T: FloatCore + Default> StructuralPartialEq for PidIn<T>