本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 6 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标
2. 第2篇 · 赛题进化史与押题
3. 第3篇 · 整车搭建与代码框架
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D（本篇）
7. 第7篇 · PID 进阶：串级+工程补丁
8. 第8篇 · PID 调参实战(核心)
9. 第9篇 · 进阶控制：几时该上
10. 第10篇 · K230 视觉与通信协议
11. 第11篇 · 状态机与整车软件
12. 第12篇 · 现场作战+避坑+开源

到这一篇，我们终于要碰电控里”听起来最玄、其实最值钱”的东西了——PID。

前面几篇，我们给小车装好了电机、电源（电机驱动与电源地基那篇），又装好了灰度、编码器、IMU 这些”感官”（感知那篇）。现在小车能动、也能”知道自己现在多快、偏了多少”，可它还差最后一口气：不会自己根据偏差去纠正。这一步，就是 PID 干的活。

很多人对 PID 有两种相反的误解。一种把它当高深算法，看见公式里的积分微分就头大，绕道走；另一种觉得”不就三个数嘛，乱试呗”，结果调了一下午，车还在地上画龙。这篇我们专治这两种病：先用大白话把 P、I、D 三个字母到底在干嘛讲透，建立直觉；再讲清两种最常见的写法（位置式和增量式）到底差在哪、怎么选；最后手把手带你做”人生第一次调参”——只调一个电机的速度环，从只有 P 开始，一步步加到能稳稳跟住目标速度。

先搞懂一件事：什么是”负反馈”

在拆 P、I、D 之前，得先有个总画面。PID 本质上是一套负反馈的纠错逻辑，一句话概括：

拿”你想要的目标”减去”传感器测到的实际值”，得到一个偏差；再根据这个偏差算出一个控制量去纠正，让实际值往目标靠。偏差越大纠得越狠，偏差归零就收手。

它一直在转圈：测量 → 算偏差 → 输出 → 再测量……画成图就是这样一个闭环：

给它起几个固定名字，后面一直用：

• 目标值（setpoint）：你希望它达到的值。比如”电机转速 = 100″。
• 实际值（反馈）：传感器测到的当前值。比如编码器测出来现在只有 60。
• 偏差（error）：$e = \text{目标} – \text{实际}$。上面这例子 $e = 100 – 60 = 40$。
• 控制量（output）：算出来要给执行机构的指令。对电机来说，就是 PWM 占空比。

而 P、I、D，就是从三个不同的时间视角去看同一个偏差：P 看现在、I 看过去、D 看未来。下面一个个拆。

P：看现在——偏差多大就纠多狠（管”快”）

P（Proportional，比例）是最直接的一项：当前偏差有多大，就按比例给多大的纠正力度。公式就一行：

$$u_P = K_p \cdot e$$

$K_p$ 是你要调的比例系数。偏差大、纠正猛；偏差小、纠正轻；偏差归零，这一项也归零。

P 决定了系统反应有多快、有多”硬”。这就是为什么常说 P 管”快”。

I：看过去——把欠的账一点点补上（管”准”）

I（Integral，积分）专治 P 留下的那个”差一丢丢”的尾巴。它的逻辑是：把过去每一拍的残余偏差都累加起来，攒到一定程度，逼着系统把这点欠账补上。

$$u_I = K_i \cdot \sum e$$

只要还有偏差没消掉，这个累加和 $\sum e$ 就一直在涨，对应的纠正力度也越来越大，直到偏差真正归零它才停止增长。所以 I 是专门消除稳态误差的，决定了系统最终能不能精确命中目标——这就是 I 管”准”。

D：看未来——看趋势提前刹车（管”稳”）

D（Derivative，微分）是三项里最”聪明”的一项。它不看偏差本身有多大，而看偏差正在以多快的速度变化（这一拍的偏差减上一拍的偏差）：

$$u_D = K_d \cdot (e_k – e_{k-1})$$

如果偏差正在飞快缩小，说明你正猛冲向目标，再不收手就要冲过头了——D 这时给一个反向的力，相当于提前点刹车，专门用来抑制超调、增加阻尼、让系统更稳。所以 D 管”稳”。

三个一起上：完整的 PID

把三项加起来，就是完整的 PID：

$$u(k) = K_p \cdot e(k) + K_i \cdot \sum e(i) + K_d \cdot [e(k) – e(k-1)]$$

用三个性格来记，特别好用：

两种写法：位置式 vs 增量式

上面那个公式，是位置式的写法。工程上还有一种增量式，两者长得不一样、用途也不一样，是新手最容易混的地方。务必搞清楚，否则照抄别人代码会出大问题。

位置式：直接算出”绝对的”控制量

就是上面那条完整公式，它算出来的 $u(k)$ 是一个绝对值——比如”舵机应该转到 37 度”。

$$u(k) = K_p \cdot e(k) + K_i \sum_{i} e(i) + K_d \cdot [e(k) – e(k-1)]$$

特点： – 输出直接对应执行机构的绝对位置/角度，符合”我要它在哪”这种直觉。 – 含一个全历史误差累加 $\sum e$，所以容易积分饱和，必须配积分限幅。 – 一旦某次算错、或者程序重启，因为输出是绝对值，执行机构会直接跳变到那个错误位置，有点危险。

增量式：只算”在上次基础上加减多少”

增量式算的不是绝对值，而是这一拍相对上一拍要变化多少（增量 $\Delta u$），最后累加回去：

$$\Delta u(k) = K_p[e(k)-e(k-1)] + K_i \cdot e(k) + K_d[e(k)-2e(k-1)+e(k-2)]$$

$$u(k) = u(k-1) + \Delta u(k)$$

它只跟最近 3 拍的误差有关，不显式累加全部历史。特点： – 不显式累加 $\sum e$，所以天然规避了那种”积分项无限膨胀”的经典饱和。 – 某次算错只影响一个增量，误动作影响小、更安全，也便于”手动/自动”无扰切换。 – 缺点：靠累加 $\Delta u$ 间接实现积分，可能残留一点稳态误差；而且 3 拍差分对噪声更敏感。

怎么选？

记住这个比喻就够了：

这个”速度环增量式、方向环位置式”的搭配，是几乎所有智能车队的标配。本篇先把增量式速度环跑通；方向环长啥样、两者怎么串成两级，是 PID 进阶那一篇的主题。

上代码：两种 PID 的最小实现

光看公式没感觉，看代码就清楚了。先是位置式（最容易懂的入门写法，已经带上积分限幅和输出限幅这两道保险——为什么要加、怎么加得更好，进阶篇讲，这里先照抄）：

// 位置式 PID：输出当作绝对量(如舵机角度)
float Position_PID(float target, float measure){
    static float integral = 0, last_err = 0;
    float err = target - measure;          // 偏差 = 目标 - 实际

    integral += err;                       // I：累加历史偏差
    // 积分限幅(防止积分饱和，进阶篇细讲)
    if(integral >  INT_MAX) integral =  INT_MAX;
    if(integral < -INT_MAX) integral = -INT_MAX;

    float out = Kp*err                     // P：看现在
              + Ki*integral                // I：看过去
              + Kd*(err - last_err);       // D：看未来(偏差变化)
    last_err = err;                        // 记住这次偏差，下次算 D 用

    // 输出限幅(必做!否则可能烧电机/舵机)
    if(out >  OUT_MAX) out =  OUT_MAX;
    if(out < -OUT_MAX) out = -OUT_MAX;
    return out;
}

增量式（速度环典型，直接对 PWM 做增减）：

// 增量式 PID：输出累加到 PWM 上，适合电机速度环
float Incremental_PID(float target, float measure){
    static float e0=0, e1=0, e2=0;         // 最近三拍误差：这次/上次/上上次
    static float pwm = 0;

    e0 = target - measure;
    float dU = Kp*(e0 - e1)                 // P：这拍与上拍偏差之差
             + Ki*e0                        // I：本拍偏差
             + Kd*(e0 - 2*e1 + e2);         // D：二阶差分
    pwm += dU;                              // 在上次基础上增减

    if(pwm >  PWM_MAX) pwm =  PWM_MAX;      // 输出限幅
    if(pwm < -PWM_MAX) pwm = -PWM_MAX;

    e2 = e1; e1 = e0;                       // 移位，准备下一拍
    return pwm;
}

第一次调参：把一个电机的速度环调稳

理论讲完，最爽的来了——亲手调一次。目标极其朴素：让一个电机稳稳地跟住一个目标转速。不管你设 100 还是 200，它都能快速、平稳、不抖地达到并保持。

准备工作

1. 架空轮子。把车架起来或拿一个电机单测，别让它在地上乱窜。第一次调参，安全第一，手边随时能断电。
2. 接通编码器测速（感知那一篇讲过：用定时器编码器模式，把”单位周期的脉冲数”当速度反馈）。
3. 定好控制周期。用定时器中断固定周期跑 PID，不要用 delay 凑！速度环常用 5~10ms（100~200Hz）。周期必须严格恒定，否则等效参数会乱漂。
4. 把数据发出来看。这是调参的眼睛——用 printf 同时发”目标值”和”实际值”两路，丢给 VOFA+ 或串口示波器画成曲线。看不到波形，调参就是瞎子摸象。 具体怎么”看波形治百病”，是 PID 调参实战那一篇的核心内容，这里你先把曲线显示出来就行。

调参顺序：先 P、再 I、最后 D

有句流传几十年的工程口诀，背下来准没错：

参数整定找最佳，从小到大顺序查；先是比例后积分，最后再把微分加。

为什么是这个顺序？因为 P 决定基本响应、必须先立起来；I 是在 P 的基础上去消那条残余尾巴；D 最后用来压超调和抖动。顺序乱了，三者互相干扰，你根本判断不出是谁在捣乱。

第一步：只调 P，找到”临界振荡”再退一档

把 $K_i$、$K_d$ 都设为 0，只留 P。给一个固定目标速度（比如目标 = 100）。

• 从一个很小的 $K_p$ 开始，逐步加大。
• 你会看到：$K_p$ 小的时候，实际转速慢吞吞地往目标爬，还到不了（有稳态误差）；
• $K_p$ 加大，响应变快，但开始有超调（冲过头再回来）；
• 继续加大到某个值，曲线开始等幅振荡（绕着目标值上下来回、幅度既不收敛也不发散）——这个点叫临界点，记下此时的 $K_p$；
• 然后把 $K_p$ 退回到临界值的 60%~70%（或者干脆乘 0.6）。这就是你的 P 起点。

这套”加到临界振荡再退一档”的做法，其实就是经典的临界比例度法（Ziegler-Nichols）的核心思想——它给你一个量级正确的起点，省得你从 0 瞎试。完整的 Z-N 换算表和起步估计，放到 PID 调参实战那一篇。

第二步：加 I，把稳态误差那条尾巴收掉

P 调好后，你的转速大概率还差一点点到不了目标（稳态误差）。现在从一个很小的 $K_i$ 开始往上加：

• 经验起点：$K_i$ 大约取 $K_p$ 的 1/10 ~ 1/5 起步试。
• 加 I 之后观察曲线：稳态误差应该慢慢被”顶”上去，最终精确贴到目标线上。
• $K_i$ 太小：尾巴消得太慢，半天贴不上目标。
• $K_i$ 太大：开始超调、甚至振荡——这时往回退。

第三步（可选）：加 D，压一压超调

如果加了 I 之后超调还是有点大，可以试着加一点点 D（从 0 缓慢加）来增加阻尼、压住超调。但前面说过，速度环测速噪声大，一旦看到曲线长毛刺、电机发抖，立刻停手回调。很多速度环这一步直接跳过。

调到这一步，你大概会在曲线上看到下面这几种典型现象，对照着调就行：

一组真实的电赛参数（仅供感受量级）

光说”经验起点”太抽象，给你看一组 2024 年电赛巡线小车的真实实测参数，感受一下数量级（再强调一遍：这是别人车上的个案值，不能照抄，只能当参照）：

一个调不出来时的保命心态

最后讲个真事。有位作者做摄像头跟踪云台（X/Y 双轴 PID，以画面中心为目标、小球坐标为反馈），因为系统太复杂，比赛现场参数怎么都收敛不了，最后他承认”开环也未尝不可“——退一步用开环或分段控制保底，反而把任务完成了。

几个新手必踩的坑（先记下，进阶篇细讲）

这篇是入门，下面这些坑你先有个印象就好，真正的解法在 PID 进阶和 PID 调参实战两篇里：

• static 状态变量被清零 → PID 失效。这是最低级也最高频的错。
• 极性搞反（偏差符号或电机方向反了）→ 不是负反馈而是正反馈，车越偏越猛、直接发散。上电先用很小的增益验一下极性。
• 用 delay 凑控制周期、或周期被中断打乱 → 相当于采样忽快忽慢，等效参数乱漂，怎么调都不对。一定用定时器固定周期。
• 照抄别人参数却换了周期/电机/电压 → 量级完全不对。
• 位置式忘了给积分限幅 → 积分饱和，超调到天上。
• D 直接加大 → 放大测速噪声，电机发抖。

小结

这一篇，我们把 PID 从”玄学”拉回了”直觉”：

• 它是一套负反馈纠错：目标减实际得偏差，再用三路力度去纠。
• P 看现在（管快）、I 看过去（管准）、D 看未来（管稳）——记牢是”P 快、I 准、D 稳”，别被对调的版本骗了。
• 位置式输出绝对量、适合舵机/方向环；增量式输出增量、适合电机速度环，且天然规避显式积分饱和。
• 调参顺序铁律：先 P、再 I、最后 D，参数从小到大。第一次就拿一个电机的速度环练手，把曲线发到上位机上盯着调。

你现在已经能让一个电机稳稳听话了。但一辆车要跑起来，光有速度还不够——它还得知道”往哪偏了、该怎么转”，这就要把方向环也加进来，让它和速度环串成两级协同工作；而真正让车在赛道上不翻不冲，还得靠一整套工程补丁。这些，我们下一篇 PID 进阶接着聊。

本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 7 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标
2. 第2篇 · 赛题进化史与押题
3. 第3篇 · 整车搭建与代码框架
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D
7. 第7篇 · PID 进阶：串级+工程补丁（本篇）
8. 第8篇 · PID 调参实战(核心)
9. 第9篇 · 进阶控制：几时该上
10. 第10篇 · K230 视觉与通信协议
11. 第11篇 · 状态机与整车软件
12. 第12篇 · 现场作战+避坑+开源

上一篇《PID 入门》里，我们把一个单电机的速度环从只有 P 开始，一步步调到能稳稳跟住目标速度。如果你已经跑通了那一步，恭喜——你已经摸到了控制的门。但单环只能让”一个量”听话，真正上赛道的车要同时管两件事：跑多快和往哪拐。这一篇，我们把单环升级成能上场的完整控制：先讲方向环，再讲串级双环，最后讲一套”不打就翻车”的工程补丁。

先说一句大实话：很多人调车调到崩溃，以为是 Kp/Ki/Kd 没拧到位，其实十有八九是少打了某个补丁。这些补丁往往比纠结那三个参数更决定成败。 这篇就是带你把它们一次配齐。

方向环：偏差怎么变成”左右轮速度差”

小车靠两个轮子转向。想右转，就让右轮慢一点、左轮快一点，车头自然就偏过去了——跟划船一个道理。

那”该偏多少”从哪来？来自一个偏差。这个偏差可以是： – 循迹题：摄像头看到的赛道中线偏差，或灰度/电感传感器的左右差(差比和)； – 方向保持题：陀螺仪测到的偏航角(Yaw)误差，比如”我想走直线，结果车头偏了 5 度”。

把这个偏差喂给一个 PID(方向环实际上多数只用 PD，下面会解释)，算出一个转向量 turn，再分配到左右轮：

$$\text{左轮目标} = \text{base} – \text{turn}, \qquad \text{右轮目标} = \text{base} + \text{turn}$$

base 是直行基础速度。这个加减号谁正谁负，取决于你电机和传感器的安装方向，调的时候试一下就知道。

它背后是差速车的运动学(给定线速度 $v$、角速度 $w$、轮距 $L$)：

$$v_R = v + \tfrac{1}{2} w L, \qquad v_L = v – \tfrac{1}{2} w L$$

平衡车里有个更直接的经典写法，是在 PWM 层直接把几路输出叠加，可以借鉴它的”共模/差模”思路：

// 直立项 + 速度项(共模,左右一样) ± 转向项(差模,左右相反)
Moto_Left  = Balance_Pwm + Velocity_Pwm - Turn_Pwm;   // 左轮
Moto_Right = Balance_Pwm + Velocity_Pwm + Turn_Pwm;   // 右轮

