1. Fundamentals of PID Controller

---

1.1 Core Concepts and Mathematical Model of PID Control

PID control regulates the system error $ e(t) = r(t) - y(t) $ in real-time through three actions: Proportional (P), Integral (I), and Derivative (D). The control output is given by:

u(t) = K_p \left[ e(t) + \frac{1}{T_i} \int_0^t e(\tau)d\tau + T_d \frac{de(t)}{dt} \right]

Here, $K_p$ determines the response speed, $T_i$ influences steady-state accuracy, and $T_d$ enhances dynamic stability. The proportional term responds instantly to the error, the integral term accumulates historical deviations to eliminate static error, and the derivative term predicts trends to suppress overshoot. For a first-order inertial system $G(s) = \frac{1}{Ts+1}$, increasing $K_p$ reduces the rise time but can cause oscillations. Introducing integral action eliminates steady-state error entirely, but excessive integral gain can lead to sluggishness. The derivative term effectively dampens the system's transient response, improving robustness. These characteristics provide the theoretical basis for subsequent Simulink modeling.

2. Basics of PID Modeling in Simulink

---

In modern control system design, MATLAB/Simulink serves as a standard tool for modeling, simulation, and analysis in both industry and academia. Its graphical interface makes building complex control logic intuitive and efficient, especially for widely-used PID controllers. This chapter details the complete process of building a PID control system in Simulink, from understanding the environment and core modules to signal sources, observation tools, and closed-loop integration, forming a reusable and scalable methodology.

2.1 Simulink Development Environment and Modular Design Philosophy

Simulink, an extension of MATLAB, provides a block diagram-based approach for system-level modeling. It allows users to describe the input-output relationships and internal state evolution of dynamic systems graphically. This "what-you-see-is-what-you-get" paradigm reduces the gap between mathematical modeling and code implementation, enabling engineers to focus on control strategy design.

2.1.1 Simulink Interface and Simulation Process

After launching Simulink, the main interface includes the menu bar, toolbar, Model Browser, Library Browser, and the central model editing area. To start, create a blank model and drag blocks to build the system diagram.

A typical Simulink workflow is:

1. Requirement Analysis: Define the plant type (e.g., first-order system, motor model), control objectives (e.g., step tracking, disturbance rejection), and performance metrics.
2. Block Selection and Layout: Select necessary blocks (e.g., PID Controller, Transfer Fcn, Scope) from the library and arrange them on the canvas.
3. Signal Connections: Connect blocks with signal lines to build the forward path and feedback loop according to the control logic.
4. Parameter Configuration: Double-click blocks to set values (e.g., transfer function coefficients, PID gains, simulation time).
5. Run Simulation: Click "Run" to execute the simulation. Simulink uses its built-in solver for numerical integration of differential equations.
6. Result Analysis: Use Scope or To Workspace blocks to collect output data, then plot or calculate performance metrics in MATLAB.

This iterative "model → configure → execute → analyze" approach supports rapid prototyping and comparison of different strategies.

graph TD
    A[Define Control Objective] --> B[Select Components]
    B --> C[Build System Diagram]
    C --> D[Set Block Parameters]
    D --> E[Configure Simulation Options]
    E --> F[Run Simulation]
    F --> G[Observe Output Response]
    G --> H{Meets Performance?}
    H -- No --> I[Adjust Parameters or Structure]
    I --> C
    H -- Yes --> J[Save Model & Generate Report]

The diagram above illustrates the standard workflow for PID simulation in Simulink. A key advantage is that parameter changes don't require recompiling the entire model; simply re-running the simulation updates the response curve, greatly improving debugging efficiency.

Simulink also offers different simulation modes:

• Normal Mode: Default, suitable for most cases.
• Accelerator Mode: Converts model to C code for faster execution.
• Rapid Accelerator Mode: Further optimizes compilation, ideal for large-scale Monte Carlo simulations.

These modes can be selected via the Simulation > Mode menu, depending on computational resources and real-time requirements.

2.1.2 Library Browser and Common Component Categories

Simulink provides extensive predefined block libraries, including Continuous, Discrete, Nonlinear, Sources, Sinks, and more. The Library Browser allows you to browse all available blocks. Key categories include:

Category	Example Blocks	Description
Sources	Step, Sine Wave, Constant	Provide various test input signals
Sinks	Scope, To Workspace, Display	Output data display and storage
Continuous	Integrator, Derivative, Transfer Fcn	Model continuous-time dynamic systems
Math Operations	Sum, Gain, Product	Perform mathematical operations
Discrete	Discrete-Time Integrator, Zero-Order Hold	Components for discrete-time systems
Logic and Bit Operations	Relational Operator, Switch	Conditional logic and decision making
Signal Routing	Mux, Demux, Inport/Outport	Combine multiple signals, define ports

Among these, the Sum block is used for error comparison, Gain for proportional amplification, Integrator for integral action, and Derivative for derivative action—these four are the core components for manually building a PID controller.

For example, when implementing negative feedback, a Sum block configured with [+-] input signs subtracts the feedback value from the setpoint to get the error signal:

% Example: Sum block parameter settings
List of signs: +-
Inputs: 2
Icon shape: round

Analysis: The List of signs field determines the sign of each input port. +- means the first input is added and the second is subtracted, reflecting the typical feedback error equation $ e(t) = r(t) - y(t) $. This configuration is a foundational step in building a closed-loop system.

2.1.3 Signal Connections and Subsystem Encapsulation

In Simulink, signal lines represent data flow, connecting the output of one block to the input of another. Adding complexity leads to "spaghetti diagrams," which impair readability. To manage this, Simulink offers Subsystem Encapsulation, which groups related blocks into a single module, exposing only necessary input/output ports.

Creating a Subsystem:

1. Select the blocks to encapsulate.
2. Right-click and choose "Create Subsystem from Selection."
3. Simulink automatically generates a subsystem block with Inport and Outport blocks.
4. Double-click the subsystem to edit its internal logic.
5. Rename the subsystem (e.g., "PID_Controller") for clarity.

Further, you can apply a Mask to the subsystem, creating a custom parameter dialog. For instance, adding three adjustable parameters (Kp, Ti, Td) to the PID subsystem and assigning them to internal blocks via initialization code:

% Mask Initialization Code
P = Kp;
I = 1/Ti;
D = Td;

set_param('PID_Subsystem/P_Gain','Gain',num2str(P));
set_param('PID_Subsystem/I_Gain','Gain',num2str(I));
set_param('PID_Subsystem/D_Gain','Gain',num2str(D));

Parameter Explanation:

• Kp, Ti, Td: User inputs from the mask dialog.
• set_param function dynamically modifies block properties along a given path.
• This method achieves "encapsulate once, reuse many times," significantly improving modeling efficiency.

Using Annotations and Signal Labels enhances model readability. For example, labeling the error signal e(t) and the control signal u(t) aids collaboration and maintenance.

In summary, Simulink is more than a simulation tool; it's a methodology that supports modular, hierarchical design. By skillfully using library components, signal connection rules, and encapsulation techniques, you can build high-quality models that are clear, easy to debug, and scalable.

2.2 Constructing the Core PID Control System

There are two primary methods for implementing a PID controller in Simulink: using the built-in specialized block for quick modeling or manually building it from basic blocks for a deeper understanding. This section introduces both methods and compares their application scenarios.

2.2.1 Parallel PID Controller Structure

