EVOLV/wiki/concepts/pid-control-theory.md

PID Control for Process Applications

Note

Reference page. Maintained for context; not regenerated by code. See Home for current top-level navigation.

Used by: mechanical-process-engineer agent, node-red-runtime agent, generalFunctions/src/pid/ Validation: Verified against Astrom & Hagglund (ISA, 2006) and MATLAB/Simulink documentation

Continuous PID Controller

Standard (ISA/Ideal) Form

u(t) = K_p · [e(t) + (1/T_i) · ∫e(τ)dτ + T_d · de(t)/dt]

Where:

• u(t) = controller output
• e(t) = error = setpoint - process variable (SP - PV)
• K_p = proportional gain
• T_i = integral time (seconds)
• T_d = derivative time (seconds)

Parallel Form

u(t) = K_p · e(t) + K_i · ∫e(τ)dτ + K_d · de(t)/dt

Where K_i = K_p/T_i and K_d = K_p · T_d

Discrete PID Implementation

Positional Form (absolute output)

u[k] = K_p · e[k] + K_i · Δt · Σe[j] + K_d · (e[k] - e[k-1]) / Δt

• Computes the absolute output value each cycle
• Requires tracking of the integral sum
• Subject to integral windup
• Used when the controller output directly sets an actuator position

Velocity Form (incremental output)

Δu[k] = K_p · (e[k] - e[k-1]) + K_i · Δt · e[k] + K_d · (e[k] - 2·e[k-1] + e[k-2]) / Δt
u[k] = u[k-1] + Δu[k]

• Computes the change in output each cycle
• Inherently bumpless on mode transfers (auto→manual→auto)
• Less prone to windup (but still needs anti-windup for output limits)
• Preferred for incremental actuators (VFDs, variable valves)

Anti-Windup Strategies

Integral windup occurs when the controller output saturates (hits actuator limits) but the integral term continues to accumulate, causing large overshoot when the error changes sign.

1. Clamping (Conditional Integration)

Stop integrating when the output is saturated and the error has the same sign as the integral term:

if (u_raw > u_max || u_raw < u_min) && sign(e) == sign(integral):
    freeze integral (do not accumulate)
else:
    integral += e * Δt

• Simple to implement
• Effective for most process control applications
• The approach used in the EVOLV generalFunctions PID implementation

2. Back-Calculation

When the output saturates, feed back the difference between the saturated and unsaturated output to "unwind" the integrator:

integral += (K_i · e + K_b · (u_saturated - u_raw)) · Δt

Where K_b = 1/T_t (tracking time constant, typically T_t = √(T_i · T_d) or T_t = T_d).

• More sophisticated than clamping
• Better performance for systems with large disturbances
• Recommended by Astrom & Hagglund for demanding applications

3. Integrator Reset

Reset the integrator to a value that would produce the saturated output:

if u_raw > u_max:
    integral = (u_max - K_p · e) / K_i

• Simple but can be aggressive
• May cause discontinuities

Derivative Filtering

The derivative term amplifies high-frequency noise. Always filter it:

First-Order Low-Pass Filter on D-Term

D_filtered[k] = α · D_filtered[k-1] + (1-α) · D_raw[k]

Where α = T_f / (T_f + Δt) and T_f = T_d / N (N typically 5-20, default 10).

Derivative on PV (not Error)

To avoid derivative kick on setpoint changes:

D = -K_d · (PV[k] - PV[k-1]) / Δt   (instead of using error)

This is the standard approach for process control.

Cascade PID

Two nested loops where the outer (master) loop's output is the setpoint for the inner (slave) loop.

[SP_outer] → [PID_outer] → [SP_inner] → [PID_inner] → [Actuator] → [Process]
                 ↑                            ↑
            [PV_outer] ←──── [Process] ←── [PV_inner]

Design Rules

• Inner loop must be 5-10x faster than outer loop
• Tune inner loop first (with outer loop in manual)
• Then tune outer loop
• Anti-windup on outer loop essential (its output is bounded by inner loop's SP limits)

EVOLV Application

• Outer: Level controller → outputs flow setpoint
• Inner: Flow controller → outputs pump speed
• pumpingStation node coordinates this cascade

Tuning Methods

Ziegler-Nichols (Ultimate Gain Method)

1. Set I and D to zero, increase K_p until sustained oscillation
2. Record ultimate gain K_u and ultimate period T_u
3. Apply: K_p = 0.6·K_u, T_i = T_u/2, T_d = T_u/8

Cohen-Coon (Process Reaction Curve)

1. Apply step change, record process reaction curve
2. Identify: gain K, dead time L, time constant τ
3. Apply formulas based on K, L, τ

Lambda Tuning (IMC-based)

1. Identify process as FOPDT: K, L, τ
2. Choose closed-loop time constant λ (typically λ = max(3·L, τ))
3. K_p = τ/(K·λ), T_i = τ

• Preferred for process control — gives non-oscillatory response
• Directly specifies desired closed-loop speed
• Robust to model uncertainty when λ is chosen conservatively

Authoritative References

1. Astrom, K.J. & Hagglund, T. (2006). "Advanced PID Control." ISA — The Instrumentation, Systems, and Automation Society.
2. Astrom, K.J. & Hagglund, T. (1995). "PID Controllers: Theory, Design, and Tuning." 2nd ed., ISA.
3. Seborg, D.E. et al. (2011). "Process Dynamics and Control." 3rd ed., Wiley. (Chapter on PID control)
4. MATLAB/Simulink documentation — "Anti-Windup Control Using PID Controller Block"
5. Smith, C.A. & Corripio, A.B. (2005). "Principles and Practices of Automatic Process Control." 3rd ed., Wiley.