Struct Tolerances

pub struct Tolerances {
    pub duration: Option<Duration>,
    pub error_tolerance: Option<f64>,
    pub velocity_tolerance: Option<f64>,
    /* private fields */
}

Describes when a control system has stabilized reasonably near its setpoint.

This struct monitors both position error and velocity to determine if a system has reached and stabilized at its target. It can be configured with tolerances for both error and velocity, a required duration to maintain those tolerances, and an optional timeout for if the target isn’t reached in a reasonable amount of time.

Settling Logic

A system is considered settled if either:

• The specified timeout has elapsed since the first call to Tolerances::check, OR
• Both:
  1. The error and velocity are within their respective tolerances.
  2. The system has maintained these tolerances for the specified duration.

If the system leaves the tolerance window before the duration is met, the tolerance timer resets.

Fields

duration: Option<Duration>

Duration for which error_tolerance and velocity_tolerance must be satisfied.

error_tolerance: Option<f64>

Minimum error range.

velocity_tolerance: Option<f64>

Minimum velocity range.

Implementations

impl Tolerances

pub const fn new() -> Self

Creates a new Tolerances instance with no configured tolerances or timings.

Until tolerances are configured using the builder methods, all tolerance checks will pass immediately.

pub const fn error(&mut self, tolerance: f64) -> Self

Sets the maximum acceptable error value for settling.

The error tolerance defines how close to the target position the system must be to be considered “within tolerance”.

pub const fn velocity(&mut self, tolerance: f64) -> Self

Sets the maximum acceptable velocity for settling.

The velocity tolerance defines how slow the system must be moving to be considered “stable”.

pub const fn duration(&mut self, duration: Duration) -> Self

Sets how long the system must remain within tolerances to be considered settled.

This duration acts as a “debounce” to ensure the system has truly stabilized and isn’t just passing through the tolerance window momentarily.

pub fn check(&mut self, error: f64, velocity: f64) -> bool

Checks if the system has settled based on current error and velocity.

This method should be called periodically (typically in a control loop) with current system measurements. It will return true when either:

• The specified timeout has elapsed since the first call to this function, OR
• Both:
  1. The error and velocity are within their respective tolerances.
  2. The system has maintained these tolerances for the specified duration.

Parameters

• error - Difference between the setpoint and measured state of the system.
• velocity - Measurement of how fast the system response is changing over time.

Trait Implementations

impl Clone for Tolerances

fn clone(&self) -> Tolerances

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Tolerances

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

Formats the value using the given formatter.

impl Default for Tolerances

fn default() -> Tolerances

Returns the “default value” for a type.

impl PartialEq for Tolerances

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

fn partial_cmp(&self, other: &Tolerances) -> 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 Copy for Tolerances

impl StructuralPartialEq for Tolerances