The most common PID implementation is the Parallel Form, with the control law:

u(t) = K_p \cdot e(t) + K_p \cdot \frac{1}{T_i} \int_0^t e(\tau)d\tau + K_p \cdot T_d \cdot \frac{de(t)}{dt}

Where:

• $ u(t) $: Controller output.
• $ e(t) $: Error signal (setpoint minus actual output).
• $ K_p $: Proportional gain.
• $ T_i $: Integral time constant.
• $ T_d $: Derivative time constant.

This structure features parallel calculation of the three actions before summation, offering clear physical meaning and easy parameter adjustment. The Simulink implementation diagram is:

graph LR
    e[e(t)] --> P[P: Kp*e(t)]
    e --> I[Integrator --> Gain: Kp/Ti]
    e --> D[Derivative --> Gain: Kp*Td]
    P --> Sum{{Sum}}
    I --> Sum
    D --> Sum
    Sum --> u[u(t)]

Here, the Integrator integrates the error, and the Derivative calculates the error rate of change. Both are multiplied by respective gains and summed with the proportional term. This structure directly mirrors the PID mathematical model and is suitable for teaching and mechanism research.

2.2.2 Manual Construction of a PID Controller

Here are the steps to manually build a parallel PID controller in Simulink:

1. Open a blank model.
2. Drag the following blocks from the library:
   • Sum (for error calculation)
   • Gain × 3 (for Kp, Kp/Ti, Kp*Td)
   • Integrator
   • Derivative
   • Mux (optional, for combining signals into a Scope)
3. Connect the blocks as follows:
   • The error signal branches into three paths.
   • The first path connects directly to the proportional gain block.
   • The second path goes through Integrator followed by the integral gain block.
   • The third path goes through Derivative followed by the derivative gain block.
   • The outputs of the three gain blocks are combined using a Sum block to produce the control output.

Parameter settings for the manual controller:

Block	Parameter Name	Value	Description
Proportional Gain	Gain	Kp	Proportional coefficient
Integral Gain	Gain	Kp / Ti	Integral gain
Derivative Gain	Gain	Kp * Td	Derivative gain

% Initialization script (run in MATLAB command window or Model Callback)
Kp = 1.0;
Ti = 2.0;
Td = 0.5;

Analysis: The manual approach is highly transparent, allowing you to study the effect of each action independently. For example, you can disconnect the derivative branch to study pure PI control or freeze the integral branch to simulate PD control. This flexibility is excellent for teaching and exploring the underlying mechanisms.

However, the Derivative block is inherently sensitive to noise, which can cause high-frequency chattering. In practice, a first-order low-pass filter is often added to create a filtered derivative term:

D(s) = \frac{K_p T_d s}{1 + N T_d s}

Where $ N $ is the filter coefficient (typically 8–20). This improvement is discussed in Chapter 4.

2.2.3 Using the Built-in PID Controller Block for Rapid Modeling

Simulink provides a highly integrated PID Controller block (located in Simulink > Continuous or Continuous PID Controller library). It supports switching between P, PI, PD, and PID modes and includes features like anti-windup, external integral, and setpoint weighting.

Usage steps:

1. Drag the PID Controller block into your model.
2. Double-click to open its parameter dialog.
3. Select the controller type (e.g., "PID").
4. Enter the Kp, Ti, Td parameters.
5. Optionally enable anti-windup to prevent integral saturation.
6. Connect the error input and the control output.

% Example parameter settings (can be loaded via script)
Kp = 1.5;
Ti = 1.8;
Td = 0.4;
N = 10; % Filter coefficient

Advantages:

• Automatically handles derivative filtering, avoiding manual modeling errors.
• Supports discretization options (e.g., sample time Ts).
• Provides a "real-time tuning" interface for online debugging.
• Seamlessly integrates with the Simulink Control Design toolkit for automatic tuning.

In summary, manual building is better for understanding principles, while the built-in block is more suited for engineering deployment. It is recommended that beginners first implement the controller manually to gain understanding before moving to the more efficient tool.

2.3 Configuring Input Signal Sources and Output Observation Tools

Effective system testing requires appropriate excitation signals and accurate measurement of results. Simulink offers various signal sources and display tools for comprehensive PID performance evaluation.

2.3.1 Sine Wave Generator Parameters

The Sine Wave block is commonly used for frequency response testing or simulating periodic disturbances. Key parameters include:

Parameter	Description	Example Value
Amplitude	Signal amplitude	1
Bias	DC offset	0
Frequency	Angular frequency (rad/s)	1
Phase	Initial phase (rad)	0

% Generating a sine wave with amplitude 2 and frequency 0.5 Hz
Amplitude = 2;
Frequency = 0.5 * 2*pi; % Convert to rad/s
Phase = 0;

Application: Used to test the system's ability to track inputs at different frequencies and for generating Bode plots.

2.3.2 Step Signal and Other Test Inputs

The Step block is the most common test signal for evaluating transient response characteristics (rise time, overshoot, etc.). Typical settings:

• Step time: 1s
• Initial value: 0
• Final value: 1

Other inputs include:

• Pulse Generator: For testing impulse response.
• Chirp Signal: A swept-frequency signal for frequency domain analysis.
• Random Number: For simulating random disturbances.

The choice depends on the plant characteristics and test objectives.

2.3.3 Oscilloscope (Scope) Multi-Channel Configuration and Data Capture

The Scope block is the most intuitive tool for observing signals. To enable multiple channels, use a Mux block to combine signals before connecting them to the Scope.

Key configuration options:

• Right-click Scope → Configuration Properties.
• Set Time span and Y-limits.
• Enable Log data to workspace to export data as a variable.
• Using the To Workspace block provides more flexible control over data format (e.g., Array, Structure With Time).

% Plotting exported data in MATLAB
plot(simout.time, simout.signals.values);
xlabel('Time (s)');
ylabel('Output');
title('Closed-loop Response');

Advanced Tip: Use the Simulation Data Inspector (SDI) to compare response curves from multiple simulation runs, making it easy to visualize parameter tuning effects.

2.4 System Connection and Simulation Framework Construction

A complete PID simulation model requires a plant, controller, feedback loop, and input/output interfaces.

2.4.1 Importing the Plant Model and Matching Interfaces

A common plant, such as a first-order inertial system, is:

G(s) = \frac{1}{2s + 1}

This can be implemented in Simulink using a Transfer Fcn block with:

• Numerator coefficients: [1]
• Denominator coefficients: [2 1]

Unit consistency is vital: if the controller output is voltage (V), the plant input should also be in V; the output might be temperature (°C) or speed (rpm), and these units should be noted on the Scope.

2.4.2 Building the Feedback Loop and Forming a Closed-Loop System

The closed-loop connection follows a standard structure:

1. The setpoint and feedback are subtracted by a Sum block to produce the error.
2. The error is fed into the PID controller.
3. The controller output drives the plant.
4. The plant output is returned as the feedback signal.

Ensure the feedback polarity is correct (usually negative feedback); otherwise, the system will diverge.

2.4.3 Signal Labeling and Model Readability Optimization

The final step is to label critical signals, such as:

• r(t): Reference input
• e(t): Error
• u(t): Control input
• y(t): System output

Use the Signal Name feature or text annotations. Consistency in font, color, and layout enhances the model's professionalism.

At this point, a complete Simulink PID simulation framework has been established, providing a reliable platform for future parameter tuning and performance analysis.

