PID控制完整教程：从原理详解到Python与Simulink闭环仿真实践

做电机转速闭环、平衡小车、温控系统或者无人机姿态控制时，PID 几乎是绕不开的第一个算法。很多人在学习时会发现：公式看懂了，程序也能跑，但参数一调不对，系统要么响应太慢，要么震荡发散。更麻烦的是，网上关于 PID 的讲解很多，却大多只给公式和代码片段，看完依旧不知道如何从零搭建一个仿真环境，也不知道调参时应该按什么顺序来。

本文打算把 PID 从原理到仿真完整梳理一遍：先讲清楚比例、积分、微分三个环节到底在做什么，再给出一套基于 Python 的可运行闭环仿真代码，同时补充 Simulink 的搭建思路，最后整理调参方法和高频问题排查清单。适合刚接触自动控制的学生、入门嵌入式开发的工程师，也适合需要快速回顾 PID 要点的开发者。

1. 背景与核心概念

1.1 什么是 PID 控制

PID 是“比例（Proportional）、积分（Integral）、微分（Derivative）”三个英文单词的缩写，本质上是一种负反馈控制律。它的输入是目标值与实际值之间的误差e(t)，输出是给执行机构的控制量u(t)。

可以用一个生活中的例子来理解：你用手淋浴调节水温，水凉了就开大热水阀，水热了就关小热水阀，这是比例动作。如果水温一直比目标温度低一点，你会在一个相对稳定的开度上慢慢把热水阀再开大一点，把“欠下的热量”补回来，这是积分动作。如果发现水温正在快速上升，你会提前把热水阀往回关一点，避免冲过头，这是微分动作。

PID 控制器就是按照下面的公式把这三个动作组合起来：

u(t) = Kp * e(t) + Ki * ∫e(τ)dτ + Kd * de(t)/dt

其中：

• Kp：比例系数，作用于当前误差。
• Ki：积分系数，作用于历史误差的累积。
• Kd：微分系数，作用于误差的变化趋势。

在离散控制系统中，计算机只能按固定周期采样，因此上式会被改写成差分形式，这也是后面代码实现的基础。

1.2 PID 控制解决什么问题

先看开环控制的问题。假如要控制直流电机转速，PWM 占空比直接给一个固定值，电机转速会随着负载变化而波动，因为没有反馈，系统不知道转速是否偏离目标。再看简单的开关控制：转速低于目标就全速转，高于目标就停止，这种控制方式实现简单，但输出在最大值和最小值之间来回切换，执行机构磨损严重，系统也会有明显抖动。

PID 提供的是连续平滑的调节方式。它能根据误差的大小、积累和时间趋势动态调整控制量，兼顾响应速度、稳定性和精度。常见的应用场景包括：

• 电机调速与伺服位置控制。
• 加热器或温控箱的温度控制。
• 水箱或反应釜的液位控制。
• 四轴飞行器的姿态与高度控制。
• 移动机器人底盘速度闭环。
• 电源系统的输出电压稳定控制。

可以说，PID 是自动控制领域最基础也最通用的算法之一。即使后续学习 LQR、ADRC、模糊控制、模型预测控制等更复杂的算法，理解 PID 仍然是非常有价值的起点。

1.3 为什么需要先做仿真

很多开发者习惯直接写单片机代码，然后在真实设备上调试 PID。这种方式不是不行，但效率通常比较低：每改一次参数都要重新下载程序，如果系统发散，还可能损坏电机、加热器或驱动器。

仿真的价值主要体现在这几个方面：

• 可以在不接硬件的条件下验证算法逻辑是否正确。
• 可以自由地在被控对象模型中加入延迟、饱和、噪声和非线性环节，提前暴露问题。
• 可以批量对比多组 PID 参数，快速观察超调量、上升时间和稳态误差等指标。
• 可以把调好的参数作为真机调试的初值，减少现场盲目试凑的次数。

本文后面的实践会围绕两个仿真环境展开：一是 Python 脚本仿真，适合快速验证控制算法；二是 Simulink，适合更直观地搭模型和展示信号流向。

2. PID 控制原理拆解

2.1 比例项 P：响应当前误差

比例项是最直观的部分：

u_p = Kp * e(t)

误差越大，控制量越大；误差趋近于零时，控制量也趋近于零。比例系数Kp决定了系统对误差的反应强度。

