序章

在实际的器件控制中，经常会遇到这样的问题：给驱动电机设一个目标速度 v_{\mathrm{ref}}=3\mathrm{m/s}，车辆真的能稳定运行在 3\mathrm{m/s}吗？给转向电机设一个目标转角 \delta_{\mathrm{ref}}=10^\circ，前轮真的能准确保持在 10^\circ吗？

如果只是凭经验给电机一个固定的 PWM，答案通常是否定的。

电池电压会变化，电机存在内阻和反电动势，机械系统存在惯量和摩擦，车辆还会受到坡度、轮胎阻力和道路回正力矩的影响。同样的 PWM，在车辆架空、平地运行、上坡运行时，得到的车速往往完全不同；同样的转向电机输出，在静止和高速行驶时，也可能对应不同的实际转角。

因此，实际控制系统真正要解决的是：

\boxed{\text{输出与目标之间存在误差时，系统应该如何自动修正？}}

这就是 闭环控制 要解决的问题。

本文从闭环控制本身出发，进一步结合驱动电机速度环和转向电机转角环，分析一个实际控制系统是如何从物理模型出发，经过数学建模、控制器设计和稳定性分析，最终变成能够运行在 MCU 上的控制算法。

一、从开环控制说起

假设现在想控制一台电机。

最简单的做法是凭经验给电机一个控制量 u(t)，例如一定占空比的 PWM。这个控制量经过电机以及机械结构之后，最终产生输出 y(t)。

从系统的角度，可以写成：

u(t)\longrightarrow G(s)\longrightarrow y(t)

这里的 G(s) 表示被控对象，也就是电机、传动结构、轮胎以及负载等所有物理过程共同形成的系统。

对于驱动电机，可以简单理解为：

\mathrm{PWM}\longrightarrow\text{驱动电路}\longrightarrow\text{电机}\longrightarrow\text{车轮}\longrightarrow v

这种控制方式称为开环控制。

开环控制的问题是：

相同的输入，在任何情况下都会得到相同的输出。

但实际系统显然不满足这个条件。

例如在实验中测得，当 PWM 占空比为 40% 时，车辆在平整地面上能够稳定运行在 3\mathrm{m/s}。那么是否可以认为，只要以后始终输出 40% PWM，速度就永远是 3\mathrm{m/s}？

不能。

车辆进入坡道时，负载转矩增大；电池电压下降之后，相同占空比对应的平均电机电压下降；轮胎温度、地面摩擦、机械传动效率甚至车辆质量的变化，都会改变最终速度。

因此实际速度可能变成：v=2.6\mathrm{m/s}，但控制器仍然输出原来的 PWM

这就是开环系统最根本的问题：

\boxed{\text{控制器没有利用实际输出的信息}}

二、闭环控制

如果希望系统能够主动修正，就必须把实际输出重新送回控制器。

设系统目标值为 r(t)，实际输出为 y(t)。

定义误差：

\boxed{e(t)=r(t)-y(t)}

控制器不再直接凭经验输出固定控制量，而是根据当前的误差 e(t) 计算控制输入：

u(t)=C(s)e(t)

其中 C(s) 表示控制器。

于是整个控制过程变成：

r\longrightarrow e\longrightarrow C(s) \longrightarrow G(s) \longrightarrow y

与此同时，输出 y 又重新反馈到输入端，与目标 r 进行比较。以速度控制为例：
e_v(t)=v_{\mathrm{ref}}(t)-v(t)

如果实际速度小于目标速度，则：e_v>0

控制器增加电机输出。如果实际速度超过目标速度，则：e_v<0

控制器减少电机输出。也就是说，闭环系统是通过不断观察误差来修正控制量的。

这也是闭环控制最重要的思想：

\boxed{\text{不断修正错误直到获得正确的结果}}

三、闭环传递函数是怎么得到的

为了进一步分析闭环系统，需要把刚才的关系写成数学形式。

在单位负反馈系统中：E(s)=R(s)-Y(s)
控制器输出为：U(s)=C(s)E(s)
被控对象输出为：Y(s)=G(s)U(s)
把控制器关系代入：

Y(s)=G(s)C(s)E(s)

再利用：E(s)=R(s)-Y(s)