3. Theoretical Analysis of PID Parameters and Dynamic Response Characteristics

---

In modern control systems, the PID controller is widely used due to its simple structure, clear physical meaning, and strong adaptability. Although its form is simple, the coupling between the three core parameters—$ K_p $, $ T_i $, and $ T_d $—is complex, and each affects system dynamic performance differently. Understanding their independent and synergistic effects on closed-loop response is key to achieving high performance.

This chapter analyzes the specific impact of each parameter on rise time, overshoot, steady-state error, settling time, and disturbance rejection. It uses mathematical modeling, graphical analysis (e.g., root locus), and typical response curves for visualization. It also discusses the interaction effects between parameters, revealing why engineers cannot optimize a single metric in isolation but must balance stability, speed, and robustness. The ultimate goal is to provide a solid theoretical foundation and operational guidance for parameter tuning in Simulink.

3.1 The Impact of Proportional Gain Kp on System Behavior

Proportional control is the most basic and direct action in PID. It generates a control signal proportional to the current error $ e(t) = r(t) - y(t) $:

u_p(t) = K_p \cdot e(t)

$ K_p $, the proportional gain, determines the controller's "sensitivity" to the error. Increasing $ K_p $ enhances the system's response speed but can also introduce stability issues. A deep understanding of $ K_p $'s specific effects is essential for tuning intuition.

3.1.1 Effects of Increasing Kp on Rise Time and Overshoot

When $ K_p $ increases, the magnitude of the controller output changes more for the same error, pushing the system toward the setpoint faster. This significantly reduces the rise time ($ t_r $), the time for the output to first reach 90% of its final value. However, this acceleration is not without cost.

Consider a unity-feedback first-order system:
G(s) = \frac{1}{\tau s + 1}
With proportional control, the closed-loop transfer function is:
T(s) = \frac{K_p G(s)}{1 + K_p G(s)} = \frac{K_p}{\tau s + 1 + K_p} = \frac{\frac{K_p}{1+K_p}}{\frac{\tau}{1+K_p}s + 1}

As $ K_p $ increases, the effective time constant decreases (to $ \frac{\tau}{1+K_p} $), making the response faster. The steady-state gain also approaches 1, improving accuracy. The situation is more complex for second-order and higher systems.

Consider a standard second-order system:
G(s) = \frac{\omega_n^2}{s^2 + 2\zeta\omega_n s + \omega_n^2}
With proportional control, the closed-loop characteristic equation becomes:
s^2 + 2\zeta\omega_n s + \omega_n^2(1 + K_p) = 0
The natural frequency increases to $ \omega_n’ = \sqrt{(1+K_p)}\omega_n $, speeding up the response. However, the damping ratio decreases to $ \zeta’ = \zeta / \sqrt{1+K_p} $, meaning the system becomes underdamped, leading to greater overshoot ($ M_p $) and potentially oscillations.

The following table shows the performance trend for a second-order system with different $ K_p $ values:

$ K_p $	Rise Time $ t_r $ (s)	Overshoot $ M_p $ (%)	Settling Time $ t_s $ (s)	Stability
1	1.8	16	4.5	Stable
3	1.2	32	6.0	Marginally Stable
5	0.9	48	Sustained Oscillation	Unstable

Note: Based on simulations for $ G(s)=\frac{4}{s^2 + 0.8s + 4} $ in a closed-loop system.

This shows that while increasing $ K_p $ speeds up the response, an excessively high gain can make the system unstable. This warns against blindly increasing the proportional term.

This phenomenon can be quickly tested using MATLAB/Simulink. The code below compares step responses for different $ K_p $ values:

% Define the plant
s = tf('s');
G = 4 / (s^2 + 0.8*s + 4);

% Set multiple Kp values
Kp_values = [1, 3, 5];
figure;
hold on;
for i = 1:length(Kp_values)
    Kp = Kp_values(i);
    T = feedback(Kp*G, 1); % Unity negative feedback loop
    step(T, 'DisplayName', ['Kp = ', num2str(Kp)]);
end
legend show;
title('Comparison of Step Responses for Different Kp');
xlabel('Time (s)');
ylabel('Output');
grid on;

Code Explanation:

• s = tf('s');: Defines the Laplace variable $ s $ for transfer function construction.
• G = 4 / (s^2 + 0.8*s + 4);: Creates the open-loop transfer function.
• Kp_values = [1, 3, 5];: Defines the test gains.
• feedback(Kp*G, 1): Builds the closed-loop system with unity negative feedback.
• step(T, ...): Plots the step response curve, automatically labeling it.
• hold on;: Keeps all curves on the same figure for comparison.

Running this script generates clear trend plots illustrating $ K_p $'s impact on system response.

3.1.2 Instability Caused by Excessively High Proportional Gain

When $ K_p $ becomes too large, the system poles move towards the imaginary axis and may cross into the right half-plane, causing instability. This process can be systematically analyzed using the Root Locus method.

The root locus plots the trajectory of the closed-loop system's poles as a function of gain $ K_p $. Basic rules for drawing root loci include:

• Originates at the open-loop poles and terminates at the open-loop zeros or infinity.
• Segments on the real axis are to the left of an odd number of open-loop poles and zeros.
• The asymptote center is at $ \sigma_a = \frac{\sum p_i - \sum z_j}{n - m} $, with angles $ \phi_a = \frac{(2k+1)\pi}{n-m} $.

For the second-order system example, its open-loop poles are at $ s = -0.4 \pm j1.96 $ with no finite zeros. As $ K_p $ increases from 0 to ∞, the root locus branches extend into the left half-plane in a symmetrical pattern.

To draw the root locus in MATLAB:

rlocus(G);
title('Root Locus Analysis of Kp Effect on Pole Locations');
grid on;
[k, poles] = rlocfind(G); % Manually select a gain point

By clicking on a point on the locus, you can get the corresponding $ K_p $ and pole coordinates. For example, when $ K_p > 6 $, the real part of the poles approaches zero, and the system exhibits sustained oscillations. A further increase makes the real part positive, leading to complete instability.

The following Mermaid flowchart illustrates the decision process for assessing system stability:

graph TD
    A[Start Kp Analysis] --> B{Get Open-Loop Transfer Function G(s)}
    B --> C[Plot Root Locus]
    C --> D[Observe Pole Movement]
    D --> E{Any poles enter Right Half-Plane?}
    E -- Yes --> F[System is Unstable]
    E -- No --> G{Are poles far from Imaginary Axis?}
    G -- Yes --> H[System Stable with Good Damping]
    G -- No --> I[System May Be at Risk of Oscillation]
    F --> J[Reduce Kp to Restore Stability]
    I --> K[Evaluate Need for Integral/Derivative Compensation]

This flowchart demonstrates the standard strategy for addressing high-gain risks: using graphical tools to identify potential instability and then taking corrective action by modifying parameters or the controller structure.

3.1.3 Understanding the Effect of Kp on Pole Movement via Root Locus

Further analysis shows that stability depends not only on the pole location but also on the distribution of the dominant poles. Dominant poles are the pair of complex conjugate poles closest to the imaginary axis, and they dictate the system's transient response characteristics.