Kp偏小时，系统响应很慢，受到扰动后需要较长时间才能回到目标值。Kp偏大时，系统响应变快，但容易产生超调，甚至持续震荡。

比例控制的缺点是很难做到无静差。以电机转速控制为例，如果负载需要一定的力矩来维持旋转，比例控制必须保留一个误差才能产生足够的 PWM 输出，这个误差就是稳态误差。

2.2 积分项 I：消除稳态误差

积分项把过去所有时刻的误差累加起来：

u_i = Ki * ∫e(τ)dτ

只要误差存在，积分项就会不断增大，推动控制量逐渐偏向能消除误差的方向。因此，积分项的主要作用是消除稳态误差。

离散化之后，积分通常写成累加的形式：

integral += error * dt u_i = ki * integral

积分项带来的问题也不少。如果误差长期存在，积分量会累积到非常大，导致控制量长时间停留在饱和区，这就是“积分饱和”。系统需要等积分量慢慢退回来才能恢复控制，表现为明显的超调或滞后。后面第七节会专门说这个问题。

2.3 微分项 D：预测误差趋势

微分项关注误差的变化率：

u_d = Kd * de(t) / dt

误差快速增大时，微分项输出一个反向作用力，相当于“踩刹车”；误差快速减小时，微分项也会反向作用，缓和输出变化。因此，微分项可以增加系统阻尼，抑制超调和震荡。

离散化方式：

derivative = (error - prev_error) / dt u_d = kd * derivative

微分项的主要风险是放大噪声。实际传感器信号总有波动，如果直接对误差求差分，小幅噪声会被放大成很大的控制量毛刺。工程上通常会对测量值低通滤波，或者采用“微分先行”的结构，也就是只对实际测量值求微分，而不是对误差求微分。

2.4 位置式 PID 与增量式 PID

根据输出形式的不同，PID 还分为位置式和增量式。

位置式 PID 直接输出完整的控制量u(k)：

u(k) = Kp * e(k) + Ki * T * sum(e(i)) + Kd * (e(k) - e(k-1)) / T

它需要保存积分累加量，适合输出绝对控制量的场景，比如阀门开度、PWM 占空比等。它的缺点是如果积分项处理不好，容易积分饱和。

增量式 PID 输出的是控制量的增量Δu(k)：

Δu(k) = Kp * (e(k)-e(k-1)) + Ki * T * e(k) + Kd * (e(k)-2*e(k-1)+e(k-2)) / T

最终输出由累加得到：

u(k) = u(k-1) + Δu(k)

增量式只需要最近三次误差，不需要保存总积分量，适合步进电机、伺服系统等需要增量输出的执行机构。它也不容易出现积分饱和问题，因为输出是在上一时刻基础上累加的。实际选型时，要根据执行机构的接收方式来判断：能接收绝对量就用位置式，能接收脉冲增量就用增量式。

3. 仿真环境准备与模型设计

3.1 仿真工具选择

本文的仿真示例主要使用以下环境：

• Python 3.x。
• numpy：用于数值计算。
• matplotlib：用于绘制响应曲线。

这些库都是常用的科学计算库，安装命令如下：

pip install numpy matplotlib

如果你更习惯 MATLAB/Simulink，也可以用 Simulink 完成同样的闭环仿真。没有商业软件许可时，可以用 GNU Octave 作为部分替代，或者直接使用 Python 脚本完成验证。版本号不需要过分纠结，重点是根据你本机环境调整。

3.2 被控对象模型设计

为了演示 PID 的调节效果，本文选择一个二阶被控对象：

G(s) = 1 / (s^2 + 1.5s + 1)

选择二阶系统的原因是：一阶系统只能体现惯性，很难直观展示超调和震荡现象；二阶系统结构简单，却能很好地表现 PID 各项参数对稳、快、准三个指标的影响。

这个传递函数对应的状态方程可以写成：

dx1/dt = x2 dx2/dt = -x1 - 1.5*x2 + u y = x1

其中x1是系统输出，x2是输出的一阶导数，u是 PID 控制器输出的控制量。在 Python 仿真中，我们用欧拉法对这个连续系统做离散化近似。

3.3 采样周期对仿真的影响

离散控制系统必须有固定的采样周期dt。采样周期过大，系统动态会被漏掉，仿真结果可能出现失真；采样周期过小，计算量增加，但精度不会无限提升。