// 纯差速循迹小车去掉 Balance,在"目标速度层"做混合:
// Left_Speed_Goal  = base_speed - turn;
// Right_Speed_Goal = base_speed + turn;

方向环为什么常常只用 PD，不加 I？

方向环里那个 turn 一般用位置式 PD(位置式、增量式的区别《PID 入门》讲过了)。入弯时偏差会突然变大，这一下主要靠 D 项来响应——D 看的是”偏差变化率”，偏差一跳它最敏感，能让车提前打方向。

那 I 呢？社区里有很强的共识：方向环通常弱化甚至不加 I。原因有两个：陀螺仪有零飘、车轮会打滑，数据本身就不太准，靠 I 去”消静差”意义不大；而且 I 会引入延迟，过弯后车身”拖泥带水”半天回不到中线。

这里有个真实的坑：有人调方向环手痒加了积分，结果回正迟钝、过弯后车身拖泥带水回不到中线；去掉 I 只留 PD 后转向立刻干脆了。(来源)

调方向环之前，先验极性！

这是新手最容易栽的地方，而且一栽就是”参数怎么调都没用”。

验极性的方法极简单：给一个正的 Kp，然后用手去转车。 – 车反抗你、想转回来 → 负反馈，极性对 – 车顺着你越转越欢 → 正反馈，极性反了 ，把符号取反，或交换电机线/陀螺仪安装方向

调 P 和 D 的口诀和单环一样：从 D=0、只加 P 开始，P 加到走直线/循迹基本能跟线、但弯道略冲；再加 D 抑制过冲和振荡。P 太大直道会画龙(蛇形摆)，D 太大对噪声敏感会高频抖舵。 一套能照抄的完整方向环调参步骤，留到《PID 调参实战》一篇细讲。

串级双环：老板与员工

单环 PID 自稳性还凑合，但一遇到负载变化——上坡、打滑、电池掉压——跟随就会滞后甚至失稳。串级(双反馈)PID 是控制赛道的标准答案，它的核心思想一句话：

具体到小车： – 外环(方向/位置/角度)：负责”对不对得准、到没到位”。它的输出不直接驱动电机，而是作为内环的目标值。 – 内环(速度/角速度)：负责让实际转速快速精确跟上外环给的目标，输出才真正变成 PWM。

偏差大时，外环给一个大目标速度让车快速逼近；快到了，外环把目标速度收小，避免冲过头。

为什么这样就更抗造？举个上坡的例子：上坡瞬间电机实际转速被拖下来，内环立刻发现”我没跟上目标”，马上加大 PWM 顶上去(粗调、快)，外环再慢慢保证最终到位(细调)。所以串级在变负载、高速时明显比单环稳，提速时不甩尾。(来源)

分工：速度内环用增量式 PI，方向外环用位置式 PD

多数车队的搭配是： – 速度内环 → 增量式 PI：输出是增量累加，电机不容易在正反转之间突跳，天然好处理饱和，只需输出限幅。 – 方向外环 → 位置式 PD：偏差直观、响应快，不加(或只加极小)I。

速度内环的标准写法(左轮为例，偏差 = 目标 − 编码器)：

void Left_Speed_Control(void)
{
    float erro = Speed_Goal - Left_Encoder;            // 偏差 = 目标 - 编码器读数
    // 增量式: Δu = P*(e-e1) + I*e + D*(e-2*e1+e2)
    Left_Speed_PID.OUT += ( Left_Speed_PID.P * (erro - Left_Speed_Lasterro)
                          + Left_Speed_PID.I *  erro
                          + Left_Speed_PID.D * (erro - 2*Left_Speed_Lasterro + Left_Speed_Preverro) );
    Left_Speed_OUT = Range_protect((int)Left_Speed_PID.OUT, -9000, 9000); // 输出限幅
    Left_Speed_Preverro = Left_Speed_Lasterro;
    Left_Speed_Lasterro = erro;
}

内环要比外环跑得快得多

这是串级的命门：内环周期必须远小于外环周期。

经验上，内环周期取外环的 1/3 到 1/10(等价于内环带宽是外环的 3~10 倍)。这是跨多个来源一致的核心规律——量级上把握住就行，不必死抠精确数字。代码实现很简单，用一个计数器分频：内环每次中断都算，外环每隔 N 次才算一次。

// 在同一个定时器中断(周期 T)里:
current_loop();                       // 最内环:每次都算
if (outer_ring_timer % 2 == 0)        // 速度环:每 2T 算一次
    speed_loop();
if (outer_ring_timer % 3 == 0)        // 位置/方向外环:每 3T 算一次
    position_loop();
outer_ring_timer++;

野火的有刷电机三环例程就是这么干的：电流内环每 T、速度环每 2T、位置环每 3T。平衡车的经典分层大致是直立/角度环最快(约 5~10ms)、速度外环为它的若干倍周期。

调参铁律：先调内环，后调外环

正确流程： 1. 先屏蔽外环(把外环运算注释掉，或给内环一个固定目标速度)。 2. 单独调内环：让车架空或直线低速跑，给一个突变的目标速度，看编码器波形——调到能快速、平滑、几乎不超调地跟上，受扰后不振荡。 3. 内环稳了，对外环来说它就近似成了一个”稳定快速的等效环节”。这时再像调普通 PID 那样调外环：先加 P，再加 D。

工程补丁八件套：不打就翻车

终于到了这一篇真正的”硬核私货”。下面这八个补丁，每一个都对应一类”调参怎么都调不好”的诡异现象。把它们配齐，你的车才算从”实验室能跑”进化到”赛场能扛”。

补丁 1：积分限幅 + 补丁 7：输出限幅

这俩是一对，一起讲。输出限幅是把最终 PWM 夹到 [-Max, Max]；积分限幅是单独给积分累加项设上下界。

顺序也是固定的：先有输出限幅，anti-windup 才有”是否饱和”可判断。 国一开源 Enterprise_E 里就是电机环积分限幅 i_Max=1000、转向环 i_Max=400，和输出限幅各自独立。

补丁 2：积分分离

专治起步/大阶跃时的猛烈超调。思路：误差大时关掉积分(只用 PD 快速逼近)，误差进入小范围才投入积分消静差。

可以做成三段式平滑过渡：

if (pid->errABS > 50)         kiIndex = 0.000f;   // 大误差:关积分,纯 PD 冲
else if (pid->errABS > 30)    kiIndex = 0.600f;   // 中误差:半投
else                          kiIndex = 1.000f;   // 小误差:全投,消静差
pid->outPut = pid->outPutP + pid->outPutI * kiIndex + pid->outPutD;

实战反馈：智能车里积分分离比变速积分更直接好用、更干脆。(来源)

补丁 3：抗积分饱和(anti-windup)

这是积分类问题的总根源。积分饱和(windup)是指：误差长期同号 → 积分越累越大 → 输出顶到饱和 → 等误差反向时，积分要很久才泄完 → 造成大滞后、大超调。

有两大流派。

流派 A：遇限削弱(条件积分 / clamping)——输出已饱和时，只允许”会让积分往回退”的累加：

if (ABS(pid->outPutLast) > outPutLimit) {
    // 仅当积分会被"反向"削弱时才累加(误差与积分异号才累加)
    if ((pid->errSum > 0 && pid->errNow < 0)
     || (pid->errSum < 0 && pid->errNow > 0)) {
        pid->errSum += pid->errNow;
    }
    // 同号(会让积分更饱和) → 本次不累加
} else {
    pid->errSum += pid->errNow;   // 未饱和,正常累加
}

流派 B：反计算(back-calculation)——饱和时把”饱和差”按一定速率反喂给积分器，主动把它拉回来。离散实现很干脆：

# 先算未饱和输出 op
if op[i] > op_hi:        # 触上限
    op[i] = op_hi
    ie[i] = ie[i] - e[i] * delta_t    # 抵消本次积分增量
if op[i] < op_lo:        # 触下限
    op[i] = op_lo
    ie[i] = ie[i] - e[i] * delta_t

反计算有个跟踪时间常数 $T_t$，经验取 $T_t = \sqrt{T_i \cdot T_d}$，且满足 $T_d < T_t < T_i$；$T_t$ 越小，积分泄得越快。

补丁 4：微分先行 / 对测量值微分

专治”设定值突变”。如果微分项是对误差做差分，那么设定值一阶跃(比如目标速度从 0 突然变 100)，误差瞬间巨变，微分项会蹦出一个巨大的尖峰冲击执行器——这就是 derivative kick(微分踢)。

解法：微分项改用 $-(PV_k – PV_{k-1})$，作用在测量值上而非误差上：

// 微分项用 -(PV变化) 代替 (误差变化),二阶形式同时抑制噪声
u_k = u_k_1
    + KP*(e_k - e_k_1)
    + KI*e_k*dt
    - KD*(PV_k - 2*PV_k_1 + PV_k_2)/dt;

补丁 5：微分低通滤波(不完全微分)

专治”加大 D 就抖/啸叫”。纯微分会把编码器、陀螺仪、ADC 的高频噪声放大成抖动甚至尖啸。

做法是给微分项串一个一阶低通：

thisError = setpoint - processValue;
integral += thisError;
// 关键: (1-α)*新微分 + α*上次微分
thisDev = Kd*(1.0f - alpha)*(thisError - lasterror) + alpha*lastdev;
result  = Kp*thisError + Ki*integral + thisDev;
lasterror = thisError;
lastdev   = thisDev;

系数 $\alpha \in (0,1)$：$\alpha=0$ 无滤波、$\alpha=1$ 等于没微分。等价于工业界的微分滤波系数 $N$(典型 8~20，越小滤得越狠)。

补丁 6：电机死区补偿

专治”低速/小误差时车原地哒哒抖，或干脆趴窝不动”。静摩擦加上 H 桥死区，会让占空比低于某个阈值(常见 5%~10%，或绝对值如 < 65/1000)时电机根本不转——这时控制增益在死区内突然变 0，系统就极限环抖动或卡死。

补偿就是输出非零时，叠加一个符号相关的偏置把死区”跨过去”：

if (out > 0)      out += DEAD_ZONE;   // 正向跨死区
else if (out < 0) out -= DEAD_ZONE;   // 反向跨死区
// out == 0 时保持 0,避免零点附近来回跳

补丁 8：电池电压补偿

这是”实验室调好、上场翻车”的隐形元凶。同一个占空比下，电机力矩正比于母线电压；电池从满电掉到欠压，等效 Kp 就悄悄变小了，高速时车会变软、摆头甚至失控。

补偿公式简单，但要 ADC 实测电池电压：

// V_NOMINAL 为标称/调参时电压, v_batt 由 ADC 实测
pwm_out = pid_out * (V_NOMINAL / v_batt);

一个真实战例：高速行驶时车突然失控摆头，排查半天发现是电池电量下降导致同占空比下力矩变小、等效 Kp 变软。加上电压补偿后，从满电到亏电表现终于一致了。(来源)

一张表，把八件套对号入座

别忘了陀螺仪零飘

方向环如果用陀螺仪 Yaw 做反馈，零飘是绕不开的。一个真实战例：2024 电赛 H 题某队原计划用编码器 PID 调速，却发现两个轮子性能不一致、达到恒速的时间都不一样，被逼着改用陀螺仪 Yaw 检测偏航角控直行；结果省赛前夜先误烧了十轴模块，又发现 MPU6050 的 Yaw 在漂，最后比赛前 6 小时才把应急模块移植成功。(来源)

另外，左右电机/编码器往往天生不一致，最好左右各用一套速度 PID 参数分别整定，或在差速混合里加补偿，别指望一套参数包打天下。

收个尾：补丁配齐，参数才有意义

把这一篇捋一遍，你应该建立起这样一条心智：

想看这套东西在真实比赛代码里长什么样，强烈推荐通读第十六届智能车国一开源 ittuann/Enterprise_E：它的 pid.c 把误差限幅、积分限幅、积分分离、专家 PID、前馈补偿全配齐了，注释也到位，是工程补丁落地的最佳样板；配套博客更是把抗饱和、积分分离、不完全微分讲透了。串级落地代码可以参考 STM32 的 xxpcb/stm32-motor-pid、TI MSPM0 赛道(对口 2024 H 题)的 Szturin/M0G3507-TI-CAR，原理教程则首推野火有刷电机多环控制。

到这里，方向环、串级、补丁你都备齐了，但参数到底怎么从 0 一步步拧出来、波形该看哪些症状下哪些药——那才是真正的硬功夫。具体调参流程，我们留到下一篇 PID 调参实战，用一套能照抄的步骤和一张”波形症状→该调哪个参数”的诊断表，带你把这些参数一个个调到位。

本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 8 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标
2. 第2篇 · 赛题进化史与押题
3. 第3篇 · 整车搭建与代码框架
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D
7. 第7篇 · PID 进阶：串级+工程补丁
8. 第8篇 · PID 调参实战(核心)（本篇）
9. 第9篇 · 进阶控制：几时该上
10. 第10篇 · K230 视觉与通信协议
11. 第11篇 · 状态机与整车软件
12. 第12篇 · 现场作战+避坑+开源

到这里，前面几篇我们已经把单环、串级、还有那一堆”不做就翻车”的工程补丁都讲过了。但你大概率会有个困惑：道理我都懂，可参数到底怎么调出来？P 设多少？I 加到哪算够？车在地上画龙的时候，我该动哪个数？

这一篇就是来解决”动手”这件事的。它是整个系列里最该被你打印出来贴在调试桌上的一篇——一套从简单到难、可以照抄的调参流程，外加一张”看波形治百病”的诊断表。调参这事说穿了不玄学，它有固定套路，也有趁手工具。我们一步步来。

先把心态摆正：调参是”有顺序地试出来”，不是”算出来”

很多新手一上来就想找一组”标准参数”抄进去，结果发现别人的 Kp=500 抄到自己车上直接飞出去。

那调参靠什么？靠一套固定的顺序，配上眼睛看波形。这就像考驾照练科目二：不是背一个”方向盘打几圈”的万能数字，而是练出”看到库角到哪个位置就开始回方向”的手感。手感从哪来？从一遍遍试、一遍遍看结果来。我们要做的，就是把”试”这件事变得有章法、不瞎试。

整套流程可以浓缩成一句口诀：先内环后外环，先 P 后 I 后 D，参数从小往大加。 下面拆开讲。

调参总流程：四步走，照着做

第 0 步：先验机械和极性，别让控制环背锅

这一步最容易被跳过，但跳过它你后面会调到怀疑人生。

很多”PID 怎么调都不对”的情况，根子根本不在参数上，而在机械和反馈信号本身就是错的：编码器联轴器松了导致测速跳变、电机没固定牢一加速就晃、舵机中值没标定导致你以为在走直线其实车在跑偏。还有一种很坑的情况——低速时一切正常，一提速或者一换地面，机械松动才暴露出来。所以宁可一开始就把它排查干净。

还有一个必做动作：确认反馈极性。方法很土但极其有效——用手去转车（或拨动轮子），如果你给的是正 Kp，车应该”反抗”你这个动作（这才是负反馈）；如果车顺着你的手越转越欢，说明极性反了，那就是正反馈，再怎么调参数车都会原地打转或直接失控。极性反了，把符号取反，或者把电机两根线对调即可。

舵机车还要先标定中值、左右极限并限幅（脉宽夹在安全范围内）。标准 RC 舵机周期 20ms（50Hz），脉宽常用范围约 0.5~2.5ms，1.5ms 附近是中位。机械没装好、舵机没标好，PID 再准也救不回来。

第 1 步：先单独调好速度内环

串级系统里，永远先调内环。原因很直白：外环（方向/位置）看到的”被控对象”其实是”内环 + 电机”这个整体。如果内环本身就晃晃悠悠不稳定，你在它外面套外环，调出来的参数换个工况就废了。

具体怎么调（速度环一般用增量式 PID）：

1. 把车架空或低速直线跑，给一个固定的目标速度。
2. 先给一个很小的 I，让车能慢慢爬到目标速度（增量式里乘当前误差 $e$ 的那个系数承担”积分”角色，它负责消除稳态转速误差）。
3. 再缓慢加 P，让响应变快——目标速度一变，实际速度要快速跟上去。
4. P 一直加到编码器波形开始出现小幅高频抖动，就回退一点点。
5. D 一般很小或者干脆不加（编码器测速本身就有噪声，D 会把它放大成抖动）。

增量式速度环只需要做输出限幅（不像位置式还得专门做积分限幅），因为它本身不显式累加积分，天然抗积分饱和、误动作影响小——算错一次只是微微抖一下，而不是猛地一窜。