得到：

Y(s)=G(s)C(s)\left[R(s)-Y(s)\right]

整理所有包含 Y(s) 的项：

Y(s)\left[1+C(s)G(s)\right]=C(s)G(s)R(s)

因此：

\boxed{\frac{Y(s)}{R(s)}=\frac{C(s)G(s)}{1+C(s)G(s)}}

如果定义开环传递函数：L(s)=C(s)G(s)

那么闭环传递函数就是：

\boxed{T(s)=\frac{L(s)}{1+L(s)}}

这里最关键的部分是分母：1+L(s)

因为闭环系统的极点由：1+C(s)G(s)=0 决定。而闭环极点的位置直接决定系统是否稳定，以及系统响应到底是快速、缓慢还是振荡。所以后面设计 PI、PID 时，本质上就是通过控制器 C(s) 改变整个系统的闭环极点。

四、为什么反馈能够抵抗扰动

假设一辆模型小车正在稳定运行，突然进入上坡。坡度相当于给驱动系统增加了一个负载扰动 d(t)。在开环系统中，控制输入不发生变化，因此车速会下降。而在闭环系统中，速度下降会立刻造成：v<v_{\mathrm{ref}}

于是控制器提高电机输出，增加电流和驱动转矩，使车辆重新回到目标速度。从频域角度，还可以定义灵敏度函数：

S(s)=\frac{1}{1+L(s)}

其中：L(s)=C(s)G(s)，如果在我们关心的频率范围内：|L(j\omega)|\gg1，那么：|S(j\omega)|\approx\frac{1}{|L(j\omega)|}\ll1 这意味着扰动对输出的影响会被闭环反馈显著削弱。因此可以简单理解为：

\boxed{\text{闭环反馈让系统对扰动具有主动纠正能力}}

但这并不意味着增益越大越好。

如果环路增益过高，特别是在存在时间延迟和高阶动态的情况下，系统会产生越来越严重的相位滞后，最终可能从快速响应变成振荡甚至失稳。

因此闭环控制真正需要平衡的是：

\boxed{\text{响应速度}+\text{跟踪精度}+\text{抗扰能力}+\text{稳定性}}

五、PID 控制器到底在做什么

工程中最常见的闭环控制器就是 PID：

u(t)=K_p e(t)+K_i\int_0^t e(\tau),d\tau+K_d\frac{de(t)}{dt}

它分别包含比例、积分和微分三个部分。

1. 比例项 P

比例控制为：

u_P(t)=K_p e(t)

它的逻辑非常简单：误差越大，修正越强。

如果目标速度为：v_{\mathrm{ref}}=3\mathrm{m/s}，而实际速度只有：v=2\mathrm{m/s}，那么：e_v=1\mathrm{m/s}

控制器就会根据 K_p 产生相应的控制输出。

增大 K_p 通常能让系统响应更快，但如果比例增益过大，系统可能冲过目标值，再反向修正，然后再次越过目标值，最终形成振荡。

因此比例控制在决定：

看到误差以后，需要有多激进地修正？

2. 积分项 I

积分控制为：

u_I(t)=K_i\int_0^t e(\tau),d\tau

它解决的主要问题是长期存在的小误差。

假设车辆目标速度仍然是：v_{\mathrm{ref}}=3\mathrm{m/s}，由于存在坡道负载，比例控制最终使速度稳定在：v=2.9,\mathrm{m/s}，此时误差只有：e_v=0.1,\mathrm{m/s}

比例控制产生的修正量可能不足以继续克服负载，于是系统会保持一个固定的误差。

加入积分以后，只要：e_v\neq0

那么 \int e_v(t),dt 就会继续累积。即使误差非常小，只要持续时间足够长，积分项仍会不断增加控制输出，直到误差趋近于零。

因此积分项最重要的意义就是：

\boxed{\text{消除恒定参考和恒定扰动产生的稳态误差}}

3. 微分项 D

微分控制为：

u_D(t)=K_d\frac{de(t)}{dt}

它关注的是：误差正在以多快的速度变化？

