Agent skill
imc-tuning-rules
Calculate PI/PID controller gains using Internal Model Control (IMC) tuning rules for first-order systems.
Install this agent skill to your Project
npx add-skill https://github.com/benchflow-ai/skillsbench/tree/main/tasks-no-skills/hvac-control/environment/skills/imc-tuning-rules
SKILL.md
IMC Tuning Rules for PI/PID Controllers
Overview
Internal Model Control (IMC) is a systematic method for tuning PI/PID controllers based on a process model. Once you've identified system parameters (K and tau), IMC provides controller gains.
Why IMC?
- Model-based: Uses identified process parameters directly
- Single tuning parameter: Just choose the closed-loop speed (lambda)
- Guaranteed stability: For first-order systems, always stable if model is accurate
- Predictable response: Closed-loop time constant equals lambda
IMC Tuning for First-Order Systems
For a first-order process with gain K and time constant tau:
Process: G(s) = K / (tau*s + 1)
The IMC-tuned PI controller gains are:
Kp = tau / (K * lambda)
Ki = Kp / tau = 1 / (K * lambda)
Kd = 0 (derivative not needed for first-order systems)
Where:
Kp= Proportional gainKi= Integral gain (units: 1/time)Kd= Derivative gain (zero for first-order)lambda= Desired closed-loop time constant (tuning parameter)
Choosing Lambda (λ)
Lambda controls the trade-off between speed and robustness:
| Lambda | Behavior |
|---|---|
lambda = 0.1 * tau |
Very aggressive, fast but sensitive to model error |
lambda = 0.5 * tau |
Aggressive, good for accurate models |
lambda = 1.0 * tau |
Moderate, balanced speed and robustness |
lambda = 2.0 * tau |
Conservative, robust to model uncertainty |
Default recommendation: Start with lambda = tau
For noisy systems or uncertain models, use larger lambda. For precise models and fast response needs, use smaller lambda.
Implementation
def calculate_imc_gains(K, tau, lambda_factor=1.0):
"""
Calculate IMC-tuned PI gains for a first-order system.
Args:
K: Process gain
tau: Time constant
lambda_factor: Multiplier for lambda (default 1.0 = lambda equals tau)
Returns:
dict with Kp, Ki, Kd, lambda
"""
lambda_cl = lambda_factor * tau
Kp = tau / (K * lambda_cl)
Ki = Kp / tau
Kd = 0.0
return {
"Kp": Kp,
"Ki": Ki,
"Kd": Kd,
"lambda": lambda_cl
}
PI Controller Implementation
class PIController:
def __init__(self, Kp, Ki, setpoint):
self.Kp = Kp
self.Ki = Ki
self.setpoint = setpoint
self.integral = 0.0
def compute(self, measurement, dt):
"""Compute control output."""
error = self.setpoint - measurement
# Integral term
self.integral += error * dt
# PI control law
output = self.Kp * error + self.Ki * self.integral
# Clamp to valid range
output = max(output_min, min(output_max, output))
return output
Expected Closed-Loop Behavior
With IMC tuning, the closed-loop response is approximately:
y(t) = y_setpoint * (1 - exp(-t / lambda))
Key properties:
- Rise time: ~2.2 * lambda to reach 90% of setpoint
- Settling time: ~4 * lambda to reach 98% of setpoint
- Overshoot: Minimal for first-order systems
- Steady-state error: Zero (integral action eliminates offset)
Tips
- Start conservative: Use
lambda = tauinitially - Decrease lambda carefully: Smaller lambda = larger Kp = faster but riskier
- Watch for oscillation: If output oscillates, increase lambda
- Anti-windup: Prevent integral wind-up when output saturates
Recommended Agent Skills
Expand your agent's capabilities with these related and highly-rated skills.
csv-processing
Use this skill when reading sensor data from CSV files, writing simulation results to CSV, processing time-series data with pandas, or handling missing values in datasets.
pid-controller
Use this skill when implementing PID control loops for adaptive cruise control, vehicle speed regulation, throttle/brake management, or any feedback control system requiring proportional-integral-derivative control.
yaml-config
Use this skill when reading or writing YAML configuration files, loading vehicle parameters, or handling config file parsing with proper error handling.
simulation-metrics
Use this skill when calculating control system performance metrics such as rise time, overshoot percentage, steady-state error, or settling time for evaluating simulation results.
vehicle-dynamics
Use this skill when simulating vehicle motion, calculating safe following distances, time-to-collision, speed/position updates, or implementing vehicle state machines for cruise control modes.
web-interface-guidelines
Vercel's comprehensive UI guidelines for building accessible, performant web interfaces. Use this skill when reviewing or building UI components for compliance with best practices around accessibility, performance, animations, and visual stability.
Didn't find tool you were looking for?