第 2 步：再调方向 / 位置外环

内环稳了，外环此时看到的就是一个”快速、稳定”的等效环节，可以像调普通单环 PID 那样慢慢来。

方向环一般用位置式 PD（多数情况不加 I）：

1. 从 D=0、只加 P 开始。P 慢慢加大到车能基本跟住线 / 跟住目标方向，但过弯时略冲、直道有点画龙。
2. 再加 D，压住过冲和直道的蛇形抖动。

关于方向环要不要加 I，这里要说句更准确的话：

第 3 步：提速，然后到赛场复调

低速时系统更宽容、容易看清振荡，所以前面都是先慢速调通。调稳之后再逐步把基础速度提上去。

实战里就有人这么干：某 2024 电赛 H 题循迹分享里，直线用 Kp=500 / Kd=0，弯道单独用 Kp=900 / Kd=200，两套动态参数切换跑（来源）。

从临界振荡起步：试凑法标准步骤

上面是”流程顺序”，那每一个环具体怎么把 P 加上去？这里有个经典的标准动作。

试凑法（先 P 后 I 后 D）：

1. 把 I、D 都去掉（只留 P）。
2. 把 Kp 从小往大加，一直加到系统出现等幅振荡（不收敛也不发散，匀速来回晃）。
3. 把 Kp 减小到振荡刚好消失，再取这个值的 60%~70%（或者干脆乘 0.6）作为最终 P。
4. 需要消静差就加 I：积分时间 Ti 先设一个大初值，逐步往小减，减到出现振荡，再回头把它加大到 150%~180%。
5. 需要压超调就加 D：Td 一般取 0，或者取不振荡时的约 30%。

想要个起步估计：Ziegler-Nichols 临界比例度法

试凑法靠手感，如果你想要一个能”算出起点”的方法，可以用经典的 Ziegler-Nichols（临界比例度法）。

做法：把 I、D 去掉，逐渐加大 Kp 到系统首次出现等幅振荡，记下此时的临界增益 $K_u$ 和临界振荡周期 $T_u$，然后查表。

标准版（最常用，会产生约 25% 超调、四分之一衰减）：

$$K_p = 0.6 K_u, \quad T_i = 0.5 T_u, \quad T_d = 0.125 T_u$$

换算成常见的并联形式就是 $K_i = 1.2 K_u / T_u$、$K_d = 0.075 K_u T_u$。

野火文档里给的查表版本（数值上和标准版接近）：

重头戏：看波形治百病

如果说前面是”流程”，那这一节是这一篇的灵魂。你能不能调好 PID，很大程度取决于你能不能把车的状态”看见”。 盲调和看着波形调，效率差一个数量级。

工具：VOFA+ 串口示波器

最主流、免费的工具是 VOFA+。思路非常简单：在控制环里用 printf 同时发出”目标值”和”实际值”两路数据，VOFA+ 把字节流翻译成实时曲线画出来。你一眼就能看到实际值是怎么去追目标值的——是慢慢爬上去、还是冲过头来回荡、还是死活差一截。需要的话还能多发几路（比如 PID 的分项、PWM 输出）一起看。

VOFA+ 有三种数据协议，按你的通道数和频率选：

诊断表：波形长什么样 → 该动哪个参数

这是最可操作的产出，建议直接背下来：

一句口诀帮你记住分工：P 主管响应、I 消除静差、D 抑制振荡。

理想的响应曲线长什么样？老一辈工控人有个判据叫”两个波，前高后低四比一“——也就是超调后回落，相邻两个波峰幅值约 4:1 衰减比，既反应快又稳得住。

下面这张图把整个看波形的判断逻辑串起来：

在线调参：别每改一个数就重新烧录

调参是个反复试的活。如果每改一次参数都要重新编译、烧录、复位、再跑，一天调不了几轮。高名次队伍的共同点之一，就是把”改参数”这件事做成在线的。三种手段：

1. 板载按键 + OLED（现场最稳，比赛桌上首选）

把 P/I/D 存成数组，用按键选择当前要改哪个参数、加减键步进调整，OLED 实时显示。不用连电脑、不用重新下载、抗 PC 干扰。整定满意后把参数写进 Flash 掉电保存。

2. 蓝牙 / 2.4G 无线透传（跑动中调参）

平衡车、高速车这种”必须跑起来才能看出参数好坏”的场景，用 HC-05 蓝牙（或 NRF24L01 这类 2.4G）做无线串口透传。在 VOFA+ 或手机上发命令帧改参数，车继续跑，同时把波形实时回传回来。

下位机解析命令帧的通用做法：定好帧头帧尾，用 DMA + 串口空闲（IDLE）中断收变长包，收到后用 strstr 定位关键字、atof 把字符串转成 float。

3. MATLAB 系统辨识（算个起点）

进阶玩法：开环给电机一个恒定 PWM，记录转速响应，拟合出传递函数，再用 PID Tuner 算出一组起步参数。拟合率（fit）大于 80% 基本就能用。注意 PID Tuner 算出的连续 I 项要乘以采样周期才是离散位置式的 Ki。这套适合给速度环找起点，但最终还是得回到车上微调。

一个能照抄的 PID 实现（含输出限幅）

理论说够了，给一份电赛 H 题国奖工程里用过的通用 PID 实现——同一个结构体支持位置式和增量式两种模式，并且带上必做的输出限幅（来源）：

// 通用 PID：一个结构体两种模式（来自 2024 电赛 H 题开源工程）
void PID_Calculate(PID_Struct *pid){
    pid->error[0] = pid->target - pid->now;   // 当前偏差
    if(pid->mode == DELTA_PID){               // 增量式（电机速度环常用）
        pid->pout = pid->p * (pid->error[0] - pid->error[1]);
        pid->iout = pid->i *  pid->error[0];
        pid->dout = pid->d * (pid->error[0] - 2*pid->error[1] + pid->error[2]);
        pid->out += pid->pout + pid->iout + pid->dout;   // 注意是累加增量
    } else if(pid->mode == POSITION_PID){     // 位置式（方向/角度环常用）
        pid->pout = pid->p *  pid->error[0];
        pid->iout = pid->i *  pid->error[0];
        pid->dout = pid->d * (pid->error[0] - pid->error[1]);
        pid->out  = pid->pout + pid->iout + pid->dout;    // 直接赋值
    }
    pid->error[2] = pid->error[1];            // 历史偏差移位
    pid->error[1] = pid->error[0];
}

// 输出限幅：位置式/增量式都必须做，否则容易烧电机或舵机
void PID_OutPutLimit(PID_Struct *pid, float duty){
    if(pid->out >=  duty) pid->out =  duty;
    if(pid->out <= -duty) pid->out = -duty;
}

循迹车把方向环输出叠加到左右轮基础速度上，实现差速转向：

// 七路灰度加权求中线偏差，target=0（车正好压在中线）
track_pid.now    = weighted_sum / sum;
track_pid.target = 0;
PID_Calculate(&track_pid);
PID_OutPutLimit(&track_pid, 800);          // 方向环输出限幅 ±800
Motor_LeftCtrl (basespeed - track_pid.out); // 左轮 = 基础速度 - 转向量
Motor_RightCtrl(basespeed + track_pid.out); // 右轮 = 基础速度 + 转向量

差速运动学的本质就是这两行：左右轮一个减一个加，差出来的速度差就是转向。对应公式 $v_L = v – \frac{\omega L}{2}$、$v_R = v + \frac{\omega L}{2}$（$v$ 线速度、$\omega$ 角速度、$L$ 轮距）。左右到底是加还是减，取决于你的电机安装方向，跑一下不对就互换。

各场景 PID 经验起点数值表

再强调一遍：下面全是起点量级，不是答案，必须现场重调。 给它们是为了让你不至于从零开始瞎蒙，知道”大概在哪个数量级”。

关于控制周期和 PWM 频率，初学者最容易混成一件事，这里务必分清：

关于 PWM 频率到底取多少，有个常被网上资料说错的点：

串级调参顺序与现场快速整定

把前面的拼起来，串级双环的完整调参顺序是：

• ☐ 第 0 步：验机械、验编码器、验极性，舵机标中值限幅，开环标定好中值/死区。
• ☐ 第 1 步：屏蔽外环，单独调速度内环（增量式）。给固定目标速度，调到”目标一变实际能快速平滑跟上、受扰不振荡”。
• ☐ 第 2 步：套上方向/位置外环（位置式 PD）。先加 P 到能跟线，再加 D 压超调，方向环一般不加或只加极小 I。
• ☐ 第 3 步：逐步提速，弯道单独降速；准备 2~3 套参数现场切换。
• ☐ 现场：到赛道真实材质/光照下重标阈值、复调参数，留 20% 余量，在比赛电量水平下复测。

几个反复要人命的坑，最后再钉一遍

调参这一关过了，你的车就有了”稳和准”的底子。但你可能还会问：前馈、模糊 PID、卡尔曼这些听起来很高级的东西，到底要不要上、什么时候上才不算本末倒置？这正是进阶控制算法那一篇要替你算的那笔性价比账。

本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 9 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标
2. 第2篇 · 赛题进化史与押题
3. 第3篇 · 整车搭建与代码框架
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D
7. 第7篇 · PID 进阶：串级+工程补丁
8. 第8篇 · PID 调参实战(核心)
9. 第9篇 · 进阶控制：几时该上（本篇）
10. 第10篇 · K230 视觉与通信协议
11. 第11篇 · 状态机与整车软件
12. 第12篇 · 现场作战+避坑+开源

到了这一篇，你手里应该已经有一辆能跑的车了：电机听话转、编码器能测速、串级 PID 调好以后能稳稳跟线、过弯也不冲出去。这时候很多同学会开始心痒——网上铺天盖地的”模糊 PID””卡尔曼滤波””前馈控制””自抗扰 ADRC”，名字一个比一个唬人，是不是把这些都堆上去，车就能从”能跑”变成”封神”？

先把话撂在这儿：90% 的省赛小车，把基础 PID 加串级双环调扎实，就足够拿奖了。 这一篇要讲的进阶算法，定位是”锦上添花 + 报告亮点”，不是”不上就完蛋”的必需品。本篇的真正价值，不是教你把每个算法都写一遍，而是帮你判断：哪个算法解决什么问题、什么时候才值得上、性价比到底高不高——免得你把宝贵的四天三夜耗在调一个收益微薄的高级算法上，最后基础反而没跑稳。

先认清这条”逐级升级”的路线

进阶算法不是平行摆在货架上让你随便挑的，它们有明显的”性价比梯度”：越往后，调试成本越高、边际收益越小。一个稳妥的升级顺序长这样：

为什么是这个顺序？因为越靠左的，改动小、收益直接、不容易引入新 bug；越靠右的（尤其模糊 PID、卡尔曼），自由度多、调试耗时，稍有不慎反而把好不容易调稳的车搞乱。省赛时间紧，跑不稳就果断回退到上一级。 下面我们一个一个拆。

变速积分 / 积分分离：性价比最高，优先上

这是进阶项里性价比最高的一个：简单、收益直接，建议第一个上。

普通 PID 的积分系数是恒定的，全程积分增量都一样。但实际需求是矛盾的——误差大的时候，积分项疯狂累加，等误差快归零时这股劲儿泄不掉，造成严重超调；误差小的时候又需要积分稳稳消掉静差。

最直接的办法是三段式积分分离：

但阶跃式分段在临界点会有突变。更平滑的是变速积分，用一个线性过渡系数：

if (pid->errABS > lErr) {            // 误差大: 不积分
    kiIndex = 0.000f;
} else if (pid->errABS < sErr) {     // 误差小: 全额积分
    kiIndex = 1.000f;
} else {                             // 中间: 线性过渡
    kiIndex = (lErr - pid->errABS) / (lErr - sErr);
}
pid->outPut = pid->outPutP + pid->outPutI * kiIndex + pid->outPutD;

经验取值 lErr ≈ 50、sErr ≈ 30。

怎么选？ 匀速车选变速积分（积分主导稳态精度，平滑过渡最好）；有明显加减速的车，更该重视下面这个”遇限削弱积分”。

Bang-Bang + PID：电机弱的车靠它”榨提速”

思路：大误差全力冲，小误差精细停

Bang-Bang（起停 / 砰砰控制）让输出在两个极端之间切换——要么全速，要么全刹。控制理论里有个结论：当哈密顿量对控制量是线性的时候，Bang-Bang 就是最短时间最优解。说人话就是：想在最短时间内从 A 跑到 B，”地板油加速 + 急刹”往往就是最快的。

但纯 Bang-Bang 在目标附近会疯狂抖动，所以智能车里用的是组合拳——用 Bang-Bang 控力度、用 PID 控精度：

if (e >  eps)       u = Umax;       // 大正偏差: 全速
else if (e < -eps)  u = -Umax;      // 大负偏差: 全刹/反向
else                u = PID(e);     // 阈值内: 切 PID 精调
// eps(阈值)务必带迟滞, 避免阈值附近来回抖动(chattering)

它的坑：抖动（chattering）

Bang-Bang 最大的毛病是切换不连续。如果阈值 $\varepsilon$ 不带迟滞，误差在阈值附近来回时，输出就在两个极值之间高频跳变——既伤电机，又让车发抖。

解决办法是给阈值加一个迟滞带（施密特触发器的思路）：进入用一个阈值、退出用另一个略小的阈值，中间留一段缓冲。

前馈控制：从”亡羊补牢”到”未雨绸缪”

它到底解决什么问题

PID 是典型的反馈控制——它盯着”已经发生的偏差”去纠正。问题是，等偏差出现了你才动作，永远慢半拍。高速过弯的时候，等你看到车已经偏出赛道（误差变大）才猛打方向，往往已经来不及了。

前馈（feedforward）反过来：它不等误差出现，而是根据已知的扰动或模型提前补偿。

它的威力在于：在扰动影响输出之前就预补偿，响应能快很多，动态误差明显减小，能耗和磨损也更低。但它有三个硬性前提：

• 必须有一个比较准的被控对象模型（前馈控制器本质上就是被控对象模型的”倒数”）；
• 扰动必须可测 / 可预知——对没料到的扰动它无能为力；
• 每个系统的前馈控制器都不一样，是专用的，换车、换赛道就得重算。

所以前馈不能单用，铁律是和 PID 复合：

$$U(k) = U_{pid}(k) + U_{ff}(k)$$

智能车里前馈的两个典型落地

第一个：曲率前馈打舵。 侧向控制量 = 前馈 + 反馈。前馈那一份由参考路径的曲率和车辆动力学模型直接算出来（舵机转角公式里含轮距 $L$、曲率 $\rho$、不足转向梯度）。曲率怎么求？一个实用做法是用赛道上连续三个点：曲率等于这三点外接圆半径的倒数，而拐向用三点的叉乘面积判——右拐为负、左拐为正。高速时舵机响应慢，在输出里提前加入这个”路径趋势分量”，舵机就能预先打舵，而不是等偏差累积。

第二个：速度突变前馈 PWM。 速度环里，当目标速度突然变化（比如起步、出弯加速）时，光靠 PID 慢慢追会有明显滞后。这时候直接前馈一段 PWM，电机响应立刻跟上。一个常见的离散前馈实现，是对设定值做一阶 + 二阶差分加权：

前馈输出: result = α*(rin - lastRin) + β*(rin - 2*lastRin + prevRin)
         其中 α = A/(B*T), β = 1/(B*T^2)   (A、B 为对象模型参数, T 为采样周期)
复合控制: U(k) = Upid(k) + Uff(k)   // 位置式或增量式 PID 都行

第一项是”速度前馈”（设定值变化的快慢），第二项是”加速度前馈”（设定值变化的变化）。$\alpha$、$\beta$ 由你的电机模型参数和采样周期决定，没有万能值，得自己标。

死区补偿：一个不起眼但特别实用的小补丁

这个严格说属于《PID 进阶》里的”工程补丁”，但太常用、又特别容易被漏掉，这里单独点一下。

直流电机有个”死区电压”：大约是额定的 10%~15%（比如一个 12V 电机，低于约 1.5~2V 根本不转）。PID 算出来的小 PWM 如果落在死区里，电机纹丝不动——结果就是低速爬行、静差死活消不掉、起步迟滞。

解决办法很简单，输出非零时叠加一个死区偏置，把电机直接推出静摩擦区：

// 输出不为零时, 补一个死区偏置, 把电机踹出死区
if (pwm_out > 0)      pwm_out += PWM_DEADZONE;
else if (pwm_out < 0) pwm_out -= PWM_DEADZONE;