假设系统正在快速接近目标值，即使当前误差仍然存在，微分项也可以根据变化趋势提前减小控制作用。因此微分项经常被理解为增加系统阻尼，有助于抑制超调和振荡。但是实际传感器的数据一定包含噪声，而求导会放大高频变化。

因此实际控制器一般不会使用理想微分：

K_d s

而更常见的是带低通滤波的形式：

C_D(s)=K_d\frac{Ns}{s+N}

这也是为什么在真实电机速度控制中，PI 往往比完整 PID 更常见。

六、实例一：驱动电机速度闭环

理解完基本闭环以后，我们考虑第一个实际系统：电机速度环。

速度控制的目标非常明确：

v(t)\rightarrow v_{\mathrm{ref}}(t)

但如果想认真设计控制器，首先必须回答一个问题：

控制电压为什么会改变电机速度？

因此需要先建立电机模型。

为了简化讨论，这里使用经典直流电机模型。对于 BLDC 或 PMSM，如果底层已经存在快速电流环，那么其速度外环也可以在一定条件下近似成类似的机械系统。

七、电机的电气模型

对于直流电机，电枢回路满足基尔霍夫电压定律：

u(t)=Ri(t)+L\frac{di(t)}{dt}+e_b(t)

其中 R 为绕组电阻，L 为绕组电感，e_b 为反电动势。反电动势与电机角速度近似成正比：e_b(t)=K_e\omega(t)

因此：

\boxed{L\frac{di}{dt}+Ri+K_e\omega u}

这个公式有一个很重要的物理意义。

当电机速度提高时：\omega\uparrow，反电动势也会增加：K_e\omega\uparrow，真正作用在电阻和电感上的有效电压就会减少。

这说明电机速度和输入电压之间并不是简单的线性比例关系。

八、电机的机械模型

电机产生的电磁转矩可以近似写成：

\tau_m=K_t i

其中 K_t 为电机转矩常数。

根据旋转系统的牛顿第二定律：

J\frac{d\omega}{dt}=\tau_mB\omega\tau_L

代入电磁转矩：

\boxed{J\frac{d\omega}{dt}+B\omega=K_t i\tau_L}

这里 J 表示折算到电机轴上的等效转动惯量，B 表示黏性阻尼，\tau_L 表示负载转矩。

到这里就可以得到：

\text{电压}\rightarrow\text{电流}\rightarrow\text{转矩}\rightarrow\text{加速度}\rightarrow\text{转速}

九、从微分方程得到速度传递函数

为了分析系统，暂时忽略负载扰动：\tau_L=0

在零初始条件下进行拉普拉斯变换。电气方程得到：(Ls+R)I(s)+K_e\Omega(s)=U(s)，机械方程得到：(Js+B)\Omega(s)=K_tI(s)，因此：I(s)=\frac{Js+B}{K_t}\Omega(s)

代回电气方程：

(Ls+R)\frac{Js+B}{K_t}\Omega(s)+K_e\Omega(s)=U(s)

整理得到：

\boxed{\frac{\Omega(s)}{U(s)}=\frac{K_t}{LJs^2+(LB+RJ)s+RB+K_tK_e}}

可以看到，在这个模型下，从输入电压到电机转速是一个二阶系统。

如果车轮半径为 r_w，传动减速比为 n_g，忽略轮胎纵向滑移，则：v=\frac{r_w}{n_g}\omega

于是车辆速度模型可以写成：

\boxed{G_v(s)=\frac{V(s)}{U(s)}\frac{\dfrac{r_wK_t}{n_g}}{LJs^2+(LB+RJ)s+RB+K_tK_e}}

至此，我们已经把一个实际的「车辆速度控制问题」转换成了标准的控制系统问题。

十、为什么速度环通常使用 PI

对于速度控制，最常见的控制器并不是完整的 PID，而是 PI：

C_v(s)=K_p+\frac{K_i}{s}

原因在于速度环最主要的任务是两件事：

第一，快速跟踪目标速度。

第二，在受到持续负载之后仍保持零静差。

比例项负责快速响应，积分项负责消除恒定扰动产生的稳态误差。

设速度对象简化为：

G(s)=\frac{b_0}{a_2s^2+a_1s+a_0}

PI 控制器为：

C(s)=\frac{K_ps+K_i}{s}

闭环系统特征方程满足：