Continuing with the second-order system example, let $ K_p = 4 $. The closed-loop characteristic equation is:
s^2 + 0.8s + 4(1+4) = s^2 + 0.8s + 20 = 0
The poles are:
s = \frac{-0.8 \pm \sqrt{0.64 - 80}}{2} = -0.4 \pm j4.47
The real part is negative, so the system is stable. However, the large imaginary part indicates high oscillation frequency, leading to significant fluctuations.

To achieve a desired damping ratio of $ \zeta = 0.707 $ (the optimal damping), we need:
\zeta = \frac{|Re(s)|}{\sqrt{Re(s)^2 + Im(s)^2}} = 0.707
This implies the desired dominant poles should lie on a line at 45 degrees, such as $ s = -a \pm ja $.

To shift the poles to this desired region, a controller (like PD or PID) can be added to reshape the root locus. This leads to the importance of derivative and integral compensation covered in subsequent sections.

In summary, $ K_p $ is the primary lever for adjusting response speed. However, its effect has diminishing returns: a small increase is beneficial, but too large a value induces oscillation or instability. A suitable $ K_p $ must be chosen by considering the system order, inherent damping, and performance requirements.

3.2 Integral Time Constant Ti and Steady-State Error Elimination

The purpose of integral control is to eliminate steady-state error, a task that proportional control alone cannot achieve. In the presence of constant load disturbances or model inaccuracies, proportional action can only maintain a non-zero error to generate the control force. The integral term, by accumulating the error over time, continuously adjusts the output until the error is completely eliminated.

The output of a standard PI controller is:
u_{pi}(t) = K_p e(t) + \frac{K_p}{T_i} \int_0^t e(\tau)\,d\tau
Here, $ T_i $ is the integral time constant, which controls the strength of the integral action. A smaller $ T_i $ means stronger integral action (because $ K_i = K_p / T_i $ is larger), and vice versa.

3.2.1 Mathematical Expression of Error Accumulation by the Integral Action

From a frequency domain perspective, the integral term appears in the transfer function as $ \frac{1}{T_i s} $. It has infinite gain at low frequencies, which effectively suppresses DC components of the error. For a step input, a Type I or higher system can achieve zero steady-state error.

Consider a unity feedback system with an integral term in the open-loop transfer function:
L(s) = \frac{K_p}{T_i s} \cdot G(s)
The system is at least Type I, and the steady-state error for a step input is:
e_{ss} = \lim_{s\to0} \frac{s R(s)}{1 + L(s)} = \frac{1}{1 + \lim_{s\to0} L(s)} = 0
This is provided $ \lim_{s\to0} L(s) \to \infty $, which is true due to the integrator.

To verify this, build the following Simulink model structure:

[Step] --> [Sum] --> [PID Controller] --> [Plant G(s)] --> Scope
            ↑                             ↓
            └---------[Feedback]----------

Configure the PID controller for PI mode (Td=0) with $ K_p=2, T_i=1 $ and the plant as $ G(s)=\frac{1}{s+1} $. After running the simulation, the output will perfectly track the input, and the error will approach zero.

Here is the equivalent MATLAB script:

% Define PI controller and plant
Kp = 2;
Ti = 1;
C_pi = Kp * (1 + 1/(Ti*s));  % PI controller
G = 1/(s + 1);                % First-order plant
T = feedback(C_pi*G, 1);       % Closed-loop system

% Step response analysis
figure;
step(T);
title('Step Response with PI Control (Zero Steady-State Error)');
xlabel('Time (s)');
ylabel('Output');
grid on;

% Calculate steady-state error
[y,t] = step(T, 10);
ess = 1 - y(end);  % Setpoint is 1
fprintf('Steady-state error: %.4f\n', ess);

Parameter Explanation and Analysis:

• C_pi = Kp * (1 + 1/(Ti*s)): Creates the PI controller transfer function with both proportional and integral terms.
• feedback(...): Generates the unity negative feedback closed-loop system.
• step(T): Simulates the output response to a unit step input.
• y(end): Takes the output value at the final time step to calculate the steady-state error.
• The result ess ≈ 0 confirms that the integral term successfully eliminates the static error.

3.2.2 Issues of Integral Windup and Slow Response with Too Small Ti

While beneficial, a very small $ T_i $ (meaning a very large $ K_i $) causes the integral term to grow too quickly, leading to integral windup. This is especially problematic during system startup or large setpoint changes. In these situations, the error persists for a long time, causing the integral term to accumulate to its limit. When the error changes sign, the integrator cannot decrease quickly enough, resulting in large overshoots or a delayed response.

One common solution is to implement anti-windup mechanisms, such as conditional integration or external feedback clamping.

The following table compares system behavior for different $ T_i $ values:

$ T_i $ (s)	Integral Gain $ K_i $	Rise Time	Overshoot	Integral Windup?	Response Quality
10	0.2	Slow	<5%	No	Smooth but sluggish
2	1.0	Moderate	15%	No	Acceptable
0.5	4.0	Fast	40%	Yes	Significant oscillation
0.1	20.0	Very Fast	>60%	Severe	Risk of losing control

Conclusion: $ T_i $ should not be too small. A common practice is to start with a large value and gradually decrease it during tuning.

3.2.3 Verifying the Integral Term's Compensation Ability Under Load Disturbances

To test the integral action's advantage in disturbance rejection, apply a step load disturbance during system operation. For example, add a disturbance input $ d(t)=0.5 $ at $ t=5s $.

The modified MATLAB model is as follows:

% Add disturbance channel
D = 0.5 * tf([1], [1, 1]);  % Disturbance model (low-pass)
T_dist = feedback(G, C_pi*G);  % Transfer function from disturbance to output

% Synthesize total response: reference input + disturbance response
t = 0:0.01:10;
u_ref = ones(size(t));
u_dist = zeros(size(t));
u_dist(t>=5) = 0.5;

y_ref = lsim(T, u_ref, t);
y_dist = lsim(T_dist, u_dist, t);
y_total = y_ref - y_dist;  % Note the sign

plot(t, y_total);
title('PI Controller Output Under Load Disturbance');
xlabel('Time (s)');
ylabel('Output');
grid on;

The result shows that after the disturbance occurs, the integral term gradually accumulates the negative error, raising the control output and eventually driving the system back to the setpoint, demonstrating its adaptive compensation capability.

3.3 The Derivative Time Constant Td and Its Improvement of Transient Performance

Derivative control predicts the future error by measuring its rate of change $ \dot{e}(t) $ and applies a corrective action in advance. This adds a "predictive" capability to the controller, allowing it to suppress overshoot before it happens, thereby reducing overshoot and improving response smoothness.

The ideal PD controller is:
u_{pd}(t) = K_p e(t) + K_p T_d \frac{de(t)}{dt}

However, in practice, a pure derivative term is highly sensitive to high-frequency noise, which can be amplified and cause actuator chattering. Therefore, a filtered derivative term is typically used:
u_d(s) = \frac{K_p T_d s}{1 + N T_d s}
where $ N $ is the filter coefficient (usually between 8 and 20), limiting the high-frequency gain.

3.3.1 The Advantage of the Derivative Term's Proactive Response

The essence of derivative action is to provide phase-lead compensation, which increases the system's damping. For a second-order system, appropriately adding derivative action can effectively increase the damping ratio $ \zeta $ and suppress oscillations.

Consider the system:
G(s) = \frac{1}{s^2 + 2s + 1}
The original damping ratio is $ \zeta = 1 $ (critically damped). With only proportional control $ K_p=3 $, the closed loop becomes:
T(s) = \frac{3}{s^2 + 2s + 4} \Rightarrow \zeta’ = \frac{2}{2\sqrt{4}} = 0.5
The system becomes underdamped and exhibits overshoot.