模糊 PID：报告里的”高级感”，赛场上的”性价比陷阱”

它解决”一套参数不够用”

普通 PID 全程就一套 Kp/Ki/Kd。但智能车是个时变、非线性的系统——高速时需要一套参数，低速时需要另一套，直道和急弯的需求完全不同。一套死参数顾此失彼。

模糊 PID 的做法是：输入当前偏差 $e$ 和偏差变化率 $ec$，经过模糊化（量化因子 $K_e = N/e_{max}$ 把 $e$ 映射到论域）→ 查一张 7×7 的模糊规则表（模糊子集 NB/NM/NS/ZO/PS/PM/PB）→ 模糊推理 → 解模糊（缩放因子 $K_u = u_{max}/N$）→ 在线输出 $\Delta K_p / \Delta K_i / \Delta K_d$，实时微调 PID 三个参数。

残酷的现实：省赛性价比偏低

模糊 PID 听起来很美，但它的调试自由度多得吓人——规则表、隶属度函数、量化因子、缩放因子，每一个都要调。

所以建议很明确：车先用普通 / 串级 PID 跑稳，确实有余力了再上模糊 PID，并且一定要在报告里给出对比曲线——”加了模糊 PID 之后，过弯误差从 X 降到 Y”，这种带数据的论证，比光堆一个”我们用了模糊 PID”的名词强一百倍。想找现成起点的话，FlameAlpha/fuzzy-pid（纯 C 实现）和 the-fenrir/Fuzzy-PID（直接面向 STM32 电机控制）都可以拿来改。

卡尔曼 vs 互补滤波：姿态融合该选哪个

这一节主要是给做直立车 / 平衡车的同学——姿态解算是直立车的命根子。四轮循迹车其实多数时候用陀螺 Z 轴 + 简单滤波锁航向就够了。

为什么要融合

MPU6050 这类 6 轴 IMU 有两个传感器，各有各的毛病：

• 加速度计算出的 Pitch/Roll 是绝对的（长期不漂），但噪声大、一晃就乱跳；
• 陀螺仪积分出的角度平滑（短期准），但会随时间漂移。

一阶互补滤波的公式和代码，《感知：灰度/电磁/编码器/IMU》一篇已经给过（$angle = a\cdot(angle + gyro\cdot dt) + (1-a)\cdot acc$，$a$ 取 0.98）。这里不重复推导，只把”两条路线怎么选”讲清楚。

互补滤波：简单、够用，省赛首选

互补滤波就一行核心公式，优点是计算量小、易于嵌入式实现，平衡车直立环完全够用。它的两个系数 $a$ 与 $1-a$ 之和必须等于 1，$a$ 的物理含义是 $a = \tau/(\tau+dt)$，$\tau$ 越大越信陀螺仪、跟随越慢。

它的局限是对陀螺仪零漂的抑制有限、初始收敛慢。

卡尔曼滤波：精度更高，但要交”学费”

卡尔曼把陀螺仪角速度（当先验/预测）和加速度计倾角（当观测）做最优融合，还能在线估计陀螺零偏，精度比互补滤波更高。代价是：计算量大、要懂点统计、还得调那两个噪声参数 $Q$ 和 $R$。

$Q$/$R$ 这两个参数的方向特别容易记反，这里给准确说法：

• $Q$（过程噪声）：越小越信模型/预测，越大越信测量。
• $R$（测量噪声）：越大响应越慢、越信预测；越小收敛越快，但过小会震荡。

调法：$R$ 的初值可以这样估——让陀螺仪静止采一段数据（近似正态分布），按 $3\sigma$ 原则取 $(3\sigma)^2$ 作 $R$ 初值；然后 $Q$ 由小到大、$R$ 由大到小慢慢试。平衡车常用的一套经典参数（TKJ 版）是 Q_angle=0.001, Q_bias=0.003, R_measure=0.03, dt=0.005~0.01。

结论：省赛优先互补，精度敏感再上卡尔曼

如果你做的是多轴/全姿态（不只直立环单轴），还有两条比手写卡尔曼更省心的路：带零偏在线估计的二阶互补滤波（专治一阶互补”零漂抑制有限”的毛病），以及无人机/AHRS 圈广泛用的 Madgwick/Mahony 四元数互补滤波（计算量介于一阶互补和卡尔曼之间）。想直接抄卡尔曼的，Mattral/Kalman-Filter-mpu6050 是即拿即用的姿态卡尔曼实现。

一张表：到底什么时候该上什么

把上面这些拢成一张决策表，照着对号入座就行：

几条压箱底的忠告

进阶算法这块，翻车的往往不是”算法没学会”，而是”用错了地方”。最后几条，记牢：

• 别本末倒置。 机械中值没找准、编码器测速不稳、PWM 频率/控制周期没固定，就急着堆模糊 PID/卡尔曼——地基不稳，高级算法只会放大问题、引入更多 bug。
• 控制周期必须固定且已知。 Ki、Kd、互补滤波的 $a$、卡尔曼的 $Q$/$R$，全都隐含依赖采样周期 $T$。一定要用硬件定时器中断跑控制环来保证周期恒定，把打印、无线发送这些放低优先级或降频。有队伍踩过坑：调 PID 时发现效果不只受 PID 数值影响，还明显受无线发数间隔、编码器测速间隔的影响——控制周期不稳是隐形杀手。
• 逐级加、留对比数据。 先用基础/串级 PID 跑稳跑完整圈，再按”变速积分 → Bang-Bang → 前馈 → 模糊 PID”逐级加，每加一个都留一份对比曲线。这既是科学的工程方法，也是答辩时最有说服力的素材。
• 报告别只堆名词。 论文/答辩里只写”我们用了模糊 PID/卡尔曼”却不讲”为什么需要 + 对比数据”，反而显得为用而用。把一个算法讲透 + 给曲线，远比罗列一堆名词加分。

讲到这里，电控的”控制”部分基本拼齐了。但小车要真正变聪明——看得懂赛道、认得出数字和色块、和主控对得上话——还差一双”眼睛”。下一篇我们就来聊 K230 视觉模块怎么用、怎么设计一套稳的通信协议，把视觉结论稳稳喂给主控。

本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 10 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标
2. 第2篇 · 赛题进化史与押题
3. 第3篇 · 整车搭建与代码框架
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D
7. 第7篇 · PID 进阶：串级+工程补丁
8. 第8篇 · PID 调参实战(核心)
9. 第9篇 · 进阶控制：几时该上
10. 第10篇 · K230 视觉与通信协议（本篇）
11. 第11篇 · 状态机与整车软件
12. 第12篇 · 现场作战+避坑+开源

前面九篇，我们把”小车自己能跑稳、跑准”这件事讲透了：电机、电源、各种传感器，PID 从入门到串级再到调参实战。但你有没有发现，到现在为止小车的”眼睛”其实很弱——灰度传感器只能看脚下那条线，编码器只知道轮子转了几圈，IMU 只管自己歪没歪。要让小车看懂”前面有个二维码””那边是个 2 号路牌””这条线往左拐了 30 度”，就得请出真正的视觉模块。

这一篇聊两件事：一是 K230 这类视觉模块到底能干什么、怎么用；二是它怎么跟主控”对上话”——也就是通信协议。这两件事其实是一件事：视觉负责”看”，主控负责”动”，中间靠一根串口线把”看到的结论”传过去。把这条链路打通，你的小车才真正有了眼睛。

先把整条链路画出来，心里有个全局：

一、先想清楚：视觉模块在整车里是什么角色

新手最容易犯的一个错，是把视觉模块当”主脑”，想让它又看图、又算决策、又控电机。结果发现 K230 上用 Python 跑控制环又慢又难调，主控那边还拿不到干净数据，两头别扭。

正确的分工是这样的：

打个比方：视觉模块就像副驾上的导航员。副驾不会把整块挡风玻璃的画面塞给开车的你，他只会喊一句”左偏 10 度””前方是 2 号路牌”。你（主控）拿到这一句话就够打方向了。

所以视觉端只回传几个数——比如 line_error（线偏了多少）、line_angle（线斜了多少度）、flag（看到没看到）、id（二维码/路牌的编号）——绝不把整张图像通过串口发过来。

这种”把看的活和算的活分开”的设计，好处是两个人可以各写各的：视觉同学专心调他的巡线和识别，电控同学专心调 PID，只要事先把”传哪几个数、什么格式”约定死，最后联调时插上线就能跑。

二、K230/CanMV 能干什么

K230 是嘉楠（Kendryte）出的一颗带 6 TOPS NPU（神经网络算力）的视觉芯片，常见开发板有庐山派、01Studio CanMV 等。它跑的固件叫 CanMV，写法是 MicroPython，API 跟大家熟悉的 OpenMV 几乎同源——所以网上 OpenMV 的巡线、色块例程，K230 上稍改就能用。

对电赛小车来说，常用的有这么几样活：

巡线的两条路线

巡线是小车赛最高频的视觉任务，K230 上有两条主流做法，都只把”一个偏差 + 一个角度”发给主控。

路线一：灰度加权质心法。 把画面横向切成几条 ROI（感兴趣区域），近处权重大、远处权重小，每条 ROI 里用 find_blobs 找黑线最大的色块，加权平均出线的中心位置，再算出偏角。官方例程里近/中/远的权重是 0.7 / 0.3 / 0.1——理解一下：脚下的线最该听（权重大），远处的线只是”预判方向”（权重小），这其实就是我们在感知篇讲过的”前瞻”。

路线二：线性回归 get_regression。 直接对整幅二值图做一次直线拟合，返回一个 line 对象，里面有 theta()（角度）、rho()（到原点的距离，反映横向偏移），还有一个很有用的 magnitude()。

二维码、AprilTag、OCR——直接出”结论”

这三样的共同点是：K230 直接帮你把结果算成字符串或编号，你只要把那几个字节塞进串口发出去。

• 二维码 find_qrcodes()：返回对象的 .payload() 就是二维码里的内容字符串。
• AprilTag（一种黑白方块机器码，专为机器识别设计）find_apriltags()：返回 .id()、中心坐标 .cx()/.cy()、旋转角。默认用 TAG36H11 这一族（6×6 方块，误识率低）；还有 TAG16H5（4×4，看得更远但更容易认错）。
• OCR / 数字识别：用官方的 OCR kmodel，能识别中英文和数字；纯手写数字也可以走 MNIST 模型分类。

分辨率怎么选

一句口诀：巡线用小图保帧率，识别用大图保精度。

巡线是几何任务、要的是控制环快（帧率就是控制频率的上限），所以常用 160×120（QQVGA）甚至更小的灰度图；二维码官方例程用 640×480 灰度；OCR/AI 识别最吃算力，但 K230 有 NPU 撑着，可以慢一点换清晰。K230 还支持多通道，甚至能一路给屏幕显示、一路给算法跑。

三、视觉端代码：把巡线结果发出去

下面给一段可以直接改的灰度加权质心巡线代码（K230 / MicroPython），算出偏差和角度后调 send_line 发给主控。发送函数 send_line/send_frame 的帧格式我们在第五节细讲，这里先把”算结论”的逻辑看清楚。

import math

GRAYSCALE_THRESHOLD = [(0, 64)]              # 黑线的灰度阈值(现场要重标!)
ROIS = [ (0, 100, 160, 20, 0.7),            # 近(权重大)
         (0,  50, 160, 20, 0.3),            # 中
         (0,   0, 160, 20, 0.1) ]           # 远
weight_sum = sum(r[4] for r in ROIS)
IMG_W, IMG_H = 160, 120

while True:
    img = sensor.snapshot()
    centroid_sum, found = 0, 0
    for r in ROIS:
        blobs = img.find_blobs(GRAYSCALE_THRESHOLD, roi=r[0:4], merge=True)
        if blobs:
            b = max(blobs, key=lambda x: x.pixels())   # 取最大的黑块
            centroid_sum += b.cx() * r[4]; found += 1
    if found:
        center_pos = centroid_sum / weight_sum
        line_error = center_pos - IMG_W/2              # 居中=0,正负代表左右偏
        angle = math.degrees(-math.atan((center_pos - IMG_W/2) / (IMG_H/2)))
        send_line(line_error, angle)                   # 发给主控
    else:
        send_frame(0x00, b'')                          # 一条线都没找到 -> 告诉主控

如果走线性回归路线，核心就这几行：

img = sensor.snapshot().binary([(0, 64)])     # 先二值化
line = img.get_regression([(255, 255)], robust=True)
if line and line.magnitude() > 8:             # 阈值自调,过滤不可信的拟合
    rho_err = abs(line.rho()) - img.width()/2          # 横向偏移
    theta = line.theta()
    theta_err = theta - 180 if theta > 90 else theta   # 角度,>90度要修正
    send_frame(0x01, struct.pack('<hh', int(rho_err), int(theta_err * 10)))
else:
    send_frame(0x00, b'')                              # 没拟合到可信的线

注意那行 theta - 180 if theta > 90：get_regression 返回的角度有时会跳到 90 度以上，需要减 180 折回来，否则角度会突变、车会猛打一下方向。这是 OpenMV 官方巡线工程 的标准处理。

如果你用线性回归 + 主控双 PID 的方案，OpenMV 官方的经验 值得记住：横向偏移 rho 配一个 PID（经验 p ≈ 0.4），角度 theta 配另一个 PID（经验 p ≈ 0.001）。注意这俩 p 值差了两个数量级，必须分开调——不少人想用一个 PID 硬扛，结果怎么都不稳。具体怎么把这两路偏差喂进方向环、怎么整定，方向环和串级的细节见《PID 进阶：方向环、串级双环与工程补丁》一篇。

四、通信三选一：为什么是 UART

视觉端算好了结论，怎么送到主控？常见有三条总线：UART、SPI、I2C。对”只回传几个数”这个场景，结论很干脆——UART 几乎是唯一正确答案。

打个比方理解三者的取舍：

• UART 像乡间双车道：两根线（TX/RX）加地线，点对点，够用又省事。
• SPI 像高速公路：多车道全双工、速率最高（>10 Mbps），适合传图/大带宽，但要修匝道（每个从机一根 CS）、走线多、长线容易出错。
• I2C 像公交线：一条总线上挂一串站点，省 GPIO，但速度慢、要排班寻址（地址管理 + 上拉电阻），抗噪和距离最差。

给小车回传几个数，走”乡间双车道”最划算。详细对比：

接线：3.3V 直连，别加多余的转换板

K230 所有 IO 都是 3.3V，STM32F4 的 IO 也是 3.3V，所以 TX 接对方 RX 交叉接、共地，就能直连，不需要电平转换芯片。波特率约定 115200、8 位数据、无校验、1 位停止（也就是常说的 8N1）即可。

K230 用串口前还有一步软件上的坑：必须先用 FPIOA 做引脚复用，纯软件 UART() 初始化是不够的。另外 K230 一共 5 个串口，UART0（小核 SH）和 UART3（大核 SH）常被系统占用，别选；用户可用 UART1/2/4，主推 UART2（GPIO11 = TX，GPIO12 = RX，对应庐山派的 GH1.25 接口①）。

from machine import UART, FPIOA

# 关键:必须先做引脚复用,否则口不通!
fpioa = FPIOA()
fpioa.set_function(11, FPIOA.UART2_TXD)
fpioa.set_function(12, FPIOA.UART2_RXD)
uart = UART(UART.UART2, baudrate=115200, bits=UART.EIGHTBITS,
            parity=UART.PARITY_NONE, stop=UART.STOPBITS_ONE)

引脚、API、电平这些硬事实，以 立创庐山派 K230 wiki 为准最权威。

五、帧协议：给数据装个”快递包裹”

确定了用 UART，下一个问题是：数据在线上是一串字节流，主控怎么知道”一帧从哪开始、到哪结束、有没有传错”？这就需要设计帧协议。

打个比方，一帧数据就像一个寄出去的快递包裹：

一个经过实战检验、可以直接用的格式：

帧头 0xAA 0x55 | 类型 1B | 长度 1B | 数据 N字节 | 校验 1B | 帧尾 0x0D 0x0A

几个设计点说一下：

• 帧头用双字节 0xAA 0x55，而不是单字节。因为在二进制数据流里，单个 0xAA 太容易被数据区里恰好相同的字节”撞上”导致错帧；双字节 + 长度 + 校验三重确认，误同步概率就压到可以忽略。顺便一提，0x55 = 01010101 在线上是个 50% 占空比的方波，最容易用示波器对齐，所以常被选作帧头。
• 长度字段让你能收变长数据（1 字节最大 255，扣掉校验后净载荷还有 200 多字节，对小车绰绰有余）。
• 校验可以用最轻量的累加和，也可以用更强的 CRC-8 / CRC-16。新手先用累加和就够。
• 帧尾 0x0D 0x0A（也就是 \r\n）的好处是：用串口助手或日志直接打印时能自动换行，调试时一眼能看清每一帧。