1+C(s)G(s)=0

代入可得：

s(a_2s^2+a_1s+a_0)+b_0(K_ps+K_i)=0

整理：

\boxed{a_2s^3+a_1s^2+(a_0+b_0K_p)s+b_0K_i=0}

不难观察出，加入积分以后，原本二阶的电机对象形成了三阶闭环系统。

对于三阶多项式，根据劳斯-赫尔维茨稳定判据，在各系数为正的情况下，还需要满足：

\boxed{a_1(a_0+b_0K_p)>a_2b_0K_i}

这个条件说明了一个非常重要的问题：

\boxed{K_i\text{ 并不是越大越好}}

积分增益太小，静差消除很慢；积分增益过大，则可能明显降低系统阻尼，使系统出现振荡。

所以所谓的 PID 调参，本质上是在响应速度和稳定性之间寻找合适的闭环极点。

十一、为什么真实电机经常使用双闭环

观察机械方程：J\dot{\omega}+B\omega=K_ti-\tau_L，可以发现，真正直接决定电机转矩的是电流：\tau_m=K_ti

所以现代电机控制中，通常不会直接采用：\text{速度误差}\rightarrow\mathrm{PWM}

而是设计成：

v_{\mathrm{ref}}\rightarrow\text{速度 PI}\rightarrow i_{\mathrm{ref}}\rightarrow\text{电流 PI}\rightarrow\mathrm{PWM}\rightarrow\text{电机}

速度环根据速度误差计算「现在需要多少转矩」，而这个转矩通过目标电流 i_{\mathrm{ref}} 来表示。

电流环再负责快速让：i\rightarrow i_{\mathrm{ref}}，因为：\tau_m=K_ti

所以如果电流环足够快，那么速度环可以近似认为自己控制的是一个理想的转矩源。

这种结构最核心的设计原则就是：

\boxed{\text{内环快，外环慢}}

也就是电流环带宽明显高于速度环带宽。

十二、实例二：转向电机闭环

接下来考虑另一个非常典型的闭环：转向环。

速度环控制的是车速 v，而转向环控制的是实际车轮转角 \delta。

定义目标转角：\delta_{\mathrm{ref}}，实际转角：\delta

则转角误差为：

\boxed{e_\delta=\delta_{\mathrm{ref}}\delta}

转向控制器的任务就是让：e_\delta\rightarrow0，也就是：\delta\rightarrow\delta_{\mathrm{ref}}

看起来它和速度闭环完全一样，但真实的转向执行机构通常会更加复杂。

十三、转向系统为什么更复杂

转向电机输出之后，并不会直接得到车轮转角。

控制作用通常需要依次经过：

\text{电机}\rightarrow\text{减速器}\rightarrow\text{齿轮或齿条}\rightarrow\text{拉杆}\rightarrow\text{前轮}

机械系统中还存在摩擦、弹性和间隙。

更重要的是，车辆行驶过程中，轮胎本身会对转向机构产生回正力矩。因此即使给转向电机一个恒定的控制量，最终转角也可能随车速和路面情况而变化。把整个机构折算到车轮转角 \delta 后，可以建立一个简化机械模型：

J_\delta\ddot{\delta}+B_\delta\dot{\delta}+K_\delta\delta=K_{t,s}i_s\tau_{\mathrm{road}}

其中：

• J_\delta 表示转向机构的等效惯量；
• B_\delta 表示机械阻尼；
• K_\delta 表示等效刚度或回正特性；
• \tau_{\mathrm{road}} 表示道路和轮胎产生的扰动力矩。

转向电机自身仍然满足电气方程：

L_s\dot{i}*s+R_si_s+K*{e,s}\dot{\delta}=u_\delta

消去电流之后，可以得到转向执行机构的近似传递函数：

\boxed{G_\delta(s)=\frac{\Delta(s)}{U_\delta(s)}\frac{K_{t,s}}{L_sJ_\delta s^3+(R_sJ_\delta+L_sB_\delta)s^2+(R_sB_\delta+L_sK_\delta+K_{e,s}K_{t,s})s+R_sK_\delta}}

可以看到，在这个简化模型中，转向系统已经表现为三阶系统。