Adding a derivative term $ T_d = 0.5 $, the controller becomes:
C(s) = K_p(1 + T_d s) = 3(1 + 0.5s)
The new closed-loop system is:
T(s) = \frac{C(s)G(s)}{1 + C(s)G(s)} = \frac{3(1 + 0.5s)}{s^2 + 3.5s + 4}
\Rightarrow \zeta’’ = \frac{3.5}{2\sqrt{4}} = 0.875
The damping is now significantly closer to the ideal value.

This can be verified with MATLAB:

Kp = 3; Td = 0.5;
C_pd = Kp * (1 + Td*s);
T_closed = feedback(C_pd*G, 1);
step(T_closed);
title('PD Control Improves Transient Response');

The response curve shows that the overshoot has reduced from approximately 15% to less than 5%, and the settling time has also decreased.

3.3.2 Noise Amplification and Chattering Risks with Improper Td Settings

If $ T_d $ is too large or is used without a filter, the derivative term can react violently to sensor noise. For example, assume white noise with an amplitude of 0.01 is superimposed on the error signal:

t = 0:0.001:2;
e = sin(2*pi*t) + 0.01*randn(size(t));  % Error with noise
de = diff(e)/0.001;                     % Numerical derivative
plot(t(1:end-1), de);
title('Derivative Amplifies Noise, Causing Control Output Chattering');

The derivative can amplify noise amplitude by tens of times, severely impacting actuator lifespan.

The solution is to introduce a first-order low-pass filter, creating a "pseudo-derivative":

N = 10;
C_filtered = (Kp*Td*s) / (1 + N*Td*s);

3.3.3 Practical Techniques for Using a Filter to Suppress High-Frequency Noise

The common form of a full PID controller is:
C(s) = K_p \left( 1 + \frac{1}{T_i s} + \frac{T_d s}{1 + N T_d s} \right)

This structure balances performance and practicality. A recommended tuning sequence is: tune $ K_p $ first, then $ T_i $, and finally introduce $ T_d $ with its filter.

3.4 Multi-Parameter Coupling Effects and a Coordinated Tuning Strategy

3.4.1 Combined Response Characteristics of Kp-Ti-Td Interactions

There is a strong coupling between the three parameters. For example, increasing $ K_p $ can speed up the response, but it may require reducing $ T_d $ to prevent oscillations. Decreasing $ T_i $ strengthens the integral action, but this can increase overshoot, requiring $ T_d $ for suppression.

Sensitivity functions can help analyze parameter effects:
S(s) = \frac{1}{1 + L(s)}, \quad T(s) = \frac{L(s)}{1 + L(s)}

3.4.2 Parameter Priority Order in Typical Process Control Systems

A recommended tuning order is:

1. Set $ T_i=\infty, T_d=0 $ and use only P control to find the critical oscillation point.
2. Introduce integral action to eliminate steady-state error.
3. Add derivative action to improve the dynamic response.

3.4.3 Parameter Sensitivity Analysis and Preliminary Robustness Assessment

Define parameter sensitivity as:
S_K^T = \frac{\partial T / T}{\partial K / K}
A smaller value indicates better robustness.

Monte Carlo simulations can be used to analyze the distribution of performance metrics under parameter variations.

4. Simulink-Based PID Simulation Implementation, Debugging, and Optimization

---

In the development process of an industrial control system, theoretical analysis is only the first step. The actual performance is determined by simulation implementation and parameter tuning. Simulink provides a highly visual, modular, and scalable environment for PID controller design. This chapter explores the full process from simulation configuration and closed-loop debugging to parameter tuning and performance evaluation, focusing on key engineering practices and common problem-solving strategies.

4.1 Simulation Parameter Configuration and Solver Selection

Proper configuration of simulation parameters is fundamental to ensure simulation accuracy and computational efficiency. An inappropriate solver or time step can lead to numerical instability, simulation failure, or inaccurate results. Before starting any PID control system simulation, the Simulink simulation parameters must be systematically configured.

4.1.1 Comparison of Fixed-Step and Variable-Step Solvers

Simulink offers various numerical integration algorithms as solvers. They are mainly divided into two types: Fixed-step and Variable-step. Different solvers are suitable for different system modeling needs.

Solver Type	Typical Algorithm	Application Scenarios	Accuracy	Real-time Capability
Fixed-step	ode4 (Runge-Kutta)	Real-time simulation, embedded code generation	Moderate	High
Variable-step	ode45 (Dormand-Prince)	Offline high-precision simulation	High	Low
Fixed-step	ode1 (Euler)	Fast, rough simulation	Low	High
Variable-step	ode23t	Stiff systems (e.g., with inductive/capacitive elements)	High	Medium

Selection guidelines:

• If the goal is to generate C-code for an embedded controller, use a fixed-step solver (e.g., ode4) to ensure time discretization consistency.
• For high-precision dynamic response analysis (e.g., studying small oscillations), ode45 or ode15s (for stiff systems) is recommended.
• For non-stiff linear/near-linear systems like PID control, ode45 is the default and often the best choice.

% Configure simulation solver and parameters (via script)
set_param('pid_system_model', 'SolverType', 'Variable-step');  % Use variable-step
set_param('pid_system_model', 'SolverName', 'ode45');           % Choose ode45
set_param('pid_system_model', 'RelTol', '1e-6');               % Relative tolerance
set_param('pid_system_model', 'AbsTol', '1e-8');               % Absolute tolerance

Analysis and Parameter Explanation:

• 'SolverType': Determines whether the step size is fixed or variable, affecting stability and speed.
• 'SolverName': Specifies the integration algorithm. ode45 is a 4th/5th-order Runge-Kutta method with adaptive step size, balancing accuracy and efficiency.
• 'RelTol' and 'AbsTol': Control the upper limit of numerical integration error; smaller values mean higher accuracy but longer computation time.

mermaid flowchart: Solver Selection Decision Path

graph TD
    A[Start Solver Selection] --> B{Need embedded code generation?}
    B -- Yes --> C[Use Fixed-Step]
    B -- No --> D{Is the system stiff?}
    D -- Yes --> E[Use ode15s or ode23tb]
    D -- No --> F[Use ode45]
    C --> G[Select ode4 or ode1]
    G --> H[Set fixed step time]
    E --> I[Enable automatic step size adjustment]
    F --> I
    I --> J[Solver Configuration Complete]

4.1.2 Simulation Time Setting and Accuracy Control Options

The simulation time range directly impacts the completeness of data acquisition. For a typical step response test, observing at least 5 seconds of the transient process is usually necessary to measure rise time, settling time, and overshoot.

% Set simulation time range
set_param('pid_system_model', 'StartTime', '0');
set_param('pid_system_model', 'StopTime', '10');  % Units: seconds

Additionally, pay attention to the following parameters related to accuracy:

Parameter Name	Description	Recommended Value
MaxStepSize	Maximum step size limit	StopTime / 50 to /100
MinStepSize	Minimum step size (variable-step only)	auto or 1e-6
InitialStepSize	Initial step size guess	auto
RefineFactor	Output interpolation factor	1~10 (improves Scope resolution)

Example:

set_param('pid_system_model', 'MaxStepSize', '0.02');   % Max step size 20ms
set_param('pid_system_model', 'RefineFactor', '10');    % Improve output smoothness

Analysis and Parameter Explanation:

• A MaxStepSize that is too large can cause the simulation to miss fast dynamic details (e.g., spikes). Its recommended to set it to 1/10 of the fastest expected response time.
• RefineFactor inserts virtual points during Scope display, making curves appear smoother without affecting the calculation.
• For systems sensitive to high-frequency noise (e.g., those with derivative terms), appropriately reducing the maximum step size can suppress numerical chattering.

4.1.3 Data Storage Depth and Memory Management

When the simulation time is long or the sample rate is high, Simulink will by default save all signal data to the workspace (via the To Workspace module), which can cause memory overflow. Therefore, it is necessary to control the length of data recording.

This can be optimized using the following methods:

% Configure the To Workspace block parameters
set_param('pid_system_model/To Workspace', ...
    'LimitDataPoints', 'on', ...          % Enable data point limiting
    'MaxDataPoints', '5000', ...         % Keep a maximum of 5000 points
    'Decimation', '5');                   % Save every 5 steps

Also, turn off unnecessary signal logging in the model configuration parameters:

set_param('pid_system_model', 'SaveOutput', 'on');
set_param('pid_system_model', 'OutputSaveName', 'simout');
set_param('pid_system_model', 'LimitRows', 'on');
set_param('pid_system_model', 'MaxRows', '10000');

Analysis and Parameter Explanation:

• Decimation: A downsampling mechanism that reduces data volume without significant information loss.
• LimitDataPoints and MaxDataPoints: Prevent memory issues, especially during batch simulations or multi-parameter sweeps.
• It is recommended to enable data export only for critical signals (e.g., error, control signal, output) and avoid logging all signals.

4.2 PID Control System Operation and Debugging Process

Successful simulation is more than just "running" the model. It involves progressively verifying the functionality and stability of each component. Jumping directly into a closed-loop simulation can lead to divergence or oscillations, making it hard to locate the source of the problem. Therefore, a formal debugging process must be followed.

4.2.1 Initial Parameter Setting and Open-Loop Testing

Before closing the loop, conduct an open-loop test. This involves disconnecting the feedback path and driving the plant with the PID controller output based on the setpoint, observing the controller's behavior.

Typical steps include:

1. Replace the feedback signal with a constant zero or a constant.
2. Apply a step signal to the PID module.
3. Observe whether the PID output behaves as expected for the proportional, integral, and derivative actions.

% Example: Manually initialize PID parameters
Kp = 1.0;
Ti = 10;      % Integral time constant (seconds)
Td = 0.5;     % Derivative time constant (seconds)

% In Simulink, this can be done via a MATLAB Function block or pre-loaded workspace
assignin('base', 'Kp', Kp);
assignin('base', 'Ti', Ti);
assignin('base', 'Td', Td);

Analysis and Parameter Explanation:

• Initial $ K_p $ should not be too large (suggested 0.1-2) to prevent the integral action from accumulating too quickly.
• Use a relatively large initial $ T_i $ (e.g., above 10 seconds) to avoid integral windup.
• $ T_d $ can be set to 0 initially; only introduce derivative action after the basic loop is stable.

You can observe the output of each PID branch on a Scope:

Branch	Behavioral Characteristics
Proportional Term	Jumps immediately after the step; amplitude = Kp × error
Integral Term	Rises as a ramp; slope = Kp/Ti × current error
Derivative Term	Outputs a pulse only at the moment of the error change

If the integral term saturates quickly or the derivative term shows severe chattering, the parameters are likely incorrect, or the signal contains noise.

4.2.2 Step-by-Step Closed-Loop Construction to Ensure Stability

After the open-loop test is successful, you can proceed to build the closed-loop system step-by-step. A recommended "phased closed-loop" strategy is:

1. Enable only P control → Observe if there is any steady-state error.
2. Add I control → Eliminate static deviation.
3. Finally add D control → Suppress overshoot and oscillations.

This process can be represented by the following flowchart:

graph LR
    A[Open-Loop Test Passed] --> B[Enable P control, small Kp]
    B --> C{Is the response stable?}
    C -- No --> D[Decrease Kp and try again]
    C -- Yes --> E[Slowly increase Kp until slight oscillation]
    E --> F[Record critical Ku and Tu]
    F --> G[Enable PI control, set Ti using Z-N rules]
    G --> H{Is there integral windup?}
    H -- Yes --> I[Increase Ti or limit integral]
    H -- No --> J[Add Td and a filter]
    J --> K{Does overall performance meet the target?}
    K -- No --> L[Fine-tune parameters or use different tuning method]
    K -- Yes --> M[Debugging Complete]

This approach avoids the confusion of using all complex parameters at once and significantly increases the chances of a successful debug.

4.2.3 Real-Time Monitoring of Scope Output and Identifying Anomalous Fluctuations

During simulation, use the Scope to monitor three core signals in real time:

• Setpoint
• Process Variable (Actual Output)
• Controller Output (Control Signal)

Pay special attention to the following anomalies:

Anomaly	Possible Cause	Solution
Sustained oscillation of output	Kp too large or Td without filter	Reduce Kp, increase derivative filter coefficient N
Severe chattering of control signal	Measurement noise amplified by derivative	Add a low-pass filter or use a filtered derivative
Slow rise and no overshoot	Kp too small or Ti too large	Increase Kp, decrease Ti
Integral windup	Integral term accumulates over time	Enable anti-windup mechanism

% Enable anti-windup in Simulink (using the built-in PID block as an example)
set_param('pid_system_model/PID Controller', 'IntegralAntiWindup', 'on');
set_param('pid_system_model/PID Controller', 'SaturationPort', 'on');

Analysis and Parameter Explanation:

• IntegralAntiWindup: When enabled, the integrator stops accumulating when the controller output reaches its saturation limit.
• SaturationPort: Exposes a saturation detection signal which can be used for external logic intervention.
• This feature is particularly important for real-world systems where the actuator has physical limits (e.g., valve opening 0-100%).

4.3 Application of Parameter Tuning Methods

PID parameter tuning is the most challenging aspect of control design. Although modern intelligent optimization algorithms exist, classical empirical rules are still popular in engineering due to their intuitiveness and reliability.

4.3.1 Classic Ziegler-Nichols Ultimate Cycle Method Procedure

The Ziegler-Nichols (Z-N) ultimate cycle method is an experimental tuning method suitable for most process control systems.

Implementation steps:

1. Disable the integral and derivative actions (set Ti → ∞, Td = 0).
2. Gradually increase the proportional gain $ K_p $ until the system exhibits sustained, constant-amplitude oscillations.
3. Record the ultimate gain $ K_u $ and the oscillation period $ T_u $.
4. Calculate the recommended PID parameters using the Z-N formula:

Controller Type	$ K_p $	$ T_i $	$ T_d $
P	0.5 × $ K_u $	∞	0
PI	0.45 × $ K_u $	0.83 × $ T_u $	0
PID	0.6 × $ K_u $	0.5 × $ T_u $	0.125 × $ T_u $

% Example: Assuming simulation gives Ku = 8, Tu = 2 seconds
Ku = 8;
Tu = 2;

% Calculate PID parameters
Kp_zn = 0.6 * Ku;    % = 4.8
Ti_zn = 0.5 * Tu;    % = 1.0
Td_zn = 0.125 * Tu;  % = 0.25

