Pid Loop Tuning

Understand process dynamics before tuning. Execute a bump test (step test) in manual mode to reveal the process characteristics.

Self-Regulating Processes (flow, pressure, temperature):

• Extract process gain (Kp), time constant (τp), and dead time (Td)
• Use FOPDT (First Order Plus Dead Time) model—sufficient for most PID tuning

Integrating Processes (tank levels):

• Calculate gain from slope change or fill time
• Process never settles—requires different approach

CSV-Based Identification (Recommended)

For practical plant data, use step_test_identify.py with CSV files:

# Identify FOPDT from CSV step test data
uv run scripts/step_test_identify.py data.csv \
    --step-time 100 \
    --pv-range 0 200 \
    --op-range 0 100 \
    --plot

CSV Format Requirements:

• Required columns: timestamp, PV, OP
• Optional columns: SP, dist_* (disturbance variables)
• Sampling time inferred automatically from timestamp

Scaling for Meaningful Gain:

Gain (Kp) = %PV change / %OP change

Where:
  %PV = 100 × (PV - PV_min) / (PV_max - PV_min)
  %OP = 100 × (OP - OP_min) / (OP_max - OP_min)

This produces a dimensionless gain suitable for direct use in lambda tuning formulas.

Identification Methods:

• --method=regression (DEFAULT): Nonlinear least squares FOPDT fit with R² and RMSE metrics
• --method=ctrlsys: ctrlsys subspace ID (ib01ad/ib01bd) for higher-order systems

See Process Identification for detailed procedures and CSV format documentation.

2. Understand the Controller

The PI combination (Proportional + Integral) is the workhorse of industrial control, representing 100% of common applications.

Proportional (P) Action:

• Responds to error magnitude (present error)
• Goal: Stop the changing error
• Limitation: Results in permanent offset when used alone

Integral (I) Action:

• Responds to error duration (past error/area under curve)
• Goal: Make error zero, eliminate offset
• Acts as "watchdog" until PV returns to setpoint

Derivative (D) Action:

• Responds to rate of change (future error prediction)
• Rarely used due to noise sensitivity
• Set to zero for most industrial applications

3. Apply Lambda Tuning (Direct Synthesis)

Lambda tuning is a systematic, model-based method that delivers predictable, non-oscillatory responses.

Key Parameter: Lambda (λ) - The desired closed-loop time constant

• Choose λ ≥ 3 × Dead Time for robust performance
• Larger λ = slower, safer response (conservative)
• Smaller λ = faster, aggressive response (requires high model confidence)

Self-Regulating Process Tuning Rules:

def lambda_tuning_pi(Kp, tau_p, lambda_cl):
    """Calculate PI parameters using Direct Synthesis (Lambda Tuning).

    Args:
        Kp: Process gain (ΔPV/ΔOutput)
        tau_p: Process time constant (seconds)
        lambda_cl: Desired closed-loop time constant (seconds)

    Returns:
        (Kc, Ti): Controller gain and integral time
    """
    tau_ratio = lambda_cl / tau_p
    Kc = (1.0 / Kp) / tau_ratio
    Ti = tau_p
    return Kc, Ti

# Example calculation
Kp = 2.0      # Process gain
tau_p = 10.0  # Time constant
lambda_cl = 30.0  # Desired response time (3 × dead time)

Kc, Ti = lambda_tuning_pi(Kp, tau_p, lambda_cl)
print(f"Controller Gain Kc: {Kc:.3f}")
print(f"Integral Time Ti:   {Ti:.1f} seconds")
# Output:
# Controller Gain Kc: 0.167
# Integral Time Ti:   10.0 seconds

Integrating Process Tuning Rules (tanks):

def tank_tuning_pi(Kp, lambda_arrest):
    """Calculate PI parameters for integrating processes.

    Args:
        Kp: Process gain (1/fill_time) or slope method
        lambda_arrest: Desired arrest rate (seconds)

    Returns:
        (Kc, Ti): Controller gain and integral time
    """
    Kc = 2.0 / (Kp * lambda_arrest)
    Ti = 2.0 * lambda_arrest
    return Kc, Ti

# Example: Tank level control
fill_time = 20.0  # minutes to fill tank 0-100%
Kp = 1.0 / fill_time  # Process gain
lambda_arrest = fill_time / 5.0  # Fast response: fill_time / 5

