Struct OutputLimit 

pub struct OutputLimit {
    pub min: Float,
    pub max: Float,
}

Optional control output clamp.

Use this to match the command range of the real actuator, for example 0.0..1.0 for normalized heater power or -1.0..1.0 for a bidirectional motor command. The controller still reports the unsaturated value in its update output, which is useful during tuning.

Fields

min: Float

Minimum allowed controller output.

max: Float

Maximum allowed controller output.

Implementations

impl OutputLimit

pub const fn new(min: Float, max: Float) -> Self

Creates a new output clamp.

Examples found in repository

examples/second_order_position.rs (line 11)

fn main() -> Result<(), ladrc_no_std::ConfigError> {
    let dt = 0.001;
    let target_position = 1.0;

    let config = LadrcSecondOrderConfig::from_bandwidth(
        dt, 2.0, // one unit of command gives roughly +2 position-units/s^2
        12.0, 60.0,
    )
    .with_output_limit(OutputLimit::new(-5.0, 5.0));

    let mut controller = LadrcSecondOrder::new(config)?;
    let mut position = 0.0;
    let mut velocity = 0.0;
    let mut control = 0.0;

    for step in 0..5_000 {
        let out = controller.update(target_position, position);
        control = out.control;

        let load_disturbance = if step > 2_000 { -0.8 } else { 0.0 };
        let acceleration = -1.2 * velocity - 4.0 * position + 2.0 * control + load_disturbance;

        velocity += dt * acceleration;
        position += dt * velocity;
    }

    println!("target position: {target_position:.3}");
    println!("final position:  {position:.3}");
    println!("final velocity:  {velocity:.3}");
    println!("final command:   {control:.3}");

    Ok(())
}

examples/first_order_temperature.rs (line 11)

fn main() -> Result<(), ladrc_no_std::ConfigError> {
    let dt = 0.01;
    let target_temperature = 55.0;

    let config = LadrcFirstOrderConfig::from_bandwidth(
        dt, 2.0, // one unit of heater command gives roughly +2 C/s initially
        0.8, 4.0,
    )
    .with_output_limit(OutputLimit::new(0.0, 1.0));

    let mut controller = LadrcFirstOrder::new(config)?;
    let mut temperature = 20.0;
    let ambient = 20.0;
    let mut control = 0.0;

    for step in 0..6_000 {
        let out = controller.update(target_temperature, temperature);
        control = out.control;

        let open_window_disturbance = if step > 3_000 { -0.35 } else { 0.0 };
        let plant_cooling = -0.04 * (temperature - ambient);
        let plant_heating = 2.0 * control;

        temperature += dt * (plant_cooling + plant_heating + open_window_disturbance);
    }

    println!("target temperature: {target_temperature:.2} C");
    println!("final temperature:  {temperature:.2} C");
    println!("final command:      {:.1} %", control * 100.0);

    Ok(())
}

examples/variable_period_position.rs (line 8)

fn main() -> Result<(), ladrc_no_std::ConfigError> {
    let nominal_dt = 0.001;
    let target_position = 1.0;

    let config = LadrcSecondOrderConfig::from_bandwidth(nominal_dt, 2.0, 12.0, 60.0)
        .with_output_limit(OutputLimit::new(-5.0, 5.0));

    let mut controller = LadrcSecondOrder::new(config)?;
    let mut now_ms = 0_u64;
    let mut position = 0.0;
    let mut velocity = 0.0;
    let mut control = 0.0;

    controller.reset_at_millis(now_ms, position);

    let poll_periods_ms = [1_u64, 2, 1, 1, 2];

    for step in 0..5_000 {
        let actual_dt_ms = poll_periods_ms[step % poll_periods_ms.len()];
        let actual_dt = actual_dt_ms as f32 * 0.001;
        now_ms += actual_dt_ms;

        let out = controller.update_at_millis(now_ms, target_position, position)?;
        control = out.control;

        let load_disturbance = if step > 2_000 { -0.8 } else { 0.0 };
        let acceleration = -1.2 * velocity - 4.0 * position + 2.0 * control + load_disturbance;

        velocity += actual_dt * acceleration;
        position += actual_dt * velocity;
    }

    println!("target position: {target_position:.3}");
    println!("final position:  {position:.3}");
    println!("final velocity:  {velocity:.3}");
    println!("final command:   {control:.3}");
    println!("final time:      {:.3} s", now_ms as f32 * 0.001);

    Ok(())
}

pub fn apply(self, value: Float) -> Float

Applies the clamp to value.

Trait Implementations

impl Clone for OutputLimit

fn clone(&self) -> OutputLimit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for OutputLimit

impl Debug for OutputLimit

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

Formats the value using the given formatter.

impl PartialEq for OutputLimit

fn eq(&self, other: &OutputLimit) -> 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 StructuralPartialEq for OutputLimit