一般建议采样周期取被控对象最小时间常数的 1/10 到 1/5。对于仿真来说，dt = 0.001（1kHz 控制频率）通常已经能比较高精度地模拟连续系统动态。实际嵌入式系统中，温控系统可能用 0.5s 甚至更长的控制周期，而电机电流环可能用 0.0001s 到 0.001s，需要根据具体对象调整。

4. Python 实现 PID 闭环仿真

4.1 实现位置式 PID 类

先写一个最基础的位置式 PID 类。它需要保存两个历史状态：积分累加量和上一次误差。

# pid_basic.py class PID: def __init__(self, kp, ki, kd, dt=0.01): self.kp = kp self.ki = ki self.kd = kd self.dt = dt self.integral = 0.0 self.prev_error = 0.0 def reset(self): self.integral = 0.0 self.prev_error = 0.0 def update(self, error): """ 输入当前误差，返回控制量 u(k)。 u(k) = Kp*e(k) + Ki*T*sum(e) + Kd*(e(k)-e(k-1))/T """ self.integral += error * self.dt derivative = (error - self.prev_error) / self.dt output = ( self.kp * error + self.ki * self.integral + self.kd * derivative ) self.prev_error = error return output

这个类本身不关心被控对象是什么，只负责根据误差计算控制量。使用时需要在循环里调用update，把返回值交给执行机构或被控对象模型。reset方法在重新开始一次仿真时比较重要，可以清空积分量和上一次误差，避免使用上一轮运行的残留状态。

4.2 完整仿真脚本

下面给出一个完整的闭环仿真脚本。被控对象用前一节的状态方程递推得到，控制量还加入了一个简单限幅，模拟执行机构饱和。

# pid_sim.py import numpy as np import matplotlib.pyplot as plt class PID: def __init__(self, kp, ki, kd, dt=0.001): self.kp = kp self.ki = ki self.kd = kd self.dt = dt self.integral = 0.0 self.prev_error = 0.0 def reset(self): self.integral = 0.0 self.prev_error = 0.0 def update(self, error): self.integral += error * self.dt derivative = (error - self.prev_error) / self.dt output = ( self.kp * error + self.ki * self.integral + self.kd * derivative ) self.prev_error = error return output def plant_step(x, u, dt): """ 被控对象: G(s) = 1 / (s^2 + 1.5s + 1) 状态方程: dx1/dt = x2 dx2/dt = -x1 - 1.5*x2 + u x1 是系统输出 y，x2 是输出的一阶导数。 """ x1, x2 = x dx1 = x2 dx2 = -x1 - 1.5 * x2 + u x1_new = x1 + dx1 * dt x2_new = x2 + dx2 * dt return (x1_new, x2_new) def run_simulation(kp, ki, kd, setpoint=1.0, dt=0.001, total_time=10.0): pid = PID(kp, ki, kd, dt) x = (0.0, 0.0) times = [] outputs = [] controls = [] current_time = 0.0 while current_time <= total_time: y = x[0] error = setpoint - y u = pid.update(error) # 控制量限幅，模拟执行机构饱和 u = max(-10.0, min(10.0, u)) x = plant_step(x, u, dt) times.append(current_time) outputs.append(y) controls.append(u) current_time += dt return times, outputs, controls if __name__ == "__main__": times, outputs, controls = run_simulation(kp=3.0, ki=1.0, kd=0.5) plt.figure(figsize=(10, 4)) plt.subplot(1, 2, 1) plt.plot(times, outputs, label="y(t)") plt.axhline(y=1.0, color="r", linestyle="--", label="setpoint") plt.xlabel("time (s)") plt.ylabel("output") plt.legend() plt.grid(True) plt.subplot(1, 2, 2) plt.plot(times, controls, label="u(t)") plt.xlabel("time (s)") plt.ylabel("control") plt.legend() plt.grid(True) plt.tight_layout() plt.show()

代码中每一步的作用都很明确：

• PID类负责控制律计算。
• plant_step负责模拟被控对象在当前控制量下的动态变化。
• run_simulation把控制器和被控对象连接起来，形成闭环。
• 主程序执行仿真并画出输出曲线和控制量曲线。

运行后可以看到，系统最终能稳定到目标值1.0，并且控制量u(t)是一个平滑变化的曲线。

4.3 对比不同参数的响应效果

PID 调参的核心是观察不同参数下系统的响应。下面这段代码可以一次性对比多组参数：