视觉端发送代码

import struct

FRAME_HEAD = b'\xAA\x55'
FRAME_TAIL = b'\x0D\x0A'

# type: 0x01=巡线  0x02=二维码  0x03=AprilTag  0x04=数字  0x00=无目标
def send_frame(msg_type, payload: bytes):
    length = len(payload)
    body = bytes([msg_type, length]) + payload    # 类型 + 长度 + 数据
    checksum = 0
    for b in body:
        checksum = (checksum + b) & 0xFF           # 累加和(可换成 CRC)
    uart.write(FRAME_HEAD + body + bytes([checksum]) + FRAME_TAIL)

# 巡线 -> 回传 line_error 和 line_angle(放大10倍发,保留0.1度精度)
def send_line(line_error, line_angle_deg):
    payload = struct.pack('<hh', int(line_error), int(line_angle_deg * 10))
    send_frame(0x01, payload)

# 二维码/AprilTag/数字 -> 只回一个 id
def send_id(msg_type, id_val):
    send_frame(msg_type, bytes([id_val & 0xFF]))

六、主控收包：DMA + 串口空闲中断的黄金组合

主控这边怎么收？新手常见的错法是：在串口中断里一个字节一个字节地收，还顺手把解析、甚至 PID 都塞进中断里。这样中断被占用太久，控制环都会被拖卡。

正确姿势是 DMA + 串口 IDLE（空闲）中断：

这套组合的好处是：零 CPU 占用 + 硬件自动断帧（天然支持变长收包）。现代 HAL 库写起来很省心，一个回调搞定：

#define RX_BUF_SIZE 64
static uint8_t rx_buf[RX_BUF_SIZE];
volatile uint8_t  frame_ready = 0;
volatile uint16_t frame_len   = 0;
static   uint8_t  frame_copy[RX_BUF_SIZE];

// 初始化时调用一次(放在 DMA/UART Init 之后)
void Vision_UART_Start(UART_HandleTypeDef *huart){
    HAL_UARTEx_ReceiveToIdle_DMA(huart, rx_buf, RX_BUF_SIZE);
    __HAL_DMA_DISABLE_IT(huart->hdmarx, DMA_IT_HT);  // 关半满中断,只要IDLE/收满
}

// 整帧到达回调:Size = 本帧字节数(收到指定长度或线路空闲触发)
void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t Size){
    if (Size > 0 && Size <= RX_BUF_SIZE){
        memcpy(frame_copy, rx_buf, Size);
        frame_len = Size; frame_ready = 1;            // 只置标志,解析放主循环
    }
    HAL_UARTEx_ReceiveToIdle_DMA(huart, rx_buf, RX_BUF_SIZE);  // 重启接收
    __HAL_DMA_DISABLE_IT(huart->hdmarx, DMA_IT_HT);
}

解析：一道道闸机的状态机

收到一整块字节后，怎么验证它是合法的一帧？用一个逐字节状态机最清晰。

typedef enum {S_H1,S_H2,S_TYPE,S_LEN,S_DATA,S_SUM,S_T1,S_T2} PState;
typedef struct { uint8_t type; uint8_t len; uint8_t data[32]; } Frame;

// 逐字节喂入,返回 1=完整有效帧, -1=出错, 0=进行中
int frame_feed(uint8_t byte, Frame *out){
    static PState st = S_H1; static uint8_t idx=0, sum=0; static Frame f;
    switch(st){
      case S_H1: if(byte==0xAA) st=S_H2; break;
      case S_H2: st = (byte==0x55)? S_TYPE : S_H1; break;     // 双字节帧头
      case S_TYPE: f.type=byte; sum=byte; st=S_LEN; break;
      case S_LEN:  f.len =byte; if(f.len>32){st=S_H1;break;}  // 越界保护
                   sum+=byte; idx=0; st = f.len? S_DATA : S_SUM; break;
      case S_DATA: f.data[idx++]=byte; sum+=byte;
                   if(idx>=f.len) st=S_SUM; break;
      case S_SUM:  if((sum&0xFF)!=byte){ st=S_H1; return -1; } // 校验失败,丢
                   st=S_T1; break;
      case S_T1:   st = (byte==0x0D)? S_T2 : S_H1; break;
      case S_T2:   st=S_H1;
                   if(byte==0x0A){ *out=f; return 1; }        // 完整有效帧!
                   return -1;
    }
    return 0;  // 进行中
}

七、保命：超时降级，绝不让小车失控

视觉模块再好，赛场上也会掉链子——强光、反光、被手挡一下、线松了，丢帧是常态。这时候如果主控还傻等视觉数据，或者拿着一张过期的旧照片硬冲，小车就直接冲出赛道掉大分了。

所以必须有超时降级这道保命机制：

volatile uint32_t last_valid_ms = 0;
int16_t line_error=0, line_angle=0; uint8_t vision_ok=0;

void Control_Loop(void){          // 固定周期调用(如 5ms)
    if(frame_ready){
        frame_ready=0; Frame f;
        for(uint16_t i=0;i<frame_len;i++){
            int r = frame_feed(frame_copy[i], &f);
            if(r==1){                                  // 只有校验通过的整帧
                last_valid_ms = HAL_GetTick();         // 才刷新超时计时!
                if(f.type==0x01){                       // 巡线
                    line_error = (int16_t)(f.data[0]|(f.data[1]<<8));
                    line_angle = (int16_t)(f.data[2]|(f.data[3]<<8));
                    vision_ok = 1;
                } else if(f.type==0x00){ vision_ok = 0; } // 视觉报告:没线
                // else 0x02/0x03/0x04: 二维码/Tag/数字 id = f.data[0]
            }
        }
    }
    if(HAL_GetTick() - last_valid_ms > 100){            // >100ms 超时
        vision_ok = 0;
        Fallback_GrayscaleOrIMU();                      // 降级:灰度巡线/IMU航向
    } else if(vision_ok){
        Motor_PID(line_error, line_angle);              // 正常:视觉闭环
    }
}

这段里藏着几条容易被忽略、但赛场上很要命的细节：

要让降级真正靠谱，前提是灰度、IMU 这些备选方案本身就已经能独立巡线/锁航向。这就回到了一条贯穿整个系列的最佳实践：

八、联调心法与一份避坑速查

最后给一句这一篇最重要的工作方法：

随手附一份本篇的避坑速查，赛前过一遍：

• ☐ 视觉端只发”结论”几个数，绝不发整图
• ☐ 帧头用双字节 0xAA 0x55 + 长度 + 校验三重确认
• ☐ K230 用串口前先 FPIOA 配引脚复用，且别用 UART0/UART3
• ☐ K230 与 STM32 都是 3.3V，TX-RX 交叉接、务必共地
• ☐ 主控收包走 DMA + IDLE 中断，IDLE 中断记得手动使能
• ☐ 中断里只置标志，解析和控制放主循环
• ☐ 大小端两边对齐（视觉 <hh 小端 → 主控低字节在前还原）
• ☐ 只有校验通过的帧才刷新超时计时，坏帧只丢弃
• ☐ >100ms 无有效帧立即降级到灰度/IMU，并加迟滞防抖动
• ☐ 巡线阈值和 ROI 到现场必须重新标定，别照抄例程
• ☐ 赛前做一次”拔视觉线”的故障注入，验证降级真的会触发

到这里，小车的”眼睛”和”神经”就接通了：视觉看到东西、算出结论、打包成帧发出去，主控收包、校验、闭环，还带着超时降级的保命绳。但你可能已经发现，主控这边的活越来越多了——既要跑控制环、解析串口，又要处理起步、过弯、停靠、丢线找回这些不同阶段的逻辑。这些怎么有条不紊地组织起来、各自按什么节奏跑，就是下一篇要解决的事：状态机与整车软件架构。

本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 11 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标
2. 第2篇 · 赛题进化史与押题
3. 第3篇 · 整车搭建与代码框架
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D
7. 第7篇 · PID 进阶：串级+工程补丁
8. 第8篇 · PID 调参实战(核心)
9. 第9篇 · 进阶控制：几时该上
10. 第10篇 · K230 视觉与通信协议
11. 第11篇 · 状态机与整车软件（本篇）
12. 第12篇 · 现场作战+避坑+开源

电赛小车系列前面十篇，我们把电控的零件一个个磨出来了：电机能听话转、传感器看得见路、PID 能把速度和方向调稳、视觉和主控也能对上话。但这些都还只是”零件”。这一篇，我们要做的是把所有零件焊成一台真正能在赛道上跑的车。

你会发现一个有意思的现象：很多队伍每个模块单测都好好的——电机转得欢、灰度读得准、PID 波形漂亮——可一旦合到一起跑整车，就开始抽风：要么卡死不动，要么时灵时不灵，要么过个十字就冲出去了。问题几乎都不在某个模块本身，而在”怎么把它们组织起来、谁先跑谁后跑、出了岔子怎么兜底”。这就是整车软件架构要解决的事。

这一篇我们讲清四件事：分层（代码怎么摆放）、调度（谁在什么时候跑）、控制环时序（一拍里按什么顺序干活）、状态机（整车行为怎么管），最后再钉一遍贯穿全系列的保护逻辑和那条”机械定上限、软件定下限”的硬道理。吃透这几件事，你的车就从”一堆能动的零件”变成”一台能比赛的车”。

一、分层架构：让你的算法”换芯片不换脑子”

先讲个大白话比喻。写整车软件像点外卖：

这正是逐飞、恩智浦那套智能车开源库多年沉淀下来的标准做法。把代码分成四层，上层依赖下层、下层不知道上层的存在：

以逐飞 SeekFree 库为例，它的真实分层是这样的：

中间件层（PID、滤波、协议、元素识别）这些纯算法，本质上和芯片没有任何关系——它们只是数学，搬到任何平台上都一样跑。

一条必须刻进脑子的铁律

这条铁律还是用打比方理解最快：

为什么值得花这个力气分层？ 因为它直接决定了你前面那些功夫能不能”白嫖”过来。整车搭建那一篇讲过”STM32 练手、MSPM0 比赛”的策略，分层就是这套策略能成立的根。看一组实打实的证据：同一套逐飞库，社区已经移植到了 RT1064、英飞凌 TC264、STC32G144K，甚至 2025 年 TI 板电赛用的 MSPM0G3507。这些版本的 App 层和算法层几乎一字不改，差异全部集中在底层驱动。

想找范本直接抄结构的，推荐 Sakuramdd/SeekFree_RT1064_Opensource_Library，标准三层加上 code 目录（image / control / init），是研究分层与解耦最干净的样本。STM32 与 MSPM0 之间具体怎么对应 API、平移时要注意什么，整车搭建那一篇已经给过对照心法，这里不展开。

二、调度：电赛首选”前后台裸机”，别动不动就上 RTOS

代码摆好了，下一个问题是：这么多任务——读传感器、跑 PID、刷屏、收视觉数据——谁在什么时候跑？这叫调度。常见的有三档，我们从简单到复杂排一下。

第一档：前后台裸机（电赛首选）

这是最常见、最可预测的方案，也是绝大多数电赛车的选择。结构极简：

把这套结构画出来就是：

第二档：时间片轮询

如果你有好几个不同周期的任务（控制环 5ms、读视觉 20ms、刷屏 100ms），可以用一个简单的时间片调度器：用一个 1ms 的定时器统一递减计时，到点就给任务打个”该跑了”的标记，主循环看到标记再去执行。

// 时间片轮询调度器：一个 1ms 的 tick 管多周期任务
typedef struct { uint16_t period, timer; uint8_t run; void(*task)(void); } Task_t;

Task_t tasks[] = {
    {5,   5,   0, Control_Loop},  // 5ms：  控制环
    {20,  20,  0, Read_Vision},   // 20ms： 收视觉
    {100, 100, 0, Update_OLED},   // 100ms：刷屏
};
#define N (sizeof(tasks) / sizeof(tasks[0]))

void SysTick_Handler(void) {          // 1ms tick
    for (int i = 0; i < N; i++) {
        if (tasks[i].timer == 0) { tasks[i].timer = tasks[i].period; tasks[i].run = 1; }
        else tasks[i].timer--;
    }
}

int main(void) {
    Init();
    while (1)
        for (int i = 0; i < N; i++)
            if (tasks[i].run) { tasks[i].run = 0; tasks[i].task(); }
}

这其实是前后台的”加强版”，介于裸机和 RTOS 之间——能管多个不同周期的任务，但仍然透明可控、没有调度器的黑盒。

第三档：RTOS（FreeRTOS / RT-Thread）

只有当任务真的多、真的需要并发的时候才上 RTOS。它的代价不小：

电赛如果真要上 RTOS，主流就是 FreeRTOS 和 RT-Thread 这两个。

那到底该不该上 RTOS？

更具体地说，宁可用周期性裸机也不上 RTOS 的理由有三条，都很实在：

• 确定性：定时器中断直接管任务，没有 RTOS 那套调度算法和优先级反转，固定周期任务给你严格的时序保证，最坏执行时间也好分析。
• 低开销：省掉内核那几 KB 的 ROM/RAM，省掉每个任务的控制块（TCB）。
• 易验证：任务少（三五个）时，状态机比多线程透明得多，不会有死锁、没有同步 bug。

记住一句话：RTOS 是给”任务多到管不过来”准备的解药，不是给整车软件撑场面的装饰品。

三、控制环时序：5ms 一拍，按死顺序干活

调度定好了，现在聚焦最核心的那个”前台”——控制环。它跑在定时器中断里，是整车的心跳。

为什么是 5ms（也就是 200Hz）？这是智能车社区多年试出来的甜点：够快，能保证控制平滑；又不至于太快，给中断里的计算留足时间。背后有个定量依据——采样定理（Nyquist）：采样频率要大于被控信号变化频率的 2 倍，才不会”漏看”信号的变化。小车的动态没那么快，5ms 一拍绰绰有余。

STM32 上配一个 5ms 中断很简单：在 72MHz 主频下，预分频 PSC = 72（把计数时钟降到 1MHz，即 1µs 一格）、重装载 ARR = 5000（数 5000 格就是 5ms），就是精确的 5ms。

一拍里的标准流程

中断一进来，按这个顺序走，一步都不能乱：

落成代码骨架就是这样（前后台架构里的”前台”）：

// PIT / TIM 5ms 中断 —— 固定周期控制环（前台）
void TIM3_IRQHandler(void) {
    if (TIM_GetITStatus(TIM3, TIM_IT_Update)) {
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update);

        // 1) 采集：读编码器测速，读完立刻清零
        int16_t el = Read_Encoder(L); Clear_Encoder(L);
        int16_t er = Read_Encoder(R); Clear_Encoder(R);
        IMU_Read(&gyro, &acc);

        // 2) 融合：互补滤波出姿态角
        float ang = Complementary_Filter(acc, gyro, 0.005f);

        // 3) 串级 PID：外环速度 → 内环转向
        int16_t ps = Speed_PI(target, (el + er) / 2);   // 外环：速度
        int16_t pt = Turn_PD(line_err, gyro.z);         // 内环：转向

        // 4) 输出：差速 + 限幅后写 PWM
        Set_Motor(LIMIT(ps - pt, -7200, 7200),
                  LIMIT(ps + pt, -7200, 7200));

        // 5) 保护：视觉超时则降级，绝不盲冲
        if (++vision_timeout > VTO) Set_Motor_Safe();
    }
}

内环必须比外环快

讲串级 PID 时埋过一个伏笔，这里再钉一遍：

所以控制环里的铁律是：内环周期 ≤ 外环周期，且内环先调稳。外环的输出是内环的目标，内环都晃晃悠悠，外环再准也没用。具体的调参顺序（先内后外、先 P 后 I 再 D、看波形治百病）在 PID 入门、PID 进阶和 PID 调参实战那几篇已经讲透了，这里只强调时序关系。

最容易踩的两个时序坑

顺手补一个：传感器进 PID 前先滤波

采集到的编码器、陀螺数据有高频噪声，直接喂给 PID 的 D 项会被 Kd 放大成持续抖动。一个又便宜又好用的办法是一阶低通：

// 一阶低通：新值占 0.3，旧值占 0.7，平滑又便宜
Encoder = Encoder * 0.7f + new_value * 0.3f;