相比速度环，它包含更多动态环节，因此对控制器参数、机械共振和时间延迟通常更加敏感。

十四、转向闭环为什么也需要积分

假设目标转角是：\delta_{\mathrm{ref}}=10^\circ，车辆转向以后，轮胎持续产生回正力矩：\tau_{\mathrm{road}}\neq0，如果只采用比例控制：u_\delta=K_p e_\delta，为了让电机持续产生抵抗道路回正力矩的控制输出，就必须满足：u_\delta\neq0，而比例控制只有在：e_\delta\neq0 时才会产生非零控制量。因此车辆可能最终稳定在：\delta=9^\circ 此时虽然系统已经稳定、不再振荡，但是目标却是：10^\circ

这就是稳态误差。

加入积分以后：

u_\delta=K_pe_\delta+K_i\int e_\delta(t),dt

只要转角没有真正达到目标：e_\delta\neq0 积分器就会继续增加补偿量，直到能够产生足够大的持续转向力矩。

因此：

\boxed{\text{稳定不代表准确，稳定性与稳态误差是两个不同的问题}}

十五、转向闭环和车辆横向控制不是一个概念

在车辆系统中，经常会把「转向控制」和「路径跟踪」混在一起。实际上它们处在不同的控制层级。

底层转向伺服解决的是：\delta_{\mathrm{ref}}\rightarrow\delta 也就是说，上层要求前轮转 10^\circ，底层负责确保执行机构真的转到 10^\circ。而车辆横向控制解决的是：\text{路径误差}\rightarrow\delta_{\mathrm{ref}}

例如车辆偏离赛道中心之后，Pure Pursuit、Stanley、LQR 或 MPC 等算法根据横向误差和航向误差计算：\delta_{\mathrm{ref}} 应该是多少。

所以完整的结构实际上是：

\text{目标轨迹}\rightarrow\text{横向控制器}\rightarrow\delta_{\mathrm{ref}}\rightarrow\text{转角闭环}\rightarrow\delta\rightarrow\text{车辆}

因此，无论上层使用多么复杂的算法，如果底层转向机构无法准确执行目标转角，最终的路径跟踪性能都会受到限制。

十六、仿真应该验证什么

建立模型之后，应该先做仿真。

速度环可以首先设置一个阶跃目标，例如：

v_{\mathrm{ref}}:0\rightarrow3\mathrm{m/s}

观察车辆速度从静止到目标速度的响应。

一个基本仿真至少应该记录：

• 上升时间；
• 超调量；
• 调节时间；
• 稳态误差。

例如百分比超调量可以定义为：

M_p=\frac{y_{\max}-y_{\mathrm{ref}}}{y_{\mathrm{ref}}}\times100%

稳态误差定义为：

e_{\mathrm{ss}}=\lim_{t\rightarrow\infty}e(t)

仅仅进行阶跃响应还不够。

对于速度环，更重要的实验是在车辆已经稳定运行之后突然加入负载扰动：

\tau_L:0\rightarrow\tau_d

观察速度是否明显下降，以及控制器需要多久才能把车辆重新拉回目标速度。

对于转向环，也可以让：

\delta_{\mathrm{ref}}:0\rightarrow10^\circ

然后在某个时间加入道路回正力矩：

\tau_{\mathrm{road}}:0\rightarrow\tau_d

比较 P、PI 和 PID 控制器的响应。

通常可以观察到：P 控制具有较快的响应，但在恒定扰动下可能留下静差；加入积分以后可以消除静差，但积分过强可能增加振荡；加入适当的微分则可以改善阻尼，但会增加系统对传感器噪声的敏感程度。

仿真的意义是验证：

当前控制器的行为是否符合我们根据理论推导得到的预期。

十七、为什么仿真稳定，上车却振荡

实际控制中最常见的情况之一，就是 MATLAB 或 Python 仿真曲线非常漂亮，但控制器真正运行在 MCU 上以后却开始振荡。

原因在于前面的模型忽略了大量真实因素。

首先，实际控制器是离散执行的。

设采样周期为：T_s，那么控制算法只会在：t=kT_s 这些离散时刻执行。

积分项也会从连续形式：\int e(t),dt 变成：T_s\sum e[k]