% Apply to the Simulink model
set_param('pid_system_model/PID Controller', 'P', num2str(Kp_zn));
set_param('pid_system_model/PID Controller', 'Ti', num2str(Ti_zn));
set_param('pid_system_model/PID Controller', 'Td', num2str(Td_zn));

Analysis and Parameter Explanation:

• This method relies on finding the system's "limit of stability," requiring the plant to have some inherent self-stabilizing ability.
• In practice, you can judge by observing on a Scope whether the output waveform forms a stable sinusoidal oscillation.
• The Z-N method tends to produce a response with approximately a 1/4 decay ratio, which may result in a larger overshoot and requires subsequent fine-tuning.

4.3.2 Implementing the Decay Curve Method in Simulink

The decay curve method (also known as the 4:1 decay method) is gentler and suitable for applications where strong oscillations are not permissible.

Procedure:

1. Start with a small $ K_p $ and run a closed-loop test.
2. Observe the response curve. Adjust $ K_p $ until the second peak is approximately 1/4 of the first peak.
3. Record the gain $ K_{p\_s} $ used and the time $ T_s $ between the two consecutive peaks.
4. Look up a table to find the values for $ T_i $ and $ T_d $.

Controller Type	$ K_p $	$ T_i $	$ T_d $
PI	0.67 × $ K_{p\_s} $	0.47 × $ T_s $	—
PID	0.8 × $ K_{p\_s} $	0.39 × $ T_s $	0.14 × $ T_s $

% Assuming a satisfactory decay response was achieved with Kp_s = 3.0, Ts = 3.5 seconds
Kp_s = 3.0;
Ts = 3.5;

% Calculate PID parameters
Kp_decay = 0.8 * Kp_s;
Ti_decay = 0.39 * Ts;
Td_decay = 0.14 * Ts;

Advantage: Safer than the Z-N method, as it does not force the system into an ultimate state.
Disadvantage: Requires more trial and error to find the ideal 4:1 decay ratio.

4.3.3 Manual Fine-Tuning Tips Based on Trial and Error

Even with automated tools, experienced engineers often use a "trial and error + observation" approach for final optimization.

Common tuning rhyme:

"Start with P, then I, then D; make small changes and observe the response.
If overshoot is large, decrease Kp. If the tail is long, reduce Ti.
If chattering is bad, check the derivative; add a filter and choose N well."

Specific strategies:

Objective	Tuning Direction
Reduce rise time	↑ $ K_p $ or ↓ $ T_i $
Reduce overshoot	↓ $ K_p $ or ↑ $ T_d $ (with filtering)
Eliminate steady-state error	↓ $ T_i $ (strengthen integral action)
Suppress noise effects	↓ $ T_d $ or ↑ filter coefficient $ N $

It is recommended to adjust only one parameter at a time and keep a history of parameter changes for reference.

% Example batch simulation: sweeping Kp values to see response differences
kp_list = [2.0, 3.0, 4.0, 5.0];
for i = 1:length(kp_list)
    set_param('pid_system_model/PID Controller', 'P', num2str(kp_list(i)));
    sim('pid_system_model');
    eval(['output_kp_' num2str(i) ' = simout.yout;']);
end

Analysis and Parameter Explanation:

• Batch simulation can be used to plot a "Kp vs. Overshoot" curve, aiding decision-making.
• Combined with MATLAB's plotting capabilities, response comparisons can be generated:

figure;
plot(output_kp_1.getTime, output_kp_1.getValue, 'DisplayName', 'Kp=2.0');
hold on;
plot(output_kp_2.getTime, output_kp_2.getValue, 'DisplayName', 'Kp=3.0');
legend show; xlabel('Time (s)'); ylabel('Output'); title('Effect of Kp on Response');

4.4 Quantifying Performance and Defining Optimization Goals

Evaluating control performance solely by visual inspection is difficult. Therefore, quantitative performance metrics must be introduced to establish a unified evaluation standard.

4.4.1 Measuring Rise Time, Settling Time, and Overshoot

Define the key time-domain metrics:

• Rise Time $ T_r $: The time for the output to rise from 10% to 90% of the setpoint.
• Peak Time $ T_p $: The time to reach the first peak of the output.
• Overshoot $ M_p $ (%): (Peak value - Steady-state value) / Steady-state value × 100%.
• Settling Time $ T_s $: The time for the output to enter and remain within a ±2% error band around the setpoint.

% Assuming y is the output vector, t is the time vector, and SP is the setpoint
SP = 1.0;
tol = 0.02 * SP;

% Find rise time
idx_10 = find(y >= 0.1*SP, 1, 'first');
idx_90 = find(y >= 0.9*SP, 1, 'first');
Tr = t(idx_90) - t(idx_10);

% Overshoot
Mp = (max(y) - SP)/SP * 100;

% Settling time
idx_in_band = find(abs(y - SP) <= tol, 1, 'last', 'once');
Ts = t(idx_in_band);

Analysis and Parameter Explanation:

• Ensure the simulation runs for a sufficient time, otherwise the complete settling process may not be captured.
• If the system oscillates, take the time of the last entry into the error band.

4.4.2 Calculation and Comparison of Error Integral Metrics (IAE, ISE, etc.)

To comprehensively evaluate the quality of the entire response process, error integral metrics are commonly used:

Metric	Formula	Characteristics
IAE	∫|e(t)|dt	Sensitive to total error, uniform weighting
ISE	∫e²(t)dt	Focuses on large errors, good for suppressing overshoot
ITAE	∫t|e(t)|dt	Emphasizes later errors, speeds up convergence

% Example: calculating ISE
e = SP - y;  % Error sequence
dt = mean(diff(t));  % Time step
ISE = sum(e.^2) * dt;

Application Scenarios:

• ISE is suitable for control systems where minimizing energy consumption is important.
• ITAE is better for applications requiring fast elimination of residual error (e.g., temperature control).

4.4.3 Multi-Objective Decision-Making for Optimal Parameters

In practice, control objectives often conflict with each other: a fast response, small overshoot, and strong disturbance rejection are all desired. This requires a multi-objective optimization trade-off.

A practical approach is to construct a score function:

% Overall score (lower is better)
weight_rise = 0.3;
weight_overshoot = 0.4;
weight_settle = 0.3;

score = weight_rise*(Tr/Tr_ref) + ...
        weight_overshoot*(Mp/Mp_max) + ...
        weight_settle*(Ts/Ts_ref);

By iterating through the parameter space to find the minimum score, you can obtain the "globally optimal" parameter set.

Parameter Set	$ T_r $ (s)	$ M_p $ (%)	$ T_s $ (s)	Score
$ K_p=3.0, T_i=2, T_d=0.2 $	1.2	15	4.0	0.82
$ K_p=4.0, T_i=1.5, T_d=0.3 $	0.8	25	3.5	0.91
$ K_p=3.5, T_i=1.8, T_d=0.25 $	0.9	18	3.0	0.76 ✅

Finally, the parameter set with the lowest score is selected as the optimal one.

5. Complete Project Implementation: A Simulink-Based PID Control Model

---

5.1 Typical Engineering Case Study: DC Motor Speed Closed-Loop Control System

This section uses a DC motor speed control scenario to build a complete PID closed-loop control system. The system's objective is to allow the motor to quickly and stably track a set speed (e.g., 1500 rpm) under load disturbances, with an overshoot of less than 5% and a settling time of no more than 2 seconds.