融合姿态角同理。互补滤波是工程上最常用的：

// dt = 0.005s；0.98 越大 => 越信陀螺（高通）
float Complementary_Filter(float acc_ang, float gyro_rate, float dt) {
    static float angle = 0;
    angle = 0.98f * (angle + gyro_rate * dt) + 0.02f * acc_ang;
    return angle;
}

四、状态机：把整车行为拆成”一次只演一个角色”

控制环管的是”这一拍怎么打方向”，但整车在赛道上还有更宏观的行为切换：在起跑线待命、起步加速、跑直道、过弯道、到了十字路口要决策、到终点要精确停靠、丢线了要找回、出意外要急停……这些行为怎么管？答案是有限状态机（FSM）。

这就是状态机最大的价值：降耦合、易调试。把复杂行为拆成独立状态，每个状态只管单一功能。智能车国赛代码多年都用状态机管理直道、弯道、十字、丢线、急停；自动驾驶的行为规划也用分层有限状态机（HFSM），状态名都很像，比如 FORWARD_DRIVE、STOP_SIGN_WAIT、CROSS_INTERSECTION。

整车主状态机骨架

注意急停（ESTOP）能从任何状态进入——这是最高优先级，下面代码里会体现（图里只画了几条代表线，实际是所有状态都能转）：

typedef enum {
    ST_IDLE, ST_START, ST_STRAIGHT, ST_CURVE,
    ST_CROSS, ST_PARK, ST_LOST, ST_ESTOP
} CarState;

CarState st = ST_IDLE;

void State_Machine(void) {
    if (estop_flag) { st = ST_ESTOP; }   // 急停最高优先级，先判
    switch (st) {
        case ST_IDLE:     if (start_btn) st = ST_START;       break;
        case ST_START:    if (moving)    st = ST_STRAIGHT;    break;
        case ST_STRAIGHT: if (is_cross())      st = ST_CROSS;
                          else if (is_curve()) st = ST_CURVE;
                          else if (line_lost)  st = ST_LOST;  break;
        case ST_CURVE:    if (!is_curve())     st = ST_STRAIGHT;
                          else if (line_lost)  st = ST_LOST;  break;
        case ST_CROSS:    Cross_FillLine();
                          if (passed) st = ST_STRAIGHT;       break;
        case ST_LOST:     Recover_ByLastError();
                          if (line_found) st = ST_STRAIGHT;   break;
        case ST_PARK:     Precise_Stop();                     break;
        case ST_ESTOP:    Set_Motor(0, 0);                    break;
    }
}

状态机最容易写错的地方

五、保护逻辑：能拿分的车，先得是”摔不死”的车

开篇那一篇讲过电赛的拿分逻辑——有一堆”失败即 0 分”的红线（冲出赛道、超时等等）。所以整车软件里，保护逻辑不是锦上添花，而是保命。前面控制环代码里那行 if (++vision_timeout > VTO) Set_Motor_Safe(); 就是保护段的入口。这里展开两个最关键的。

视觉超时降级：信号断了别闭眼猛踩

这是新手最容易忽略、又最容易翻车的地方。注意一个事实：摄像头帧率（60~100Hz）远低于控制环（200Hz）。也就是说，控制环跑两三拍，视觉才更新一帧。如果某一拍没有新帧，或者连续丢线超过阈值了，你绝不能拿过期的、无效的图像去盲控。

具体做法：设一个看门狗 / 超时计数器，每来一帧新数据就清零，控制环每拍 +1。超过阈值就降级——保持上一个有效打角、减速或限速直行；严重时直接急停。阈值各队按自己车的特性定。视觉那一篇也讲过同款思路：通信超时（比如超过 100ms 没收到包）就降级到灰度或 IMU 兜底，两处其实是一回事。

丢线找回：记住”最后看见路的方向”

丢线之后怎么回到赛道？核心思路是记忆最后一次有效偏差：

• 设一个 last_error，没丢线时持续更新它；
• 一旦判定丢线，就冻结这个值；
• 用冻结的偏差判断车是往哪边出去的，据此朝相反方向打角，把车拽回赛道。

判丢线常用”全行扫描”：从图像底部往上扫，一直扫到最上面一行还找不到赛道边界，就判为丢线。

六、一条贯穿始终的硬道理：机械定上限，软件定下限

最后，讲一个比任何代码都重要的认知，来自哈工大紫丁香队的血泪经验：

他们有两个特别值得记的故事：

还有一条赛场铁律，宁可多说一遍：

想找完整工程当范本？

光看片段不过瘾，下面几个开源仓库可以拿来研究整车是怎么组织的：

• Sakuramdd/SeekFree_RT1064_Opensource_Library：逐飞 RT1064 视觉组开源库，标准三层 + code(image/control/init)，研究分层与解耦的最佳范本。
• woai66/SeekFree_MSPM0G3507_Opensource_Library：逐飞库移植到 TI MSPM0G3507，直接对应 TI 赛道，是芯片解耦平移的活样本。
• Jerrysupreme/XJTU-VISON_SMARTCAR_2025：西安交大 2025 智能视觉组完整参赛级工程，底盘 RT1064 + 摄像头，学整车怎么组织。
• Blight001/SmartCarCameraTrackingSimulation：Unity 做的赛道仿真，10 款赛道含国赛道，还能逐帧回溯复盘”为什么冲出赛道”——没硬件时调循迹、调参、复盘的神器。
• hxk55668/PID_CAR-STM32-FREERTOS-：想用 FreeRTOS 组织控制/通信/显示任务的，可以参考这个。

更全的开源清单和现场调试速查表，留到下一篇集中给。

小结：把这一篇钉进脑子

到这里，整车软件的骨架就立起来了。回顾一下这几条心法：

• ☐ 分层：App / 中间件 / Driver / HAL 四层，上层只调下层、下层不反调，设备层禁碰芯片 API——换芯片只改驱动层。
• ☐ 调度：电赛首选前后台裸机（主循环跑慢任务 + 定时器中断跑控制环），任务真多了再考虑 RTOS。
• ☐ 控制环：5ms 一拍（200Hz），按”采集→融合→串级 PID→输出→保护”死顺序走，内环快于外环，ISR 只做核心、耗时操作甩主循环。
• ☐ 状态机：把整车行为拆成独立状态，急停最高优先级、等待型状态都要超时退出。
• ☐ 保护：视觉超时降级、丢线记忆找回、出界急停——保命优先。
• ☐ 认知：机械定上限、软件定下限；传感器上场前必标定。

软件框架搭好了，但真正决定你能不能拿奖的，是四天三夜里在赛场上把它跑稳、调好、不翻车。下一篇现场作战手册，我们就聊聊四天三夜怎么安排、调试怎么避坑、以及哪些开源仓库值得你现在就 star。

本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 12 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标
2. 第2篇 · 赛题进化史与押题
3. 第3篇 · 整车搭建与代码框架
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D
7. 第7篇 · PID 进阶：串级+工程补丁
8. 第8篇 · PID 调参实战(核心)
9. 第9篇 · 进阶控制：几时该上
10. 第10篇 · K230 视觉与通信协议
11. 第11篇 · 状态机与整车软件
12. 第12篇 · 现场作战+避坑+开源（本篇）

前面十一篇，我们把一辆电赛小车从里到外拆了个遍：从拿分逻辑、赛题套路，到电机电源、感知、PID、串级双环、视觉通信、状态机……该有的零件都齐了。但你会发现一个残酷的事实——赛场上翻车的队伍，十有八九不是输在”不会”，而是输在”现场没扛住”。明明实验室里跑得好好的车，一到测评台就画龙、就冲出、就死机；明明算法都对，却因为没备份、没睡觉、最后一刻手贱改了个参数，把到手的奖弄丢了。

这一篇是整个系列的收官，也是最接地气的一篇。我们不讲新算法，只讲一件事：怎么把四天三夜活着打完，并且把已经会的东西，稳稳地变成台上的分数。 内容分四块：四天三夜的作战节奏、一张能照着排查的故障速查表、几条保命拿分的现场细节，最后是一份精选开源仓库清单。

一、四天三夜，到底是怎么个打法

电赛全国赛是四天三夜、约 84 小时连续作战（一般从第 1 天早上 8 点，到第 4 天晚上 20 点封箱上交）。这不是一场冲刺，是一场马拉松——而且是你自己一边造跑鞋一边跑的马拉松。

队伍标准配置是 2 软 1 硬（两人写软件、一人管硬件），但分工不是各扫门前雪，而是有节奏地交替。多支国奖队伍的复盘高度一致，节奏大致是这样：

第 1 天：定平台、搭机械、焊板子。 这是最忙也最关键的一天。先按题目的硬约束把平台选死（尺寸、主控、传感器都要合规，下文细说），然后机械组全力把车搭出来。

第 2 天：模块联调。 机械稳定后，把感知、电机、PID、通信一块块接起来跑通。这一天的目标是”全程能慢速跑完”，不求快。

第 3 天：核心调试 + 开始写报告。 这是分水岭。两个软件队员轮流——一个调车，一个写报告，报告随做随存、不要攒到最后赶。

第 4 天上午：定稿封箱。 不再改结构，最后一小时彻底停手，把能跑的版本稳稳交上去。

报告：边做边写，对着评分表填空

很多人误以为报告要憋到最后熬夜写。错。报告应该是第 3 天就开始、随做随存——因为它本质上是一道”按点给分”的填空题。

回顾我们在《这比赛到底在比什么》一篇说过的结论：现在的小车题总分 120 = 客观测试 100 + 设计报告 20，报告只占约 1/6。

报告 20 分怎么分？以 2024 H 题官方评分表为例：

写报告的诀窍就一句：对着这张表，一项一项填。 其中体现”测了 → 有数据 → 会分析”这条闭环最值钱。还要注意一点：测试数据必须真实可复现。因为拟获一等奖的队伍要过”综合测评”这一关（满分 30 分，统一在 8 月 10 日 8:00–15:00 闭卷制作，禁网、禁手机、禁电脑，只能带纸质资料，至少 3 名专家共同记录签字）。编造数据、或报告与实物对不上，是大忌。

二、调试与避坑：分模块自测 + 故障速查表

调试最忌讳”啥都接上、一把上电、然后对着不动的车发呆”。正确姿势是分模块自测，从下往上一层层确认，每层 OK 了再叠下一层：

• ☐ 电源：上电先量各路电压（电机轨、5V、3.3V），别让 MCU 欠压复位
• ☐ 电机方向：低 PWM 单独给每个电机，确认正转 / 反转方向对、没接反
• ☐ 编码器：手动转轮子，看脉冲计数有没有变、正反方向符号对不对
• ☐ 传感器：灰度看黑白阈值、IMU 看 Yaw 静止漂不漂、视觉看回传数据
• ☐ 速度环（内环）：给固定目标速度，看能不能稳准跟随
• ☐ 方向 / 循迹环（外环）：内环稳了再叠外环，先慢速循迹
• ☐ 状态机 + 保护：最后把丢线找回、出界急停、视觉超时降级接上

下面这张速查表，建议直接打印贴在工位上。绝大多数现场故障都能在里面对号入座：

几个最容易踩的坑，单独拎出来强调

三、保命拿分：现场细节决定生死

讲完技术，再讲几条”不写代码但能救命”的现场策略。这些每一条背后都有人摔过跟头。

求稳，永远优于求全

这是整个系列反复强调、也是现场最值钱的一条心法。回顾《这比赛到底在比什么》：客观测试约占 83%，而且有一堆“失败即 0 分”的红线——投影脱离弧线、整车越黑线、超时达规定 1 倍以上、用错主控、装了禁用的摄像头、尺寸超标、用了禁用的麦轮 / 履带……任何一条中招，该项甚至全场归零，比少拿几分发挥部分严重得多。

所以拿分顺序应该是：先吃满低门槛的基本要求 → 再啃高分项 → 发挥部分按”能不能稳定复现”来取舍。

两个故事一个结论：冲高风险的发挥项之前，先问自己——万一失败，会不会把已经到手的分一起赔进去？ 不稳定的功能，宁可不做。

测评现场和定稿后，绝不大改硬件和 PID 参数

现场测评一般有 30 分钟准备时间（电路恢复、虚焊重焊、换普通元件都行；超时则每超 1 分钟扣 1 分），但封箱后硬件不可改。第 4 天上午定稿之后，更要把”求稳”刻进 DNA：

备件全双份，且要趁早囤

别只盯着电子元件。备件清单里还要有：笔（报告全程手写，至少 2 支）、热熔胶、封箱用的木板 / PVC 板。有人现场才发现没带够笔——细节翻车，最冤。另外建议赛前先把 2~3 道历年题完整做一遍，把循迹、测距、视觉这些算法模块当”半成品”储备好，现场直接调用。

用一份问题清单，把疲劳期的脑子”外包”出去

国奖队的另一个习惯：全程维护一份 Bug 清单（随手记下遇到的问题和解法）。等到第 3、4 天人困马乏时，靠这份清单快速定位”这个坑我之前是怎么填的”。本质上就是把疲劳期的认知负担，前置到清醒的时候——和”报告随做随存”是同一个道理。

四、精选开源仓库与学习资源

最后送上一份”站在巨人肩膀上”的清单。这些都是社区里口碑不错的开源项目，逐个评注它们是什么、能借鉴多少。

MSPM0 路线（2024 起电赛官方主推）

STM32 / 跨平台路线（练手和借鉴思路）

题库与官方文档（必备底料）

• CCBP/NUEDC_Topic：历年全国电赛真题 PDF 合集，每题含官方评分标准表。研究评分逻辑、看清”基本要求 vs 发挥部分”分值的第一手权威来源，做题型预测和能力反推必备。
• 立创开发板 lspi 竞赛指南 wiki：备赛流程、器件采购、按分值优先级拿分等实操建议，前面引用的”器件易断货””按分值优先级取舍”都出自这里。

写在最后

到这里，”从 0 到 1 带你打电赛·小车电控篇”十二篇就全部讲完了。我们从”这比赛在比什么”出发，一路走过赛题进化、整车搭建、电机电源、感知、PID 入门到进阶、调参实战、进阶算法、视觉通信、状态机，最后落到今天这份现场作战手册。

如果只让我留一句话给即将上场的你，那就是开篇就埋下、今天又反复出现的那条主线——

电赛不只是一场比赛，它会逼你在极限压力下，把书本上的电机、PID、状态机真正变成手里能跑的东西。那种”它终于稳稳停在终点”的瞬间，值得你熬的每一个夜。

去吧，把车跑稳。祝你拿奖。

本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 1 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标（本篇）
2. 第2篇 · 赛题进化史与押题
3. 第3篇 · 整车搭建与代码框架
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D
7. 第7篇 · PID 进阶：串级+工程补丁
8. 第8篇 · PID 调参实战(核心)
9. 第9篇 · 进阶控制：几时该上
10. 第10篇 · K230 视觉与通信协议
11. 第11篇 · 状态机与整车软件
12. 第12篇 · 现场作战+避坑+开源

先问你一个问题：你觉得电赛拿奖，最该练的是什么？是把代码写得多漂亮，还是把报告写得多厚？

如果你脑子里第一反应是”报告要写好、PPT 要做炫”，那这篇就是来”劝退”这个想法的。我们这群拿过奖、也翻过车的人复盘下来，结论很一致：电赛小车这条赛道，拿分逻辑跟你想的可能不太一样。 这一篇不讲任何代码、不调任何参数，只干一件事——把”拿奖”这个听起来很玄的目标，拆成一条你接下来能照着练的清单。

把地图先摊开，后面十一篇你才知道每一步是在往哪走。

先用一分钟说清楚：这比赛到底是个啥

全国大学生电子设计竞赛（简称电赛，英文缩写 NUEDC），由教育部和工信部共同发起，是国内电子信息类规模最大、含金量最高的学科竞赛，一年差不多四万人参赛。它有个让新人很懵的”大小年”规律：

报名规则很简单：本校三个人自愿组一队，国赛名额通常要靠省赛推荐（一般是省一，部分省份可推优秀省二）。控制类（也就是我们这个”小车/平衡车/云台追踪”赛道）是电赛的核心方向之一。

最有”仪式感”的是赛程：四天三夜封闭。 一般 8 月初开赛，第一天早上 8 点前发题，最后一天晚上 8 点开始装箱封箱，中间禁止老师指导，元器件由学校提供。这四天三夜，你大概率是要熬夜的——所以”身体和心态扛不扛得住”，本身就是实力的一部分。

重头戏：这比赛的分，到底是怎么给的