# pid_compare.py import matplotlib.pyplot as plt from pid_sim import run_simulation def compare_params(): param_sets = [ {"kp": 1.0, "ki": 0.0, "kd": 0.0, "label": "P only (Kp=1.0)"}, {"kp": 3.0, "ki": 0.0, "kd": 0.0, "label": "P only (Kp=3.0)"}, {"kp": 3.0, "ki": 1.0, "kd": 0.0, "label": "PI (Kp=3.0, Ki=1.0)"}, {"kp": 3.0, "ki": 1.0, "kd": 0.5, "label": "PID (Kp=3.0, Ki=1.0, Kd=0.5)"}, ] plt.figure(figsize=(8, 5)) for p in param_sets: t, y, _ = run_simulation(p["kp"], p["ki"], p["kd"]) plt.plot(t, y, label=p["label"]) plt.axhline(y=1.0, color="r", linestyle="--") plt.xlabel("time (s)") plt.ylabel("output") plt.title("PID Parameter Comparison") plt.legend() plt.grid(True) plt.show() if __name__ == "__main__": compare_params()

运行之后，你会看到这样几个典型现象：

• 纯比例控制时，系统可以稳定，但最终输出和目标值之间存在稳态误差。
• 增加积分项后，稳态误差逐渐被消除。
• 加入微分项后，超调量明显下降，系统更快进入稳定状态。

建议自己修改kp、ki、kd再运行几次，观察曲线变化。这是理解 PID 各项作用最快的方式。

4.4 增量式 PID 的实现

增量式 PID 是嵌入式开发中很常用的形式。下面给出一个可直接使用的 Python 类：

# incremental_pid.py class IncrementalPID: def __init__(self, kp, ki, kd, dt=0.01): self.kp = kp self.ki = ki self.kd = kd self.dt = dt self.prev_error = 0.0 self.prev_prev_error = 0.0 self.output = 0.0 def reset(self): self.prev_error = 0.0 self.prev_prev_error = 0.0 self.output = 0.0 def update(self, error): # 增量式 PID 输出的是控制量增量 delta = ( self.kp * (error - self.prev_error) + self.ki * self.dt * error + self.kd * (error - 2.0 * self.prev_error + self.prev_prev_error) / self.dt ) self.output += delta self.prev_prev_error = self.prev_error self.prev_error = error return self.output

增量式 PID 不需要积分累加项，只保留最近两次历史误差，输出以增量形式累积。它适合输出到步进电机、数字舵机和部分伺服驱动器。需要注意的是，这里的ki仍然表示连续域积分增益，离散化后积分项为Ki * T * e(k)，与位置式代码中的含义保持一致。

5. 使用 Simulink 搭建 PID 仿真模型

5.1 模块搭建步骤

如果你有 MATLAB/Simulink 环境，可以用图形化方式验证 PID 控制效果。先新建一个 Simulink 模型，然后按以下步骤搭建：

1. 从 Simulink 库浏览器中拖入以下模块：

   • Step（Sources 库）：作为目标值输入。
   • Sum（Math Operations 库）：计算目标值与反馈值的误差。
   • PID Controller（Continuous 库）：实现 PID 控制律。
   • Transfer Fcn（Continuous 库）：作为被控对象模型。
   • Scope（Sinks 库）：显示输出曲线。

2. 双击Sum，把符号设置为+-，表示“目标值减反馈值”。

3. 双击Transfer Fcn，设置分子为[1]，分母为[1 1.5 1]，对应传递函数：

G(s) = 1 / (s^2 + 1.5s + 1)

4. 用信号线连接：Step -> Sum 正输入，Sum 输出 -> PID Controller -> Transfer Fcn -> Scope。再从Transfer Fcn输出端引出反馈线，连回Sum的负输入端。

5. 保存模型，比如命名为pid_demo.slx。

如果你希望更直观地观察 P、I、D 三个通道各自对控制量的贡献，也可以不用PID Controller模块，而是分别用Gain、Integrator、Derivative三个模块并联，再通过Add模块合成输出。这种方式在教学演示中更清晰。

5.2 参数配置与运行

双击Step，设置阶跃时间和终值：

• Step time：0.1
• Final value：1

双击PID Controller，设置控制器参数：

• Proportional：3
• Integral：1
• Derivative：0.5