一个简单的数字 PI 可以写成：

u[k]=K_pe[k]+K_iT_s\sum_{j=0}^{k}e[j]

如果控制频率过低，连续系统中原本稳定的参数，在离散实现后未必还具有相同的稳定裕度。

十八、PWM 饱和与积分饱和

第二个问题是执行器存在限制。

假设电机驱动器最大只能提供：

|u|\le U_{\max}

控制器计算出的理论输出却可能是：

u^\ast>U_{\max}

此时真实输出已经被限制在最大值，但积分器仍可能继续累加误差。

例如车辆上坡以后速度下降，PI 控制器不断增加输出，但 PWM 已经达到 100%。

此时继续积分并不能产生更多的电压，却会让积分状态越来越大。

等车辆重新进入平地以后，即使速度已经接近目标，积分器仍然保留着大量历史误差，使电机继续保持过大的输出，最终产生严重的超调。

这种现象称为：

\boxed{\text{积分饱和}}

因此真实的 PI/PID 控制器通常需要 Anti-Windup（抗饱和），例如积分限幅、条件积分或者反计算法。

十九、编码器不是完美的传感器

速度环需要测量速度，而实际的模型车辆通常使用编码器。

假设编码器每圈产生 N_{\mathrm{enc}} 个计数，在采样周期 T_s 内测得：\Delta N个计数，则电机角速度可以近似计算为：

\omega\approx\frac{\Delta N}{N_{\mathrm{enc}}}\frac{2\pi}{T_s}

在高速时，一次采样可能产生几十甚至几百个计数，速度计算相对平滑。

但低速时可能出现 \Delta N=0,\ 1,\ 2 这种离散且不平滑的情况。

于是测得的速度不是连续变化的，而是在若干离散值之间跳动。如果再直接对这种速度进行微分，噪声还会被进一步放大。

所以真实控制系统中的数据滤波、速度估计和采样周期，本身就是控制器设计的一部分，而不是可以完全忽略的外围问题。

二十、时间延迟为什么危险

实际控制过程通常需要经历：

\text{采样}\rightarrow\text{读取传感器}\rightarrow\text{算法计算}\rightarrow\text{PWM 更新}\rightarrow\text{驱动器}\rightarrow\text{机械响应}

这些过程都会产生延迟。

假设总延迟为 \tau_d，那么在连续模型中可以近似表示为：G_d(s)=e^{-s\tau_d}
令 s=j\omega 得到：G_d(j\omega)=e^{-j\omega\tau_d}

它的幅值始终为：

|G_d(j\omega)|=1

但会产生额外的相位：

\boxed{\angle G_d(j\omega)=-\omega\tau_d}

也就是说，频率越高，延迟引起的相位损失越严重。这就是为什么控制器不能无限追求带宽。

当系统响应被调得非常快之后，延迟和未建模的高频动态会越来越重要，最后可能把原本稳定的系统推向振荡。

二十一、真正需要关注的闭环性能

评价一个闭环系统，不能只问：

最后有没有到目标值？

如果速度最终到达 3\mathrm{m/s}，但是中间先到了 ,\mathrm{m/s}，显然不能称为优秀的控制。

一个完整的闭环系统通常至少需要关注：
上升时间 t_r 表示系统多快接近目标。

超调量 M_p 表示系统超过目标值多少。

调节时间 t_s 表示系统经过多长时间以后真正稳定在目标附近。

稳态误差 e_{\mathrm{ss}} 表示长期运行后目标和实际输出之间是否仍存在偏差。

除此之外，还应该进行扰动实验和参数摄动实验。

例如把电机惯量修改为：

J'=1.2J

或者让电池电压降低，再观察控制系统是否仍然稳定。

因为真实车辆的参数从来不会完全等于我们建模时使用的参数。

一个优秀的控制器应该是：

\boxed{\text{面对扰动、参数变化、噪声和延迟时仍然能够稳定工作}}

二十二、回到最开始的问题

现在再回到文章最开始的问题。

如果要求车辆运行在：v_{\mathrm{ref}}=3\mathrm{m/s}

我们不应该去寻找一个固定的 PWM，然后认为它永远对应 3\mathrm{m/s}。