这是全篇最值钱的一节，请慢点读。

很多人对评分有个”祖传印象”：总分 150，报告占 1/3（50 分）。 你在不少老资料、老学长口口相传里都会听到这个说法。

打住——这个数字不能拿来规划你的精力。

我们直接看两份官方真题的评分表，硬碰硬：

两道题、隔了三年，结构却惊人一致：报告恒为 20 分，剩下 100 分全是能拿尺子量、能掐秒表算的客观测试。 客观测试占了约 83%。

这就推出第一条铁律：

打个比方：客观测试 vs 报告，就像高考的”笔试分”和”卷面整洁分”。 小车真能跑、跑得准、跑得快，那是 120 分里的 100 分；报告写得漂亮，只值 20 分。字再工整，题做错了也白搭——先把题做对，再把卷面写干净。

比”少拿分”可怕一万倍的事：失败即 0 分

如果说”报告占比”是认知误区，那下面这个才是真正会让你前功尽弃的东西——红线。

客观测试里埋了一大堆”踩了就该项归零、甚至整场归零”的硬规则。以 2024 H 题为例，官方”说明”里白纸黑字写着这些约束：

2021 F 题同样狠：发挥部分超过 60 秒直接计 0；投影连续落在黑线上超过 30cm、或整车越过黑实线、或两车连续接触超过 5 秒，该测试项直接 0 分。

这些红线为什么比”少拿几分发挥部分”严重得多？因为它们是”一票否决”。

关于”测试不过会怎样”，网上有种很流行的强表述：”测试不通过 = 报告不参与评分 = 直接 0 分”。这里要给你一个更准确的版本，免得你被吓得方向跑偏：

还有两个你迟早要面对的关卡

光赛区跑得好还不够，想进国奖，得知道后面这两关：

• 综合测评（满分 30 分）： 这是冲国奖队伍的”复测确认”关，俗称”关小黑屋”。统一在 8 月 10 日 8:00–15:00 单独一天闭卷进行，不能上网、不能用手机和电脑，只能带纸质资料，由至少 3 名专家共同签字记录。只有超过专家组划定的最低分数线，作品才计入全国评审总分（这条线不公开）。说白了，就是把你三个人单独带进小房间限时做一道题，验证作品到底是不是你们自己做的、基本功扎不扎实。
• 获奖比例（你得知道自己在跟多少人抢）： 全国奖总数 ≤ 参赛队的 8%（国一、国二大约三七开）；赛区一二三等总获奖 ≤ 40%；赛区把 ≤ 10% 的优秀队材料上报全国。还有个细则：同一所学校、同一道题，推荐参加全国评奖的总队数 ≤ 4 个。

把这两关串起来看，结论很冷酷也很清晰：想进国奖，你得先在赛区前 10%，而且测试硬实力必须真的够。 报告里的数据还不能造假——综合测评和复评是可能要你现场复测的，数据对不上直接出局。

把”拿奖”拆成能训练的小目标

好，现在我们手里有了评分逻辑这把尺子。接下来反过来想：评委按什么给分，我就该按什么顺序练。 这条能力链，是这一篇最想塞给你的”心智模型”：

逐个拆开说：

① 稳——不冲出赛道、不挂零。 这是地基，对应红线里那一堆”0 分”项。能力上靠的是方向环 ＋ 合理限速，先让车低速也能稳稳跟着线走、不丢线、不冲出。这一步练扎实，你就已经跑赢一大批”车一上赛道就飞出去”的队伍了。

② 准——定点停车，投影覆盖顶点。 光会跑还不够，题目往往要求停在指定位置（比如投影要盖住 A/B/C/D 顶点）。这靠的是距离环 ＋ 到点判定逻辑，让车知道”我到了，该停了”。

③ 快——发挥部分拼用时。 H 题要求(4)明确写着”用时越少越好”，这就是发挥分。但提速会放大循迹和惯性误差，一不小心就冲出去（又回到红线 0 分）。所以这一步的原则是——

④ 报告闭环——误差分析 ＋ 实测数据。 报告虽只占 20 分，但这 20 分是”按点给分的填空题”，性价比其实不低。以 H 题报告评分细分为例：

一个绕不开的策略问题：基本要求 vs 发挥部分

赛题一般分”基本要求”和”发挥部分”两段。怎么取舍？

以 H 题为例：要求(1)(2)各 20 分共 40 分，难度低、能 100% 稳过；要求(3)(4)各 30 分但难度高、风险大。理性的打法是：先把 40 分稳稳吃满，再去冲 (3)；与其赌难度最高的 (4)，不如先确保前面不掉链子。 立创 wiki 里有个很经典的案例：某队卡在”波形显示 +10 分”做不出来，被建议”波形做不出，就把 UI 设计的 +10 分拿满”——按分值优先级拿分，而不是死磕一个难点。

来自前辈的几条血泪教训

光讲道理太干，给你几个真实翻车现场，提前感受一下”坑”长什么样（细节和处置我们留到对应篇章展开）：

• 方案越复杂越烧时间。 有队伍上了”双摄像头”方案，整场都在优化图像处理，赛后才发现单摄像头改个朝向就能实现同样功能。更致命的是没做版本管理——第一版能跑的程序后来”复现不出来”，第三天又过度自信去研究高精度模型，最后回不到能用的版本。教训：先用最简方案跑通拿保底分；每个能跑的版本立刻打包备份，”能复现”比”更优”重要得多。（来源）

• 硬件 / 机械问题，软件救不了。 同一台车在瓷砖地能跑 2m/s，换到木地板却加速不上去，根因是编码器机械摩擦 ＋ 电机 PID 失配；还有激光因虚焊间歇失效，最后靠焊死才解决。教训：关键信号线要焊接、别用杜邦线；机械和电源前两天就定型，后期只动参数。

• 车模和电机要冗余前置。 有人现场才发现车模尺寸超标、或电机扭矩不够，已经来不及了。教训：多备车模 / 电机 / 轮子 / 驱动 / 传感器；开赛先按题目尺寸和约束选定平台，别等软件调好才发现硬件违规。

本系列的学习地图

这一篇是”为什么”，接下来的十一篇是”怎么做”。给你一张全图，知道每篇在能力链的哪个位置：

把方向定好了，下一步自然是搞清楚”出题人到底想考什么”。下一篇《赛题进化史与押题》，我们就顺着历年小车赛题的演变，带你看懂出题套路、押对备赛方向。

本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 2 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标
2. 第2篇 · 赛题进化史与押题（本篇）
3. 第3篇 · 整车搭建与代码框架
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D
7. 第7篇 · PID 进阶：串级+工程补丁
8. 第8篇 · PID 调参实战(核心)
9. 第9篇 · 进阶控制：几时该上
10. 第10篇 · K230 视觉与通信协议
11. 第11篇 · 状态机与整车软件
12. 第12篇 · 现场作战+避坑+开源

上一篇我们把”怎么拿奖”拆成了一条能力链：稳→准→快→报告。但还有一个问题没解决——你到底该练哪种”稳准快”？循迹？测距？视觉识别？双车通信？这些技能学起来都不便宜，四天三夜里全练一遍根本不够。

所以这一篇，我们来当一回”押题侦探”。把历年小车/控制类赛题摊开来看，你会发现出题人不是随机出题的，他们有一条非常清晰的进化主线。看懂这条线，你就能猜到下一题大概要考什么，把有限的备赛时间砸在刀刃上。

先扫掉一个最常见的误区：电赛不是年年都有国赛

很多新人一上来就栽在赛制上。这件事先说清楚，否则你押题的年份都会对错。

全国大学生电子设计竞赛（NUEDC，大家都叫它”电赛”）是两年一个周期：

• 奇数年（2021、2023、2025…）= 国赛，全国统一命题、规模最大，圈里叫”大年”；
• 偶数年（2022、2024…）= 省级赛 + TI 杯模拟电子系统设计专题赛，圈里叫”小年”。

这个”大年小年交替”，你可以想成奥运会和省运会：国赛像奥运会，奇数年全国总动员、最隆重；省赛 + TI 杯像省运会加专项邀请赛，偶数年小一号、按地区比。

赛制的更多细节（四天三夜怎么打、三人怎么分工）后面《整车搭建与代码框架》和《现场作战手册》会专门展开，这里不重复。我们直接进入正题——看题。

第一阶段·早期（2003~2011）：把”机械控制”做准

最早的小车题，核心诉求就一个字：准。让车按要求跑、停得准、算得对，根本还没有”看路”这回事。

奠基性的一题是 2003 年 E 题「简易智能电动车」。官方题面要求：

• 直道行驶时，存储并显示每个薄铁片（路面中心标志）到起跑线的距离；
• 进入停车区，准确驶入车库，车身要完全进去；
• 停车后，准确显示全程行驶时间。

听着挺朴素，但它把后面二十年小车题的骨架都立好了：测距、定点停车、全程计时。当年北京科技大学的队伍靠这题拿了国一。

那它的电控核心是什么？很简单：

• 传感器：在车轮上贴黑白条纹，用光电传感器（或霍尔开关）做”里程计”——轮子转一圈，反射光就产生固定个数的脉冲；
• 算法：单片机数脉冲，就能算出走了多远、走得多快；
• 闭环：一个简单的速度闭环，让车别忽快忽慢。

到 2011 年，出现了一个很有意思的题：双车超车。两辆车在赛道上，用光电管寻迹、用红外开关测两车距离，控制车距实现超车。这是”多车协同”主线最早的雏形——日后 2021 送药双车、2022 双车跟随，思想都从这儿来：车间要么直接通信，要么靠相对距离闭环。

第二阶段·中期（2016~2022）：循迹 + 测距 + 双车，控制升级到”串级”

车开始要”会看路”和”会配合”了。这一阶段的关键词是：多路循迹、超声测距、双车通信、串级 PID。

代表题包括 2016 年无线充电车、2017/2022 自动泊车，以及 2022 双车跟随。技术栈明显比早期厚了一层：

• 循迹：从 1 路红外，升级到多路红外 / 灰度阵列。车不再只会直线跑，能沿着地面引导线过弯；
• 测距：超声波测距上场，用来控制车距、避障、入库；
• 通信：双车任务需要稳定的车间通信，最常用的是蓝牙串口模块 HC-05（配置简单、成本低）；如果是跨楼宇的远距离任务，才会考虑 LoRa；
• 控制：单环已经不够用了，串级 PID（双环） 成为标配。

什么叫串级？打个比方——

这条规矩——双环永远从内往外调——是贯穿整个 PID 体系的铁律，后面《PID 进阶》和《PID 调参实战》会反复强调。这里你先有个印象就行：到了中期，调参不再是调一个环，而是调两个环之间的配合。

第三阶段·近期（2021~2024）：视觉 + 决策被推到舞台中央

这是变化最剧烈的阶段。车不光要看引导线了，它要看懂世界——认数字、认靶标、追光斑——然后自己做决策。我们挑三道有代表性的题细看。

2021 F 题「智能送药小车」：视觉融合的里程碑

场景设定得很生活化：医院走廊地面上有一条红线，墙上 / 地上用黑色数字纸贴着病房号。任务是——单车在规定时间内把药送到指定的近距 / 中距病房并返回药房；进阶部分还要两车协同，一起把药送到同一个中距病房。

电控核心一下子丰富起来：

• 摄像头做阈值化红线循迹；
• 摄像头做黑色数字识别（认病房号）；
• 陀螺仪测角度控制转向；
• 光电编码器测里程；
• 单片机跑 PID。

主控通常是 STM32F407，视觉用 OpenMV 或 K210，车体是舵机四驱小车。

这题最值得讲的，是一段真实的国一战例——它告诉你”桌面调通”和”现场能用”是两码事：

同一支队还有个惨痛的硬件插曲：第二辆车在临赛前 UART 和 IO 引脚损坏，被迫整片换主控芯片，在封箱前最后几小时才把两车功能补完。所以关键引脚要早做冗余验证、备好替换板，别把最后几小时排满。

这段经验，到《视觉与通信》那篇会接着深挖——尤其是”视觉模块只回传结论、不回传整张图”的设计思想。这里你先记住一个判断：到了视觉时代，识别算法的成败往往不在算法本身，而在你有没有在真实条件下喂它数据。

2023 E 题「运动目标控制与自动追踪」：毫米级定位的残酷一课

这题严格说不是地面小车，而是二轴舵机云台 + 激光笔 + OpenMV 视觉的组合，但它属于控制类主线，而且给所有人上了一堂关于”机械精度”的课，非常值得看。

系统是：OpenMV 视觉 + STM32 + 二轴云台 + 激光笔，做闭环。功能包括复位、让激光沿屏幕边 / A4 纸边运动、自动追踪一个光斑。题目建议红色激光开环、绿色激光闭环（闭环那部分需要 PID 跟踪）。

难点在哪？算一笔账你就懂了：

这就是那个著名的”激光笔杠杆效应”——手腕（舵机）动一点点，1 米外墙上的红点就跑老远；指得越远，手越要稳。所以精密指向必须用”更细的手腕”。

2024 H 题「自动行驶小车」：回到纯传感器，但把双环 PID 玩到极致

有意思的是，2024 H 题反而”退”了一步——不许用摄像头，强制用 TI 的 MSPM0（M0G3507）平台，靠灰度循迹 + 陀螺仪。但它把控制做到了很硬核的程度。

场地是这样的：≥ 220cm×120cm，两段对称的半圆弧，半径 40cm，黑弧线宽约 1.8cm。四个任务由易到难：

控制方案是七 / 八路灰度识线 + 维特陀螺仪测偏航，跑姿态环 + 寻迹环双环 PID：直线 / 斜线段靠姿态环，过弯靠寻迹环。控制周期 10ms（定时器中断，TIM2）。

实战里有两个流派，你可以都参考：

• 流派一（陀螺主控向）：用位置式 PID，直接以陀螺的绝对偏航角控制直行和转向，把算出来的 PWM 增 / 减量，叠加到左右轮的基础占空比上。逻辑是”遇到黑线开寻迹环，离开黑线开转向环”；
• 流派二（分段动态 PID）：直线段用大 Kp、Kd=0 求快；弯道段用更大的 Kp + 大 Kd 求稳，按陀螺角速度或灰度命中宽度来切换。

这给我们引出两条非常实用的经验法则：

具体到怎么把这几条揉进一份能跑的代码、怎么对着波形一步步整定，是《PID 调参实战》整篇要解决的事，这里点到为止。下面给一段差速控向的骨架，让你先有个手感——不管误差是来自陀螺偏航角还是灰度加权，套路都是”误差 → PID → 叠加到左右轮”：

// 控制周期 10ms（定时器中断里调用）
// err 可以来自：陀螺偏航角偏差，或灰度加权偏差
float turn = Kp * err + Kd * (err - err_prev);
err_prev  = err;

int left  = base_speed - turn;   // 左轮 = 基础速度 - 转向量
int right = base_speed + turn;   // 右轮 = 基础速度 + 转向量
// 符号按你自己的传感器朝向 / 电机接线定，调反了会朝偏差方向越冲越远

但 2024 H 题也暴露了纯灰度 + 陀螺方案的两个致命弱点，这两个坑你一定要提前防：

把这条线拎出来：四个清晰的演进方向

把三个阶段叠在一起看，趋势其实非常干净。我用一张表收一下：

四句话总结出题人的脑回路：

1. 视觉权重一路走高：从”无视觉”，到 OpenMV/K210，再到 K230/MaixCam；
2. 精确停靠越来越变态：从”到了就行”，到厘米级，再到毫米级；
3. 多车协同成为常客：单车 → 双车 → 多车，背后都是”通信 + 相对定位”；
4. 决策状态机不可或缺：题目里越来越多”识别完再决定往哪走”的环节，背后必然是一套状态机（这套东西《状态机与整车软件》会专门讲）。

那 2025 / 省赛，该往哪押？

押题这事，没人能打包票，但顺着上面这条线，方向是可以判断的。多份器件清单分析和复盘给出的较高概率方向是：

• 复杂小车系统：小车 + 摄像头 + 云台 + 激光笔 + 感光纸绘图这类复合系统；或者”视觉循迹 + 精确停靠 + 双车 / 多车协同”的组合；
• 主控大概率延续 TI MSPM0 系列（M0G3507）。2024 起电赛主推 TI 平台，这个惯性短期内不会变；
• 视觉模块偏好紧凑型：因为车体尺寸卡得严，MaixCam 这类小模块更吃香；
• 可能融合更多模态：摄像头 + 超声波 + 雷达；目标跟踪场景会用到卡尔曼滤波去抖。