然后把仿真结束时间设为10，点击运行。Scope 中可以看到系统的输出响应曲线。如果需要对比不同参数，可以复制一个 PID 模型再修改参数，或者用 MATLAB 脚本批量执行：

% pid_compare.m % 需要把 PID Controller 的参数设置为工作区变量 kp、ki、kd kp_list = [1, 3, 3]; ki_list = [0, 1, 1]; kd_list = [0, 0, 0.5]; figure; hold on; for i = 1:length(kp_list) kp = kp_list(i); ki = ki_list(i); kd = kd_list(i); sim('pid_demo'); plot(tout, yout); end grid on; legend('P only Kp=1', 'PI Kp=3 Ki=1', 'PID Kp=3 Ki=1 Kd=0.5');

这个脚本要求模型中的PID Controller参数是变量名kp、ki、kd，否则每次都要手动修改。用脚本批量仿真可以非常高效地观察参数变化趋势。

5.3 从仿真到嵌入式移植的注意点

仿真中调好的参数不能直接照搬到真机。原因在于：

• 仿真模型往往忽略了执行机构延迟、死区和摩擦力。
• 真实传感器存在噪声和量化误差。
• 实际系统可能存在非线性，比如饱和、间隙、滞回。

一个可行的流程是：先在仿真中确定 PID 参数的大致范围，再用这些参数作为真机调试的初值，然后在真机上微调。真机调试时，推荐用串口把目标值、反馈值、误差和控制量实时发送到上位机，常用工具如 VOFA+ 可以直接绘制实时曲线，能大幅提高调参效率。

6. PID 调参方法与仿真验证

6.1 先 P 后 I 再 D 的试凑法

最常用的调参顺序是“先比例，后积分，再微分”。

1. 把Ki和Kd设置为 0，只保留比例控制。
2. 从小到大逐渐增大Kp，观察系统响应：响应太慢就加大Kp，出现明显震荡就减小Kp。
3. 找到一组能稳定、但存在稳态误差的Kp后，加入积分项。
4. 从小到大增大Ki，直到稳态误差被消除。Ki过大时系统会引入振荡，需要回退一点。
5. 如果系统超调量偏大，再加入微分项。
6. 从小到大增大Kd，观察振荡和超调是否被抑制。Kd过大会放大噪声，出现控制量毛刺。

这个顺序能让你在调试过程中清楚知道每一项带来了什么变化。

6.2 临界比例度法（Ziegler-Nichols 整定）

Ziegler-Nichols 是一种经典整定方法，适合有一定模型但不想推导太细的场景。基本步骤如下：

1. 关闭积分和微分，只保留比例控制。
2. 从小到大增大Kp，直到系统输出出现等幅振荡。
3. 记录此时的临界增益Ku和振荡周期Tu。
4. 按经验公式计算 PID 参数。

一种常用计算公式如下：

注意，这里的Ti是积分时间常数，Td是微分时间常数。如果代码中使用的是积分增益Ki和微分增益Kd，需要换算：

Ki = Kp / Ti Kd = Kp * Td

Ziegler-Nichols 方法给出的参数通常比较激进，实际应用中往往需要进一步微调。在仿真环境中可以先验证效果，再决定是否采用。

6.3 用仿真量化动态指标

调参时不能只靠“看曲线”，还要用数值指标评估。常用的指标包括：

• 上升时间：输出首次到达目标值附近所需时间。
• 超调量：输出最大值超出目标值的百分比。
• 调节时间：输出进入并稳定在目标值误差带内所需时间。
• 稳态误差：系统稳定后输出与目标值之间的差值。

在 Python 仿真中，可以用简单代码计算超调量：

import numpy as np times, outputs, controls = run_simulation(kp=3.0, ki=1.0, kd=0.5) setpoint = 1.0 steady_value = outputs[-1] # 最后时刻的值作为稳态参考 overshoot = (max(outputs) - setpoint) / setpoint * 100 print(f"稳态值: {steady_value:.4f}") print(f"超调量: {overshoot:.2f}%")

把动态指标打印出来，对比不同参数时会更客观，也更容易沉淀成自己的调参经验。

7. 常见问题与排查思路

7.1 高频问题排查表

7.2 系统震荡与稳态误差

如果系统持续震荡，第一反应不是继续加参数，而是先判断震荡来自哪个环节。先把Ki和Kd置零，只保留比例控制，看震荡是否消失。如果纯 P 控制已经不震荡，说明问题出在积分项或微分项上；如果纯 P 控制仍震荡，说明Kp太大了。