更合理的做法是：

v_{\mathrm{ref}}\rightarrow e_v\rightarrow\text{速度控制器}\rightarrow\text{电机}\rightarrow v

当实际速度下降时，控制器自动增加输出；当实际速度升高时，控制器自动降低输出。

同样，如果要求前轮保持：\delta_{\mathrm{ref}}=10^\circ

也不应该简单地认为某个 PWM 或某个电压一定对应 10^\circ。

而应该构造：

\delta_{\mathrm{ref}}\rightarrow e_\delta\rightarrow\text{转角控制器}\rightarrow\text{转向机构}\rightarrow\delta

道路力矩变化之后，控制器根据新的误差重新调整转向电机输出。

于是速度控制和转向控制虽然面对的是完全不同的物理系统，但最终拥有相同的控制逻辑：

\boxed{\text{目标}\rightarrow\text{测量}\rightarrow\text{比较}\rightarrow\text{修正}\rightarrow\text{再次测量}}

二十三、示例与说明

前面的理论最终都需要落实到实际的控制程序中。对于 MCU 而言，闭环控制并不是连续执行的，而是在固定的控制中断周期内不断完成：

\boxed{\text{读取传感器}\rightarrow\text{计算误差}\rightarrow\text{计算控制量}\rightarrow\text{驱动执行器}}

一、PI 控制器实现

连续形式的 PI 控制器为：

u(t)=K_p e(t)+K_i\int_0^t e(\tau),d\tau

在单片机中，控制器以采样周期 T_s 周期运行，因此误差可以写成：

e[k]=r[k]-y[k]

积分项可以近似离散化为：

I[k]=I[k-1]+e[k]T_s

于是离散 PI 控制器为：

u[k]=K_p e[k]+K_i I[k]

对于车辆速度环：

e_v[k]=v_{\mathrm{ref}}[k]-v[k]

控制器根据目标速度和编码器测得的实际速度，计算下一控制周期的 PWM

#include <stdint.h>

/* =========================
 * 速度 PI 控制器
 * ========================= */

typedef struct
{
    float kp;
    float ki;

    float integral;

    float integral_max;
    float output_max;
} SpeedPI_t;


/* 限幅函数 */
static float Limit(float value, float min, float max)
{
    if (value > max)
        return max;

    if (value < min)
        return min;

    return value;
}


/* 速度 PI 初始化 */
void SpeedPI_Init(SpeedPI_t *pi,
                  float kp,
                  float ki,
                  float integral_max,
                  float output_max)
{
    pi->kp = kp;
    pi->ki = ki;

    pi->integral = 0.0f;

    pi->integral_max = integral_max;
    pi->output_max = output_max;
}


/* 速度闭环控制 */
float SpeedPI_Update(SpeedPI_t *pi,
                     float target_speed,
                     float current_speed,
                     float dt)
{
    /* 1. 计算速度误差 */
    float error = target_speed - current_speed;

    /* 2. 更新积分项 */
    pi->integral += error * dt;

    /* 3. 积分限幅，减轻 Integral Windup */
    pi->integral = Limit(
        pi->integral,
        -pi->integral_max,
         pi->integral_max
    );

    /* 4. PI 控制 */
    float output =
        pi->kp * error
        + pi->ki * pi->integral;

    /* 5. 执行器输出限幅 */
    output = Limit(
        output,
        -pi->output_max,
         pi->output_max
    );

    return output;
}

代码中的核心实际上只有：

error = target_speed - current_speed;

integral += error * dt;

output = kp * error + ki * integral;

分别对应：

e_v=v_{\mathrm{ref}}-v

I=\int e_v(t)\,dt

以及：

u=K_p e_v+K_iI

2、转向 PID 控制与实现

转向闭环同样可以按照离散控制的思想来实现。

定义转角误差：

e_\delta[k]=\delta_{\mathrm{ref}}[k]-\delta[k]

离散 PID 可以简单写成：

u[k]=K_p e[k]+K_i I[k]+K_d\frac{e[k]-e[k-1]}{T_s}

其中：

I[k]=I[k-1]+e[k]T_s

typedef struct
{
    float kp;
    float ki;
    float kd;

    float integral;
    float last_error;

    float integral_max;
    float output_max;
} SteeringPID_t;