Kc, Ti = tank_tuning_pi(Kp, lambda_arrest)
print(f"Tank Controller Gain Kc: {Kc:.2f}")
print(f"Tank Integral Time Ti:   {Ti:.1f} min")
# Output:
# Tank Controller Gain Kc: 2.50
# Tank Integral Time Ti:   8.0 min

See Lambda Tuning Methods for detailed derivations and advanced scenarios.

4. Validate Performance

Test the tuned controller in automatic mode with a small setpoint change. Verify the response matches design specifications.

Expected Response:

• Self-regulating: Smooth first-order response, settling in ~4λ time constants
• Integrating: Critically damped response, level recovers in ~6 arrest rates
• No overshoot or oscillation (non-oscillatory by design)

Troubleshooting:

Critical Considerations

Units Must Match:

• Time constant and integral time must use same units (seconds or minutes)
• Mismatch causes tuning error factor of 60
• Verify controller documentation for expected units

Dead Time Limits:

• If Td > 3 × λ, conventional PI fails
• Use advanced methods: Smith Predictor or IMC
• See Advanced Methods

Model Mismatch:

• Real processes deviate from first-order model
• Compensate by increasing λ (larger tau ratio)
• Robustness vs. speed tradeoff

Nonlinearities:

• Stiction, dead band, varying gain cannot be fixed by tuning
• Require mechanical repair or adaptive control
• See Nonlinearities

PID Controller Forms

Critical: DCS/PLC vendors implement PID differently. Using tuning parameters in the wrong form causes factor-of-Ti errors.

ISA (Standard/Ideal) Form

u(t) = Kc × [e(t) + (1/Ti)∫e(t)dt + Td×de/dt]

• Kc multiplies all terms
• Used by: Honeywell, Emerson DeltaV, Siemens

Parallel (Independent) Form

u(t) = Kp×e(t) + Ki∫e(t)dt + Kd×de/dt

• Each term has independent gain
• Used by: Allen-Bradley, some Yokogawa

Conversion Table

def isa_to_parallel(Kc, Ti, Td=0):
    """Convert ISA form to Parallel form."""
    Kp = Kc
    Ki = Kc / Ti if Ti > 0 else 0
    Kd = Kc * Td
    return Kp, Ki, Kd

def parallel_to_isa(Kp, Ki, Kd=0):
    """Convert Parallel form to ISA form."""
    Kc = Kp
    Ti = Kp / Ki if Ki > 0 else float('inf')
    Td = Kd / Kp if Kp > 0 else 0
    return Kc, Ti, Td

# Example: Lambda tuning gives ISA parameters
Kc, Ti = 0.938, 45.0  # ISA form from lambda tuning
Kp, Ki, Kd = isa_to_parallel(Kc, Ti)
print(f"Parallel: Kp={Kp:.3f}, Ki={Ki:.4f}, Kd={Kd}")
# Output: Parallel: Kp=0.938, Ki=0.0208, Kd=0

Warning: Entering ISA parameters into a Parallel controller (or vice versa) results in grossly incorrect integral action.

Additional Resources

Interactive Tools

• Notebooks - Jupyter notebooks for iterative tuning workflows

  • pid_analysis_workflow.ipynb - Complete control theory analysis using ctrlsys: Bode plots, pole/zero analysis, frequency response, and discretization
  • Uses: ctrlsys for state-space analysis (tf01md, ab04md, tb05ad), numpy for arrays, matplotlib for visualization
  • Use for: Visual validation, frequency domain analysis, documenting tuning sessions, discretization for embedded deployment

• Scripts - Command-line calculation tools

  • step_test_identify.py - CSV-based FOPDT identification with proper scaling and regression fitting
  • lambda_tuning_calculator.py - Quick PI parameter calculation from process models

Reference Documentation

• Process Identification - Detailed bump test procedures, slope methods, fill time calculations
• PID Fundamentals - Deep dive into P, I, D actions and controller forms
• Lambda Tuning - Complete derivation, tau ratio selection, frequency analysis
• Integrating Processes - Tank level tuning, arrest rate selection, validation
• Advanced Methods - Smith Predictor, IMC, dead time compensation
• Nonlinearities - Stiction diagnosis, dead band, adaptive control

Quick Reference

Self-Regulating PI Tuning:

• Kc = (1/Kp) / (λ/τp)
• Ti = τp
• Choose λ ≥ 3×Td

Integrating PI Tuning:

• Kc = 2 / (Kp × λ_arrest)
• Ti = 2 × λ_arrest
• λ_arrest = fill_time / M (M=5 for fast, M=2 for slow)

Validation Check:

• For ideal tuning: Kc × Kp × Ti = 4