Mastering PID Control: Theory, Tuning, and MATLAB/Simulink Implementation

Essence of Control: Eliminating Error

Any control system strives to make the actual value as close as possible to the target value, reducing the error (the difference) to zero.

The controller calculates a suitable control effort based on this error and drives an actuator (valve, motor, etc.) so that the error converges toward zero.

Proportional Control

Proportional control applies a control effort directly proportional to the current error: the larger the error, the stronger the action.

Example: If the desired temperature is 40 °C and the measured temperature is 30 °C (error = 10 °C), the valve is opened widely; if the error is only 2 °C, the valve is adjusted slightly.

Mathematically, u(t) = K_p \times e(t), where K_p is the proportional gain. A large K_p yields fast response but may cause overshoot and oscillation; a small K_p leads to sluggish response and steady‑state error.

Proportional control alone cannot eliminate steady‑state error because the control effort diminishes as the error approaches zero.

Integral Control

Integral control eliminates steady‑state error by accumulating the error over time, regardless of how small it becomes.

It acts like an accountant that records every error sample and sums them; even a tiny error repeated many times builds up enough control effort to drive the error to zero.

Mathematically, u(t) = K_i \int_0^t e(\tau) d\tau, where K_i is the integral gain. This removes static offset but can slow the response and cause "integral wind‑up" if the accumulated error becomes excessive.

Derivative Control

Derivative control predicts the future trend of the error by reacting to its rate of change.

Continuing the temperature example, if the temperature is rising quickly toward the setpoint, the controller reduces the valve opening pre‑emptively to avoid overshoot.

Mathematically, u(t) = K_d \frac{de(t)}{dt}, where K_d is the derivative gain. It improves stability and reduces overshoot but is highly sensitive to measurement noise, so K_d must be kept modest.

Combined Action: 1 + 1 + 1 > 3

Proportional : provides immediate response proportional to the current error.

Integral : accumulates past errors to eliminate steady‑state offset.

Derivative : forecasts future error trends to improve dynamic performance.

The synergy of the three terms yields fast response, zero steady‑state error, and reduced oscillation, which explains the enduring popularity of PID controllers.

Parameter Tuning

PID has only three parameters (Kp, Ki, Kd), but finding suitable values is non‑trivial. A common engineering practice is the trial‑and‑error method in the order: first tune Kp, then Ki, and finally Kd.

Typical adjustments:

If the system oscillates, decrease Kp.

If the response is too slow, increase Kp.

If overshoot is excessive, reduce Kd.

If steady‑state error persists, increase Ki.

If the system is sluggish in suppressing overshoot, increase Kd.

This iterative process balances speed, stability, and accuracy.

MATLAB/Simulink Simulation

Simulation validates the theory. MATLAB/Simulink offers a powerful environment for PID control. The article uses a second‑order plant as an example and presents two implementation approaches.

MATLAB Code Implementation

Discrete PID can be realized with an incremental algorithm, which computes the control increment at each sample.

ts = 0.01;                     % Sample time
sys = tf(1, [1, 2, 1]);       % Transfer function of the plant

dsys = c2d(sys, ts, 'z');    % Discretize using zero‑order hold
[num, den] = tfdata(dsys, 'v');

kp = 10; ki = 0.03; kd = 0.1; % PID parameters

for k = 1:1000
    % Incremental PID calculation
    du(k) = kp*(error-error_1) + ki*error + kd*(error-2*error_1+error_2);
    u(k) = u_1 + du(k);
    u(k) = max(-10, min(10, u(k))); % Saturation

    % Difference equation for plant output
    y(k) = -den(2)*y_1 - den(3)*y_2 + num(2)*u_1 + num(3)*u_2;
end

Simulink Graphical Implementation

Simulink provides a block‑diagram approach. The simplest method uses the built‑in PID Controller block: feed a Step signal as the reference, compute the error with a Sum block, pass the error to the PID block, and route the controller output to a Transfer Function block representing the plant. Feed the plant output back to the Sum block to close the loop.

Setting the PID block parameters to P=10, I=0.03, D=0.1 and running the simulation shows a fast, stable, and accurate tracking of the setpoint.

An alternative is to construct the PID manually with three parallel branches: a Gain block for proportional action, an Integrator block for integral action, and a Derivative block for derivative action, then sum the three outputs. This layout makes the internal structure of the PID controller explicit.

Conclusion

PID control uses a simple mathematical structure to address the most common control problem—making a system follow a desired trajectory without requiring an exact model. By treating the error from the perspectives of "now", "past", and "future", PID achieves rapid, stable, and accurate performance. MATLAB and Simulink enable rapid prototyping, visualization of parameter effects, and verification of the controller before deployment in real engineering projects.