Struct PidGains 

pub struct PidGains {
    pub kp: f64,
    pub ki: f64,
    pub kd: f64,
    pub integral_max: f64,
}

PID controller gains for frame time regulation.

Mathematical Model

Let e_t = frame_time_t − target be the error signal at frame t.

The PID control output is:

u_t = Kp * e_t  +  Ki * Σ_{j=0..t} e_j  +  Kd * (e_t − e_{t−1})

The output u_t maps to degradation level adjustments:

• u_t > degrade_threshold → degrade one level (if e-process permits)
• u_t < -upgrade_threshold → upgrade one level
• otherwise → hold current level

Gain Selection Rationale

For a 16ms target (60fps):

• Kp = 0.5: Proportional response. Moderate gain avoids oscillation while still reacting to single-frame overruns.
• Ki = 0.05: Integral term. Low gain eliminates steady-state error over ~20 frames without integral windup issues.
• Kd = 0.2: Derivative term. Provides anticipatory damping to reduce overshoot when frame times are trending upward.

Stability Analysis

For a first-order plant model G(s) = 1/(τs + 1) with τ ≈ 1 frame:

• Phase margin > 45° with these gains
• Gain margin > 6dB
• Settling time ≈ 8-12 frames for a step disturbance

Anti-windup: integral term is clamped to [-integral_max, +integral_max] to prevent runaway accumulation during sustained overload.

Fields

kp: f64

Proportional gain. Reacts to current error magnitude.

ki: f64

Integral gain. Eliminates steady-state error over time.

kd: f64

Derivative gain. Dampens oscillations by reacting to error rate.

integral_max: f64

Maximum absolute value of the integral accumulator (anti-windup).

Trait Implementations

impl Clone for PidGains

fn clone(&self) -> PidGains

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PidGains

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

Formats the value using the given formatter.

impl Default for PidGains

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for PidGains

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