First, build the system structure diagram in Simulink. The main blocks are:

• Signal Source: A Step block for the speed setpoint.
• PID Controller: The built-in PID Controller block for easy tuning.
• Plant: The DC motor transfer function model: $$ G(s) = \frac{K}{s(Js + B)} $$ Where $ K=0.05 $ (motor gain), $ J=0.01 $ (moment of inertia), and $ B=0.1 $ (damping coefficient).

The corresponding MATLAB expression is:

K = 0.05; J = 0.01; B = 0.1;
motor_tf = tf(K, [J, B, 0]); % Transfer function from voltage to speed

This transfer function can be imported into the Simulink environment using an LTI System block.

• Feedback Path: A Gain block to simulate the speed sensor gain (set to 1).
• Disturbance Injection Point: A step disturbance is added at the motor output via a Sum block to simulate a sudden load change.
• Observation Tools: A Scope to display the set speed, actual speed, and control voltage.

The final system structure can be visualized as follows (Mermaid flowchart):

graph TD
    A[Step Reference] -->|r(t)| B[PID Controller]
    B -->|u(t)| C[Motor Plant G(s)]
    C -->|y(t)| D[Scope]
    C -->|Feedback| E[Gain Sensor]
    E --> B
    F[Disturbance Step] --> C

This topology implements a standard Single-Input, Single-Output (SISO) feedback control architecture with good scalability.

5.2 Model Organization and Engineering Standardization

To improve model readability and maintainability, follow these engineering best practices:

1. Subsystem Encapsulation: Encapsulate the PID controller, the DC motor, and the disturbance module into separate subsystems, named PID_Control, DC_Motor_Plant, and Load_Disturbance.
2. Signal Labeling: Add descriptive labels to all key signal lines, such as Reference_Speed, Control_Voltage, and Actual_Speed.
3. Comments: Add text annotations inside each subsystem explaining its function and the source of its parameters.
4. Model Version Information: Insert a static text box in an empty area to note the author, date, and version number (e.g., v1.2, 2025-04-05).
5. Color Coding: Use different colors to distinguish signal types (e.g., green for setpoints, red for errors, blue for outputs).

Additionally, use Simulink's "Model Advisor" to check the model's compliance with standards like the MathWorks Automotive Advisory Board (MAB) guidelines.

5.3 Parameter Tuning and Dynamic Performance Verification

Use the Ziegler-Nichols ultimate cycle method described in Chapter 4 for initial tuning.

Procedure:

1. Disable integral and derivative action (set Ti → ∞, Td = 0).
2. Gradually increase $ K_p $ until the system exhibits sustained constant-amplitude oscillations.
3. Record the ultimate gain $ K_u = 68 $ and oscillation period $ T_u = 0.8\,\text{s} $.
4. Calculate the PID parameters using the Z-N formula:

Controller Type	$ K_p $	$ T_i $	$ T_d $
P	0.5 × $ K_u $	-	-
PI	0.45 × $ K_u $	$ T_u $ / 1.2	-
PID	0.6 × $ K_u $	0.5 × $ T_u $	0.125 × $ T_u $

This gives:

• $ K_p = 40.8 $
• $ T_i = 0.4\,\text{s} $
• $ T_d = 0.1\,\text{s} $

Set these parameters in the Simulink PID Controller block and run a simulation (simulation time 10 seconds, solver ode45, max step size 0.01 s).

Key Performance Metrics from Simulation Results (using Scope data cursors):

Metric	Value	Measurement Method
Rise Time	0.42 s	Time from 10% to 90% of target value
Peak Time	0.78 s	Time to first peak
Maximum Overshoot	4.3%	(Peak - Steady-state) / Steady-state ×100%
Settling Time (±2%)	1.86 s	Time to enter and stay within ±2% band
Steady-State Error	<0.1%	Deviation after long run
Disturbance Recovery Time	~1.2 s	Time to return to ±2% band after disturbance

These metrics meet the initial design requirements, indicating that the parameter tuning was effective.

5.4 Multi-Scenario Testing and Robustness Evaluation

To further validate the system's robustness, design several comparative experiments:

Test No.	Condition Change	Observation Focus
Test1	Nominal operating conditions	Baseline response curve
Test2	Load disturbance +20%	Recovery capability and steady-state accuracy
Test3	Motor parameter drift (J increased by 30%)	Change in dynamic response, potential instability
Test4	Reference signal changed from step to ramp	Tracking ability and steady-state error trend
Test5	High-frequency noise added (0.01 × randn)	Control signal chattering

Run the simulations in batch using a MATLAB script:

for i = 1:5
    assignin('base', 'test_case', i);  % Set test number
    sim('PID_Speed_Control_Model');   % Run simulation
    save(['result_', num2str(i), '.mat'], 'tout', 'simout');
end

The results show that the system remains robust under parameter variations and external disturbances. Only in the high-noise condition is it necessary to add a first-order low-pass filter to the derivative term (N=100) to suppress chattering.

5.5 Model Export and Preparation for Embedded Deployment

After verifying the simulation, use Simulink Coder to generate C code for an embedded controller:

1. Configure model parameters:
   • System target file: ert.tlc (Embedded Coder)
   • Language: C
   • Hardware board: Generic Real-Time Target
2. Execute the automatic code generation command:

slbuild('PID_Speed_Control_Model')

The generated code contains the core control logic function:

void PID_Controller(void)
{
    real_T e = ref - feedback;
    integral += Ki * e;
    derivative = Kd * (e - prev_error);
    output = Kp * e + integral + derivative;
    prev_error = e;
}

Simultaneously, an HTML report can be generated containing a model snapshot, signal flow diagram, and code mapping, which is useful for team collaboration and review.

It is also recommended to package the .slx model file and test data into a compressed archive (e.g., PID_Project_v1.2.zip) and manage it using a version control system like Git, keeping a history of parameter changes and performance comparisons.

5.6 Common Modeling Pitfalls and Best Practices Summary

Despite the powerful visual modeling capabilities of Simulink, several common pitfalls exist:

Pitfall	Specific Issue	Correct Approach
Inconsistent parameter units	Using rad/s but setting rpm	Convert all parameters to SI units
Ignoring sample time effects	Using continuous PID in a discrete system	Explicitly choose a discrete PID block or set the sample time $ T_s $
Unhandled integral windup	Integral term grows unbounded, saturating the actuator	Enable anti-windup mechanism (back-calculation or clamping)
Unset initial conditions	State variables default to 0, causing startup shocks	Set appropriate initial operating points
Missing output saturation	Control signal exceeds the physical device's range	Add a Saturation block after the PID
Ignoring communication delay	Control loop lacks a transport delay model	Add a Transport Delay block to simulate real-world lag
Simulation step size too large	High-frequency dynamics are distorted	Choose a step size based on system bandwidth (suggested ≤ 1/20 of the bandwidth period)
No data logging for monitoring	Scope not saving data, preventing post-analysis	Use the "To Workspace" block to record critical variables
Using outdated modules	Using old PID block lacking modern algorithm support	Upgrade to the latest Simulink version
Lack of documentation	Model has no explanation, making handover difficult	Generate a PDF report using Simulink Report Generator

By avoiding these issues and incorporating modular design, automated testing, and continuous integration concepts, the development efficiency and reliability of PID control systems can be significantly improved.