void SteeringPID_Init(SteeringPID_t *pid,
                      float kp,
                      float ki,
                      float kd,
                      float integral_max,
                      float output_max)
{
    pid->kp = kp;
    pid->ki = ki;
    pid->kd = kd;

    pid->integral = 0.0f;
    pid->last_error = 0.0f;

    pid->integral_max = integral_max;
    pid->output_max = output_max;
}


float SteeringPID_Update(SteeringPID_t *pid,
                         float target_angle,
                         float current_angle,
                         float dt)
{
    /* 1. 转角误差 */
    float error = target_angle - current_angle;

    /* 2. 积分 */
    pid->integral += error * dt;

    pid->integral = Limit(
        pid->integral,
        -pid->integral_max,
         pid->integral_max
    );

    /* 3. 微分 */
    float derivative =
        (error - pid->last_error) / dt;

    /* 4. PID 输出 */
    float output =
        pid->kp * error
        + pid->ki * pid->integral
        + pid->kd * derivative;

    /* 5. 输出限幅 */
    output = Limit(
        output,
        -pid->output_max,
         pid->output_max
    );

    /* 保存上一周期误差 */
    pid->last_error = error;

    return output;
}

假设目标转角为：

\delta_{\mathrm{ref}}=10^\circ

当前实际转角为：

\delta=6^\circ

则：

$e_\delta=10\circ-6\circ=4^\circ$

比例项首先根据当前误差产生主要控制输出：

u_P=K_p e_\delta

随着转向机构逐渐接近目标角度：

4^\circ\rightarrow2^\circ\rightarrow1^\circ\rightarrow0

比例控制作用也不断减小。

如果轮胎回正力矩使转向系统最终停留在：

\delta=9.7^\circ

那么仍然存在：

e_\delta=0.3^\circ

积分项会继续累积：

I[k]=I[k-1]+0.3^\circ T_s

直到产生足够的持续控制量，使：

\delta\rightarrow10^\circ

微分项：

K_d\frac{e[k]-e[k-1]}{T_s}

则主要根据误差的变化速度产生阻尼作用。当转向机构快速接近目标角度时，微分项能够提前抑制过大的控制输出，从而减少超调和振荡。

3、小结

无论是速度 PI 还是转向 PID，程序的基本逻辑实际上都是：

error = target - feedback;

integral += error * dt;

output = control(error, integral, derivative);

但这几行代码对应的是完整的闭环控制理论：

\boxed{\text{目标}\rightarrow\text{误差}\rightarrow\text{控制器}\rightarrow\text{被控对象}\rightarrow\text{反馈}}

当外部负载、道路力矩或者电池电压发生变化时，系统不要求提前准确知道每一种扰动，而是利用实际输出与目标输出之间的误差持续修正控制量。

因此，PID 代码本身并不复杂。

真正决定控制性能的，是对被控对象动态特性的理解，以及控制周期、反馈测量、参数整定、饱和处理和噪声处理等因素。

二十四、结语

PID 只是实现反馈的一种方法，真正完整的控制设计应该从物理系统开始：

\text{物理建模}\rightarrow\text{数学模型}\rightarrow\text{控制器设计}\rightarrow\text{稳定性分析}\rightarrow\text{仿真}\rightarrow\text{离散实现}\rightarrow\text{实际器件验证}

如果不知道被控对象是什么，仅仅修改 K_p、K_i 和 K_d，本质上仍然是在凭经验调参。

反过来，当我们知道电压如何产生电流、电流如何产生转矩、转矩如何改变速度；知道转向电机如何经过机械结构影响前轮转角；知道扰动从哪里进入、传感器测到了什么、执行器又受到哪些限制，那么 PID 参数就不再只是三个需要「试出来」的数字。

它们是在改变一个具体系统的闭环动态。

所以我更愿意把闭环控制理解成一句非常简单的话：

对于模型车辆来说，这个思想贯穿整个控制系统。

从最底层的电流环，到速度环、转角环，再到车辆横向控制和轨迹跟踪，本质上都是在不断回答同一个问题：

现在离目标还有多远，以及下一步应该如何修正？

这就是闭环控制。