稳态误差的成因则相对集中：要么没有积分项，要么积分项被限幅截断。可以先增大Ki，如果Ki增到一定程度后系统开始震荡，说明这次调节已经过头，需要退回一点，并通过微分项来补偿超调。

7.3 积分饱和问题

积分饱和是 PID 工程应用中最常见的问题之一。简单来说，当系统误差长期为正时，积分量会一直累加到一个很大的值，即使误差已经反向，积分量也需要很长事件才能回落，导致系统出现大超调和慢动态。

常见处理方式有三种：

• 积分限幅：给积分累加量设置上下限，避免无限累积。
• 积分分离：误差较大时不进行积分，误差进入较小范围后再启用积分。
• 抗积分饱和：只有控制量没有进入饱和区时才允许积分累加。

下面给出一个积分限幅的示例思路：

# 在 PID 类中增加积分限幅 integral_max = 100.0 integral_min = -100.0 self.integral += error * self.dt if self.integral > integral_max: self.integral = integral_max elif self.integral < integral_min: self.integral = integral_min

具体限幅范围需要根据你的执行机构输出范围来定。

7.4 微分噪声问题

微分项对噪声非常敏感。传感器的一点点抖动，经过差分后会变成很大的控制量变化。如果你发现系统在稳定状态附近控制量仍然上下乱跳，大概率是微分项在放大噪声。

工程上常用三种策略：

1. 适当减小Kd，牺牲一些阻尼特性换取平稳输出。
2. 对测量值做低通滤波，再计算微分。
3. 采用“微分先行”结构，也就是只对反馈值y(t)求微分，而不是对误差e(t)求微分。这样可以避免设定值突变时产生微分尖峰。

8. 最佳实践与工程建议

8.1 从简单对象开始验证

学习 PID 时，不要一开始就把系统弄得太复杂。先对一个明确的二阶或一阶对象做仿真，确认控制器逻辑正确，再逐步增加扰动、噪声、饱和等环节。这样可以逐步建立直觉：哪些现象来自控制器本身，哪些现象来自被控对象特性。

8.2 输出限幅与积分限幅结合使用

实际执行机构一定有输出范围。即使仿真里模型再精确，控制量过大也无法实现。因此，在控制器输出环节必须加限幅。更重要的是，输出限幅不能只限制最终输出，还要考虑积分项是否会被“憋大”。推荐在代码中同时做输出限幅和积分限幅，避免积分项无限累加。

8.3 固定控制周期并记录数据

离散 PID 的积分和微分都依赖采样周期。如果控制周期不稳定，相当于每一项系数都在随机变化，参数自然调不稳。工程中应该尽量使用定时器产生固定控制周期，而不是依赖主循环的软件延时。

同时，建议把目标值、反馈值、误差、控制量都记录下来。真机上可以用串口日志保存，仿真中可以用列表保存。有了历史数据，才能回放问题，而不是每次靠“感觉”调参。

8.4 仿真参数不能直接搬到真机

仿真和真机之间永远有差距。仿真中调好的 PID 参数放到真机上，通常需要重新整定。真机调试时，先手工把执行机构转到安全位置，然后把最大输出限制在一个较小值，再逐步放开，避免程序异常导致设备损坏。任何涉及真实设备的调试，都应该先确认输出限幅、急停逻辑和供电安全。

9. 总结与进阶学习路线

9.1 本文学到的核心内容

通过本文，你应该已经掌握：

• PID 的数学公式和比例、积分、微分三个环节的作用。
• 位置式 PID 与增量式 PID 的区别与实现方式。
• 基于 Python 的完整闭环仿真方法。
• 使用 Simulink 搭建 PID 仿真模型的基本流程。
• 试凑法和临界比例度法的基本步骤。
• 震荡、稳态误差、积分饱和、微分噪声等常见问题的原因和排查思路。

这些内容足以支撑你完成一个简单的温度控制、电机调速或小车速度闭环仿真项目。

9.2 下一步可以学习什么

PID 只是自动控制的一种基础算法。如果你希望继续深入，可以考虑以下方向：

• 模糊 PID：让 PID 参数根据误差状态自适应调整，适合难以建立精确模型的对象。
• ADRC 自抗扰控制：把模型不确定性和外部扰动统一当作总扰动进行估计和补偿，工程实践中有很多成功案例。
• L