押对了方向，下一步就是动手搭车。三个人怎么分工、主控为什么选 TI MSPM0、怎么搭一套”算法和芯片解耦”的代码框架，让你在 STM32 上练通的东西能整段平移过去——这些就是整车搭建与代码框架那一篇要解决的事。

本文是 「从 0 到 1 带你打电赛 · 小车电控篇」 系列（共 12 篇）第 3 篇。

1. 第1篇 · 拿奖逻辑：把比赛拆成小目标
2. 第2篇 · 赛题进化史与押题
3. 第3篇 · 整车搭建与代码框架（本篇）
4. 第4篇 · 电机驱动与电源地基
5. 第5篇 · 感知：灰度/电磁/编码器/IMU
6. 第6篇 · PID 入门：搞懂 P/I/D
7. 第7篇 · PID 进阶：串级+工程补丁
8. 第8篇 · PID 调参实战(核心)
9. 第9篇 · 进阶控制：几时该上
10. 第10篇 · K230 视觉与通信协议
11. 第11篇 · 状态机与整车软件
12. 第12篇 · 现场作战+避坑+开源

前两篇我们把”这比赛在比什么””出题人爱出什么”聊清楚了。从这一篇开始，我们正式动手——但先别急着掏出电烙铁。一支队伍的上限，往往不是某个调参的瞬间决定的，而是开赛前那个”0 阶段”就埋下的：人怎么分工、主控选谁、代码骨架怎么搭。

这就好比盖楼。地基和承重结构得在挖第一锹土之前想清楚，等楼盖到一半才发现柱子位置不对，那不是修修补补能解决的，是要拆了重来的。而电赛只有四天三夜，没有”重来”的预算。这一篇我们就把这套地基打牢，让你后面写算法、调参数的时候，能做到”现场只改参数，不改架构”。

三个人，怎么分这摊活

小车赛道的队伍通常是三个人。最舒服、也最常见的分工是这样切的：

• 硬件 / 机械：负责选电机、画 PCB 或飞线、电源、机械结构、传感器布板与焊接。这个人手要稳、要懂模拟电路，是整车能不能”通电不冒烟”的第一道关。
• 电控软件：负责主控固件——电机驱动、PID、循迹、状态机、各路通信的整合。这是把所有零件”捏成一辆会跑的车”的人。
• 视觉算法：负责摄像头那一摊——巡线、识别色块/二维码/数字，把图像处理成一个个”结论”发给主控。

这里先埋个伏笔：视觉和主控之间”只传结论不传整张图”的协议怎么设计，是《视觉与通信》一篇的重头戏，这里点到为止。

主控选谁：为什么 2024 年起电赛主推 TI 的 MSPM0

如果你是 2023 年以前打电赛，主控基本就是 STM32。但从 2024 年开始，电赛官方主推的是 TI 的 MSPM0G3507，尤其是智能小车这类题（比如 2024 年 H 题”自动行驶小车”）。很多人第一反应是”我 STM32 还没玩明白，又要换芯片？”——别慌。这俩的关系，我们后面会讲透：STM32 是你练手的”训练场”，MSPM0 是你上场的”主战场”，而且练通的算法能整段搬过去。

先看 MSPM0G3507 这颗芯片本身。它是一颗 Arm Cortex-M0+ 内核、主频 80MHz 的”混合信号”单片机。所谓”混合信号”，意思是它不只擅长跑数字逻辑，模拟外设也特别强——这正好戳中小车的需求。核心规格：

一个必须提前知道的”反直觉硬伤”：硬件编码器接口只有一路

这是 MSPM0 相对 STM32 最大的坑，选型和布线之前必须想清楚，否则到现场才发现就晚了。

STM32 几乎每个定时器都能配成编码器接口模式，你想测两个电机的转速，随便挑两个定时器就行。但 MSPM0G 全芯片只有一个定时器（常说的 TIMG8）硬件支持 QEI 正交编码器解码。也就是说，硬件层面你只能”白嫖”一路编码器。

那双电机怎么办？两条路：

• 路线 A（硬件 QEI）：用那唯一一路 TIMG8，硬件自动计数 + 判方向，几乎不占 CPU。这是首选。
• 路线 B（GPIO 外部中断）：A/B 两相各接一个 GPIO，上升沿触发中断，在中断里读另一相的电平判方向，再用一个 20ms 周期的定时器去数脉冲算速度。代价是高转速时容易漏脉冲、把中断占满。

所以双电机的典型方案是：一路走硬件 QEI，另一路退回 GPIO 中断（给它最高优先级），或者上一颗外部计数芯片。

编码器测速本身的原理很直白，就像数脉冲过了几个：车每跑一段，电机转一点，编码器吐出一串脉冲；你每隔固定时间（比如 20ms）数一次这段时间内新增了多少脉冲，数得越多说明跑得越快。A、B 相脉冲的先后顺序，还能告诉你是前进还是后退。具体的编码器接法和 IMU 融合，我们留到《感知：灰度/电磁/编码器/IMU》一篇细讲。

开发环境：SysConfig、IDE 和两种下载方式

SysConfig：TI 版的”装修图纸软件”

TI 给 MSPM0 配了一个图形化配置工具叫 SysConfig，作用相当于 STM32 玩家熟悉的 CubeMX。

它就像装修前用图纸软件拖拽布局：你在图上点哪个插座（引脚）接什么电器（外设），软件自动帮你把”水电图”（一个叫 ti_msp_dl_config.h 的头文件，里面有 SYSCFG_DL_init() 初始化函数）画好，你不用自己一根根去配寄存器。配 PWM 在 TIMER-PWM 分类下、配编码器在 TIMER-QEI、配 ADC 在 ADC12、配运放在 OPA。配完它会生成一堆实例宏，比如 PWM_0_INST、QEI_0_INST、UART_0_INST，你代码里直接用这些名字就行。

配 PWM 的时候，有个关系要记牢：

$$\text{频率}=\frac{\text{时钟}}{\text{分频}\cdot(\text{period}+1)}$$

向上计数时，占空比 $=\frac{\text{CCR}}{\text{period}+1}$。立创开发板的电机驱动例程用 80MHz 时钟、period 设 10000，实测出来约 8kHz。运行时动态改占空比就一行：

// 设置占空比 (向上计数: duty = CCR/(period+1))
DL_TimerG_setCaptureCompareValue(PWM_0_INST, 1000, DL_TIMER_CC_1_INDEX);
// 如果 SysConfig 里没勾 "Start Timer"，需要手动启动一次
DL_TimerG_startCounter(PWM_0_INST);
// 读编码器 QEI 计数
uint32_t cnt = DL_Timer_getTimerCount(QEI_0_INST);

注意 MSPM0 的 API 全是 DL_ 前缀（DriverLib 的意思），这和 STM32 的 HAL_/LL_ 不一样。再记两个小口诀：PWM 占空比建议别超过 95%；改 PWM 频率（改 period）会同时改变占空比的分辨率（period 越小，占空比能分的档越粗），要兼顾。PWM 频率电赛常用 8kHz 到 32kHz 这个区间，低于 20kHz 左右电机会有可闻的”啸叫”，想安静点就往高了选。

IDE：CCS / Keil / IAR 怎么挑

• CCS：TI 官方的，免费，基于 Eclipse，内置 SysConfig，配套最全。新手最省心。
• Keil MDK：电赛圈最主流，因为大家生态熟、学校积累多。但要注意版本——需要 uVision v5.38a 以上 + AC6 编译器 v6.16 以上，版本太旧装不上 MSPM0 的支持包。
• IAR：也支持，用的人相对少。
• VSCode：它本身不是官方 IDE，但社区常用 VSCode + Keil（靠插件）或 VSCode + CMake + GCC 来获得更现代的编辑体验，编译下载还是靠 Keil 或命令行。

一句话：图省心、从零起步用 CCS；要沿用学校积累、跟队友保持一致就用 Keil。

下载：SWD 仿真器 vs BSL 串口

这俩的区别，可以类比成上网方式：

• SWD（专线宽带）：用板载的 XDS110 或外接 DAP-Link / J-Link，四根线（SWCLK / SWDIO / GND / 3V3）。不仅能下载，还能实时看程序在干嘛、打断点单步调试。开发期首选。
• BSL 串口（手机热点应急）：用 TI 的 UniFlash 工具，通过 USB 转串口把程序灌进去，没仿真器也能用，但只能灌不能调。

BSL 这条路有两个非常容易翻车的细节：

结论很简单：开发期老老实实用板载 XDS110 或 DAP-Link 走 SWD，能调试又省事；BSL 留作”手头没仿真器”时的应急手段。

重头戏：让”算法和芯片解耦”的分层框架

到这里，才是这一篇真正的核心。前面铺垫了这么多，就是为了引出一个问题：STM32 练手、MSPM0 上场，凭什么练通的算法能整段搬过去？

答案不在芯片，在代码架构。

为什么要分层

设想一下，如果你的 PID 函数里直接写满了 HAL_GPIO_WritePin(...) 这种 STM32 专属的芯片 API，那换到 MSPM0 的时候，整个 PID 函数都得跟着改——因为它和具体芯片”焊死”在一起了。这就是没分层的下场：换芯片 = 满地找改 = 平移变重写。

分层架构的思路，像点外卖：

• 你（App 应用层）：只对着 App 下单，决定”我要吃啥、车要怎么跑”，从不进后厨。这里放状态机和决策。
• App 平台（中间件层）：把订单翻译给骑手和商家，承载 PID、滤波、通信协议、元素识别这些和芯片无关的算法。
• 骑手 / 灶台（驱动层 + HAL）：干脏活累活，真正去配寄存器、读写引脚。

换城市（换芯片）时，你点外卖的方式（算法）一字不改，变的只是当地的骑手和店家（驱动层）。这就是”算法和芯片解耦”的本质。

这套范式不是我们瞎编的，它直接借鉴了智能车圈久经考验的逐飞（SeekFree）开源库的分层结构：

一条不能破的铁律

分层能不能起作用，全看一条铁律守不守得住：

逐飞库就是这么干的：设备层（管摄像头/陀螺/屏的初始化）只允许调驱动层的接口，不准碰最底层的芯片 API。这样换 MCU 只改驱动层，中间件和 App 原样平移。

这套库有多能打？同一份逐飞库已经移植到了 RT1064、英飞凌 TC264、STC32，以及 TI 的 MSPM0G3507（对应 2025 TI 板电赛）——上层算法共用，差异全集中在底层驱动。这就是分层解耦价值的活证据。

一个可照抄的目录骨架

落到实处，你的工程目录可以这么切：

project/
├── App/                 # 应用层：你写的核心逻辑
│   ├── fsm.c/h          #   状态机：待命/起步/直道/弯道/路口/停靠/找回/急停
│   └── control_task.c   #   控制环调度：采集→融合→串级PID→输出→保护
├── Middleware/          # 中间件层：芯片无关的算法
│   ├── pid.c/h          #   PID（位置式/增量式）
│   ├── filter.c/h       #   滤波（一阶低通/互补）
│   └── protocol.c/h     #   通信帧解析
├── Driver/              # 驱动层：换芯片主要改这里
│   ├── motor.c/h        #   电机：把"带符号速度"翻译成PWM+方向
│   ├── encoder.c/h      #   编码器读速
│   ├── gray.c/h         #   灰度采集
│   └── uart.c/h         #   串口收发
└── HAL/                 # 芯片相关：DriverLib / 寄存器
    └── (SysConfig 生成的 ti_msp_dl_config.h 等)

关键在于接口的方向：App 调中间件和驱动，中间件和驱动里绝不出现任何芯片专属 API。比如电机驱动这一层，对上只暴露一个”给我一个带符号的速度”的接口，符号决定正反转、绝对值决定 PWM 大小，至于底下怎么配 PWM 寄存器，全藏在驱动层里：

// 中间件层：PID 算出一个带符号输出，完全不知道芯片是谁
int pwm = (int)pid_calc(&speed_pid, target_speed, get_encoder_count());

// 驱动层：把带符号输出翻译成具体的正反转 + PWM（这层才碰芯片）
void motor_set(int pwm) {
    if (pwm > 0)       set_motor(0, pwm);   // 正转
    else if (pwm < 0)  set_motor(-pwm, 0);  // 反转（取绝对值）
    else               stop_motor();
}

pid_calc 这个函数里只有数学，没有一行芯片代码，所以它在 STM32 上调通了，搬到 MSPM0 上一个字都不用改。这就是”练通的算法整段平移”的底气。

STM32 MSPM0 平移心法

很多人迁移时的第一反应是”把每一个 HAL_xxx 逐行翻译成 DL_xxx“。这是最痛苦、最容易错的做法，千万别这么干。

TI 官方在《从 STM32 到 MSPM0 迁移指南》（文档号 ZHCABX9B，能搜到）里给出的标准心法是：先把你的应用逻辑理解透，然后拿一份最接近的 MSPM0 官方例程当骨架，把你的 PID、循迹这些算法层原样搬进去，只重写外设的初始化和读写。

官方给的工具链对照表，迁移时贴在显示器边上很有用：

有几个外设层面的差异，是平移时最容易”反咬”算法层假设的地方，列成清单逐条核对：

• ☐ GPIO 拆成了两块：STM32 一个 GPIO 概念，MSPM0 拆成 GPIO（读写 / 中断）+ IOMUX（引脚复用），配引脚和读写是分开的。
• ☐ 硬件编码器接口只有一路 QEI（前面强调过的硬伤），双电机方案要提前定好。
• ☐ UART 的 FIFO 只有 4 字节（STM32 是 8 字节），高速收发更容易溢出，而且不支持自动波特率检测。
• ☐ UART 中断里不要照搬习惯去调 NVIC_ClearPendingIRQ()——官方教程明确提醒过，照搬 STM32 写法会出问题。
• ☐ 时钟树、NVIC、中断模型和 STM32 不一样，从官方 example 起步能帮你绕开大部分坑。

官方迁移指南把整个流程总结成五步，照着走就行：① 对照产品系列表选定 MSPM0 器件 → ② 订 LaunchPad 开发板（LP-MSPM0G3507）→ ③ 装 IDE + SDK → ④ 软件移植（从最接近的官方例程改起，不是逐行替换 API）→ ⑤ 调试验证。

有哪些现成的模板和库可以站在肩膀上

完全从零搭框架很费时间。下面这几个仓库都是经过电赛验证的，按你的处境挑一个当起点：

• TI 官方 mspm0-sdk：DriverLib + 海量外设例程（GPIO / Timer / PWM / ADC / UART / DMA / OPA 全都有）。这是所有上层方案的底座，也是”从最接近的 example 改起”那个 example 的来源。一手权威，必装。
• ZLC_MSPM0_Peripheral_Library：2024 电赛 H 题一等奖（山大威海）的外设库，编码器、电机（DRV8701E 双路）、舵机 PWM、8 路灰度、IMU、无线串口一应俱全，还附了设计报告和环境配置文档。想看一等奖的完整车软件栈长什么样，看这个。
• PIDCarTemplate-MSPM0G3507：两轮 / 四轮 PID 小车模板，封装好了 Delay / Encoder / Motor / 按键（短按长按双击）/ MPU6050 / OLED / 蓝牙 / 灰度，clone 下来调 API 就能开发。从零起步直接套模板的首选。
• woai66 的逐飞 MSPM0 移植库：把上面讲的逐飞分层库移植到了 MSPM0，对应 2025 TI 板电赛。想要”芯片解耦平移”那套完整范本，看它。
• danshoujieyi/TI-MSPM0G3507：电赛指定板模板，裸机版 + FreeRTOS 版 + RT-Thread 版都有（Keil5 + VSCode）。想上 RTOS 或要 VSCode 工作流的直接用。
• MSPM0-CMAKE-GCC-Template：GCC + CMake 模板，想脱离 Keil、用 VSCode + 命令行现代工作流的首选。

更全的开源仓库点评（含视觉车、平衡车、仿真工具），我们放在收官的《现场作战手册》一篇里集中评注，这里先给够你起步用的几个。

一些选型和架构上的经验之谈

最后几条是过来人趟出来的，写代码之前先记在心里。

调度、控制环时序、状态机怎么把所有模块串成一辆会跑的车，是《状态机与整车软件》那一篇的主题，到时候我们会给出完整的主控制环伪代码和状态图。

把这一篇的地基打牢，你就有了一套”算法写一次、芯片换着用”的框架。但框架终究是个空壳，真正让车动起来的第一步，是让电机听话——电机驱动、PWM 和电源这套电控地基，我们下一篇见。