本文是 「从 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 篇）第 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 篇）第 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 篇）第 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 篇）第 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 篇）第 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 篇）第 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 篇）第 5 篇。

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篇 · 现场作战+避坑+开源

上一篇《电机驱动与电源地基》解决的是”小车的腿能不能听话地动起来”。可问题来了：腿动得再稳，要是脑子不知道”我现在偏左了还是偏右了””我跑多快””车头朝哪个方向”，那也只是一辆瞎跑的车。

这一篇我们就来给小车装上四样”感官”——灰度、电磁、编码器、IMU。它们的共同任务只有一个：给后面的控制环(PID)送上一份又干净又准确的反馈信号。打个比方，PID 是司机，感知层就是司机的眼睛、耳朵和平衡感。眼睛进了沙子，再老练的司机也得撞墙。所以这一篇虽然不讲控制算法，却是整车成败的地基里非常硬核的一块。

我们分四块讲：循迹的两条路线(灰度 / 电磁)、测速度的编码器、测姿态的 IMU。每一块都给你能照抄的算法和代码，最后说一句”路上怎么在它们之间切换”。

一、循迹路线一：灰度——小车最常用的”看路”方式

灰度循迹是绝大多数电赛/智能车小车的第一选择：在车头底部横排一组朝下的光电/灰度传感器，地面是白底黑线，传感器看到黑线就报告”我这儿压线了”。把所有传感器的信息汇总，就能算出”黑线现在偏车身中线多远”。这个偏差，就是喂给转向 PID 的核心输入。

数字量阵列：加权位置法(行业标准算法)

最经典、被全网开源项目反复抄的算法，叫加权位置法，来自 Pololu 的 QTR 传感器库 readLine 算法。它的思路特别好懂：

写成公式就是：

$$\text{position} = \frac{\sum_{i} (i \times 1000) \times value_i}{\sum_{i} value_i}$$

其中 $i$ 是传感器索引。对 8 路传感器，这个值的范围是 $0 \sim 7000$，正中心就是 $(8-1)\times500 = 3500$。这个数随黑线左右移动单调变化，直接拿来当 PID 输入：设定值 setpoint = 3500，误差 error = position − 3500。

下面是改写自 QTR 库的核心代码，数字量、模拟量阵列都能用：

// N 路灰度阵列加权位置法，返回 0~(N-1)*1000，中心 (N-1)*500
// value[i]: 第 i 路校准后读数(压线=高值)，已做归一化
uint16_t readLinePosition(uint16_t *value, uint8_t N) {
    uint32_t avg = 0;   // 加权和 Σ(i*1000*value)
    uint32_t sum = 0;   // 权重和 Σ(value)
    static uint16_t lastPos = 0;
    bool onLine = false;
    for (uint8_t i = 0; i < N; i++) {
        uint16_t v = value[i];
        if (v > 200) onLine = true;        // 判定压线
        if (v > 50) {                       // 噪声门限，>50 才计入加权
            avg += (uint32_t)v * (i * 1000);
            sum += v;
        }
    }
    if (!onLine) {                          // 全丢线：朝上次方向找线(下面细讲)
        if (lastPos < (uint32_t)(N - 1) * 1000 / 2) return 0;
        else return (N - 1) * 1000;
    }
    lastPos = avg / sum;
    return lastPos;                         // PID 输入：error = lastPos - (N-1)*500
}

注意里面两个门限：读数 >50 才计入加权和(滤掉噪声)，>200 才算”真的压线了”。这是 QTR 库的经验值，能让位置计算更干净。

数字量 vs 模拟量：要不要那么精细？

刚才代码里的 value[i] 可以是两种来源：

模拟量有个必做的预处理：归一化。每一路传感器单独记下自己在纯黑、纯白时的最大最小值，运行时把读数折算到 0~100。这能消除各路传感器的个体差异，换场地也只要重测一遍。

// 标定阶段：扫黑白记录每路 min[i]/max[i]
// 运行阶段：归一化到 0~100
uint8_t normalize(uint16_t raw, uint16_t mn, uint16_t mx) {
    if (raw <= mn) return 0;
    if (raw >= mx) return 100;
    return (uint8_t)((uint32_t)(raw - mn) * 100 / (mx - mn));
}

工程四件套：”实验室能跑、赛场翻车”的分水岭

灰度循迹真正拉开差距的，不是那个加权公式，而是下面这四件事。

① 黑白阈值，一定要现场标定。 别用上次的、别用实验室的。赛场的光照、地面材质、纸张反光都和你家不一样，固定阈值一换场就误判。

进阶一点，可以上 OTSU 大津法做动态阈值，免去手动标定：

// 非线性映射，增强黑线区分度(减小传感器个体差异)
adc[a] = pow((adc[a] / 10.0), 3) / 15000;
// OTSU：遍历灰度级找"最大类间方差"对应的灰度作阈值
// 类间方差 = p0 * p1 * (m0 - m1)^2   (p0/p1 两类概率，m0/m1 两类均值)
// 阈值限幅 100 <= threshold <= 800
output[i] = (input[i] <= threshold) ? 1 : 0;     // 二值化

有作者用 OTSU + 三次方非线性映射，在 9 片不同材质、不同光照、带污渍褶皱的场地上测试全部正常，还省掉了上电黑白标定这一步(来源)。

② 全丢线，绝不能把 error 清零。 这是新手最容易踩的命案。

③ 十字/直角路口，必须特判。 经过十字时多路传感器会同时压线，加权位置会突然跳变、把偏差算飞，车就猛打一下方向。处理办法：8 路里有 ≥3 路同时压线就判为路口，进入”路口模式”——这时候不用常规偏差了，而是靠状态机让车直行/盲走固定一段(配合编码器或惯导计程)穿过去，过完再恢复巡线。一位省赛一等奖选手就是这么干的，并强调”换赛道、换车都得重标重调，没有万能参数”(来源)。

④ 安装高度与前瞻，是个三方妥协。 前瞻 = 传感器有效检测点离车头多远。

• 前瞻远 → 高速直道更稳，能提前预判弯道，但急弯容易提前切弯、切到弯内；
• 前瞻近 → 急弯跟得紧，但高速时容易发抖。

经验做法：直道用远前瞻，弯道用近前瞻，可以动态切换(灰度阵列靠”用哪几路算偏差”来实现切换，切换点要带迟滞，否则在直弯交界来回切会抖)。

关于 TCRT5000 红外光电

入门玩具车上最常见的就是 TCRT5000 这种离散红外反射光电。它是红外发射二极管(波长 950nm) + 光敏三极管，集成了日光阻断滤光片(Vishay 官方手册)。关键参数：

• 峰值工作距离 2.5mm，有效范围 0.2~15mm，最佳 0.2~6.5mm；
• 供电 3.3~5V，配 LM393 比较器整形输出数字量。

选型小结：TCRT5000 离散红外便宜、易上手，但单点少、贴地要求严、抗环境光差，适合入门；集成灰度阵列(如 8 路 IIC 数字阵列、模拟量阵列)一致性好、分辨率高、部分带自标定，是电赛/智能车的主流；摄像头方案前瞻最远、能识别十字数字等复杂元素，但算力和调试成本高(留到《K230 视觉与通信协议》一篇展开)。2024/2025 电赛 H 题(自动行驶小车)的主流一等奖方案，就是 8 路灰度 + 惯导(主控 MSPM0G3507)，不是电磁，这点后面会再强调。

灰度循迹的调参口诀(转向环)

偏差信号算出来后，喂给转向 PID。这里先给经验，完整的调参流程见《PID 调参实战》一篇。

有个 Arduino 5 路 PD 循迹的实测起点可以参考：Kp=15、Ki=0、Kd=200、基础速度 200(PWM 0~255)，5.14m 的赛道跑约 5 秒(来源)。

还有一条容易被忽视：偏差信号要先低通滤波再算微分。灰度原始读数有抖动，直接微分会被 Kd 放大，车就发抖。经验做法：

adc_err = 0.4 * err + 0.6 * adc_err;   // 一阶低通，新值权重 α≈0.3~0.5

注意滤波别太狠：α 太小会引入滞后，让弯道响应变慢——这是前瞻和滤波之间的又一个权衡。

二、循迹路线二：电磁——蒙眼跟着 20kHz 小调走

有些赛题(尤其智能车竞赛电磁组)不是白底黑线，而是在赛道中心埋一根漆包线，通上 20kHz、约 100mA 的正弦交变电流，产生交变磁场。车上用工字电感去感应这个磁场——离导线越近，感应出的电压越大。

电磁循迹在电赛里用得不算多(主要是智能车竞赛电磁组的常态)，但思路很经典，而且 TI MSPM0 芯片在这上面有独特优势，值得了解。

信号链：从 30mV 微弱交流到一个能用的数

单个 10mH 工字电感在离线上方 15~20cm 处感应出的原始信号，只有大约 30mV 的 20kHz 小交流——这么弱、这么高频，单片机根本没法直接读。必须走完整的四级信号链：

1. LC 并联谐振选频：只放大 20kHz，抑制其它频率的干扰。10mH 电感配 6.8nF 电容，谐振频率约 19.3kHz(理论上 20kHz 对应 6.33nF，工程上取就近标称值 6.8nF，刻意略低一点适配寄生电容与公差)。
2. 运放放大约 100 倍：把 30mV 抬到伏级(STM32 不超 3.3V)。
3. 二极管检波(常用肖特基 BAT54S)：把 20kHz 交流的包络/峰值整流成直流。
4. RC 低通滤波：平滑后送 ADC。

核心算法：差比和 (L−R)/(L+R)

电感读到值之后，最关键、最该记住的算法就是差比和：

$$\text{偏差} = \frac{L – R}{L + R}$$

为什么不直接用 L−R？因为整体场强会漂移——电流波动、不同赛道，会让所有电感的读数整体涨 10%，这时候位置没变，L−R 却跟着变了。而差比和的分子分母同比例缩放，比值不变，所以偏差只反映位置，不受幅值影响。

工程上还会先把每个通道归一化到 0~100(value/max×100)，方便统一设阈值、识别环岛/十字等特殊元素。下面是真实电磁组代码里的双重差比和：

// 归一化(每通道 value/max*100)
Left_Adc  = (adc_deal_last[LEFT_1]*100) / adc_max[0];
Right_Adc = (adc_deal_last[RIGHT_1]*100) / adc_max[1];
// 双重差比和求偏差 AD_Bias
AD_Bias = ((Left_Adc - Middle_Adc)*100/(Left_Adc + Middle_Adc))
        - ((Right_Adc - Middle_Adc)*100/(Right_Adc + Middle_Adc));

电感布局：成绩的隐形变量

电感怎么摆，直接影响直道稳不稳、弯道灵不灵：

布局要点：相邻电感间距 ≥2cm，避免互感串扰。

MSPM0 的独门优势：片上运放

前面那条信号链里，”运放放大”通常要在板外焊 LM358/OPA4377 之类的运放。但 TI MSPM0 芯片内部就自带运放——比如 MSPM0G3507 含 2 个 OPA，MSPM0L13xx 含 2 个零漂斩波运放 + 1 个 GPAMP，可编程增益(PGA)1~32 倍(单级不够可两级 cascade)，输出能直连片上高速 12 位 ADC。

这意味着电磁前端的选频信号放大可以做进芯片里，省掉外置运放，减 BOM、减焊接、减板上噪声。零漂斩波运放尤其适合这种微弱信号(低失调、低 1/f 噪声)。配置用 TI 的 SysConfig 图形化完成，官方有 opa_signal_chain_to_adc 等例程。不过要注意：MSPM0 跑纯电磁的完整开源还比较少(多为灰度)，建议自己验证片内运放增益够不够，不够就级联或再外置一级。

电磁的几个高频坑

三、编码器：知道自己跑多快

循迹解决了”往哪走”，编码器解决”跑多快”。增量编码器输出 A、B 两路正交方波(相位差 90°)，转得越快、脉冲越密；正转反转，A、B 的超前关系相反。

首选读法：定时器编码器模式

STM32 的定时器有个硬件”编码器模式”，强烈推荐用它：硬件自动加减计数、自动判方向，CPU 几乎零开销。

在 CubeMX 里把 TIMx 的 Encoder Mode 设成 “TI1 and TI2”(即 4 倍频，Encoder Mode 3)，Prescaler = 0，ARR 设 65535(16 位)或 0xFFFFFFFF(32 位定时器，强烈推荐用 32 位的 TIM2/TIM5 防溢出)。

读速度的代码非常简洁——每个固定控制周期(常用 5ms 或 10ms)读一次计数差值：

// CubeMX: TIMx -> Encoder Mode = "TI1 and TI2"(4倍频), Prescaler=0, ARR=65535/0xFFFFFFFF
HAL_TIM_Encoder_Start(&htim2, TIM_CHANNEL_ALL);   // 启动编码器接口

// 每个固定控制周期(5/10ms)调用一次，返回"单位周期脉冲数"作速度反馈
int16_t Encoder_GetSpeed(void) {
    static int16_t last = 0;
    int16_t cur   = (int16_t)__HAL_TIM_GET_COUNTER(&htim2); // 读计数
    int16_t delta = cur - last;   // signed 差值自动吃掉 65535/0 回绕(单周期增量<32767)
    last = cur;
    return delta;                 // 正/负即正反转，数值即速度反馈
}

关键心法：单位周期脉冲数，直接当速度用

很多新手卡在”怎么把脉冲换算成 m/s”。其实不用换算——那个 delta(单位周期内的脉冲数)本身就能直接当速度反馈喂进 PID。

如果报告里需要物理速度，再换算也不迟：

$$\text{RPM} = \frac{\Delta CNT \times (1000 / \text{period\_ms})}{\text{PPR} \times 4 \times \text{减速比}}$$

线速度再乘轮周长即可。采样周期是个权衡：太短，ΔCNT 太小，量化噪声大；太长，响应慢。智能车常用 5ms 或 10ms(弱一点的电机推荐 10ms)。

还有一种读法是用 EXTI 外部中断在 A/B 边沿软件计数(M 法数脉冲 / T 法测间隔)，更灵活，但占 CPU、高速易丢脉冲。结论：有硬件编码器接口时优先用定时器模式，EXTI 只在引脚/定时器不够时备选。

四、IMU：给小车装上平衡感和方向感

IMU(常用 MPU6050)是六轴传感器：三轴加速度计 + 三轴陀螺仪。它能告诉小车两件事——姿态(Pitch/Roll，平衡车直立要用)和航向(Yaw，走直线锁方向要用)。但这两件事的难度天差地别。

姿态融合：互补滤波(必会)

加速度计和陀螺仪各有各的毛病，得互补着用：

• 加速度计：能算出绝对的倾角，但噪声大、抖；
• 陀螺仪：积分出来的角度很平滑，但会慢慢漂移。

互补滤波公式：

$$\text{angle} = \alpha \times (\text{angle} + \text{gyro} \times dt) + (1-\alpha) \times \text{acc\_angle}$$

$\alpha$ 取 0.95~0.98(陀螺权重高)。加速度算角：$\text{pitch} = \text{atan2}(a_y, \sqrt{a_x^2 + a_z^2})$。代码：

// 一阶互补滤波：融合加速度(绝对但抖)与陀螺(平滑但漂)，求 Pitch/Roll
// alpha=0.98(陀螺权重)，dt=控制周期(秒)
float comp_pitch = 0;
void IMU_Update(float ax, float ay, float az, float gy, float dt) {
    float acc_pitch = atan2f(ay, sqrtf(ax*ax + az*az)) * 57.2958f; // 加速度算角(度)
    comp_pitch = 0.98f*(comp_pitch + gy*dt) + 0.02f*acc_pitch;     // 互补融合
}

进阶可以上一阶卡尔曼滤波(平衡车经典 TKJ 版)，效果更平滑，标准参数 Q_angle=0.001、Q_bias=0.003、R_measure=0.03、dt=0.005~0.01。它本质上就是”会自动调权重的互补滤波”——发现加速度计这会儿可信就多听它，发现它在抖就少听它。代价是计算量大。对资源受限的单片机，互补滤波通常已经够用，追求极致平滑再上卡尔曼。

Yaw(航向)：六轴 IMU 的一个大坑

姿态(Pitch/Roll)有加速度计当绝对参考，能纠偏。但 Yaw 不行——水平面内的旋转，加速度计提供不了任何参考(重力始终竖直)。所以 Yaw 只能靠陀螺 Z 轴积分：yaw += gyro_z * dt，必然随时间漂移。这是六轴 IMU 的固有局限(想要绝对航向，得上九轴加磁力计，或者用外部基准纠偏)。

对策有两步。

第一步：开机静止采零偏。 陀螺仪静止时本该读 0，但实际总有个固定的偏心读数。上电后让车绝对静止，采 N 次(常 500~2000，1000 次很常见)陀螺 Z 读数求平均当零偏，运行时每个读数都减掉它。

// 开机静止采陀螺 Z 轴零偏 + 运行时积分 Yaw(相对航向)
float gz_bias = 0, yaw = 0;
void Gyro_CalibZ(void) {            // 上电后车保持静止时调用
    float sum = 0;
    for (int i = 0; i < 1000; i++){ sum += MPU_GetGyroZ(); HAL_Delay(1); }
    gz_bias = sum / 1000.0f;        // 零偏 = 静止读数均值
}
void Yaw_Update(float dt){          // 每个控制周期调用
    float gz = MPU_GetGyroZ() - gz_bias;   // 去零偏
    yaw += gz * dt;                 // 积分得相对航向(短时漂移可忽略)
}

第二步：走直线用”相对航向”，随时重置。 既然绝对 Yaw 会漂，那就不依赖它的绝对值——每段直线起步时把当前 yaw 清零当目标，航向误差 err = 0 − yaw 做 PID，输出叠加到左右轮差速：

// 走直线锁航向：起步时 yaw=0(清零当目标)，err = 0 - yaw，差速纠偏
// out = Kp*err - Kd*gz;   pwm_L = base + out;   pwm_R = base - out;

注意上面那行的 D 项直接用了陀螺角速度 gz(对测量微分，比对误差微分更干净、抗扰)。转 90°：把目标航向加/减 90，闭环自动转到位后再清零，进入下一段直线。再高级一点可以做串级：外环用航向角锁朝向、内环用角速度求跟手——不过对入门小车，上面这套单环 PD 已经够稳。

五、把感官接到一起：分工、串级与切换

四样感官各管一摊，整车里它们这样配合：

记住两条分工原则(串级双环的落地代码与调参顺序，见《PID 进阶》和《状态机与整车软件》两篇)：

• 速度环(编码器反馈)用增量式 PID——只输出 ΔPWM、自带积分、无饱和切换冲击，适合连续调速；
• 方向/航向环(灰度/电磁/IMU 反馈)用位置式 PID(实践中多为 PD)——适合”锁住某个朝向/位置”。

至于”什么路段用哪个感官”，核心思路是分工 + 兜底：

• 巡线主要靠灰度/电磁给偏差；
• 直道锁航向用 IMU 的相对航向，防止灰度细微抖动累积成跑偏；
• 十字/丢线时灰度偏差不可信，切到 IMU + 编码器”盲走”几格穿过去；
• 一旦灰度长时间丢线，有外部基准(重新抓到的灰度线)就纠偏、没有就靠惯导兜底——绝不让 error 清零直冲。

感官齐了、反馈干净了，下一步就是真正让控制环动起来——从最基础的”把一个电机的速度调稳”开始，一次搞懂 P、I、D 各自在管什么。我们下一篇 PID 入门见。

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

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 也照着教程抄了，可车一上场要么嗡嗡乱叫不走直线，要么跑着跑着自己复位重启，再要么瓷砖地上飞快、一到赛场木地板就趴窝？

十有八九，问题不在你的算法，而在脚下这块”地基”——电机、驱动和电源。

这是赛后总结里被反复念叨的一句话：硬件不过关，软件再强也救不回来。控制算法是建在反馈信号和稳定供电之上的，地基一塌，上面盖得再漂亮也是空中楼阁。所以这一篇我们不碰高深的控制理论，专心把三件事讲透：电机怎么选、驱动怎么接、电源怎么供。

先认识小车的”肌肉”：电机怎么选

电机就是小车的肌肉。肌肉不行，神经系统（你的控制算法）指挥得再精妙也白搭。电赛小车上最常见的是两类带编码器的直流减速电机。

N20 和 GA12-N20：两个常客

N20 是最小巧的那一类，微型直流减速电机，适合轻量级小车。

• 额定 3-6V（工作范围 2-9V），体积小、重量轻
• 带霍尔编码器，电机轴典型 7 PPR（每转 7 个脉冲）
• 通常是 6 线制：电机两根（M+ / M-）、编码器供电两根（VCC / GND）、编码器信号两根（A / B 两相）

这里有个新手最容易接错的地方：编码器的供电（3.3-5V 逻辑电平）和电机的供电（走功率轨）是分开的两路，别图省事接到一起。

举个具体型号让你有数：Waveshare 那款 12V/200rpm 的 N20，减速比 1:150，电机轴 7 PPR，那么输出轴每圈就是 $7 \times 150 = 1050$ 个脉冲，再经过后面要讲的四倍频，每圈能数到 4200 个计数。这个分辨率对测速来说相当够用了。

GA12-N20 是它的”健身版”——同样是 12mm 直径，但换成了金属齿轮箱，更耐用、扭矩更大。

• 减速比可选范围极广，1:3 到 1:1000 都有，常用的是 1:30 / 1:50 / 1:100 / 1:150
• 拿 GA12-N20-0100 举例：DC 12V、空载 100rpm、负载 80rpm、额定力矩 2kg·cm、额定电流 300mA
• 同款电压下转速参考：6V 约 95rpm，3V 约 47rpm（基本随电压线性变化）

N20 塑齿轻便但扭矩弱，GA12 金属齿耐造扭矩大。需要爬坡、负载重、或者怕齿轮磨损的车，优先 GA12。

减速比怎么选：像自行车换挡

减速比这个参数最让人犯迷糊，其实一个比喻就懂了。

选型的思路是从你的目标反推，分两路算：

1. 看顶速：目标线速度 = 轮子周长 × 输出轴每秒转数。先定下你想要的最大线速度（比如 1.5 m/s），再用轮径折算出需要的输出轴 rpm，倒推减速比。
2. 看扭矩：车有多重、要不要爬坡、起步要不要猛，决定了你需要多大扭矩。负载重、要爬坡就往大减速比走。

编码器：电机的”码表”，靠它测速

编码器是装在电机尾部的转速传感器，相当于自行车的码表。它输出 A、B 两相方波，相位差 90°。我们用 STM32 定时器的编码器模式来读它，并且做正交四倍频。

四倍频是什么意思？AB 两相每个周期里有 4 个跳变沿（A 上升、B 上升、A 下降、B 下降），我们每个沿都数一次，分辨率就翻了 4 倍。所以：

$$\text{每圈计数} = \text{PPR} \times \text{减速比} \times 4$$

测速的办法很直接：在固定周期的定时器中断里，读一次 TIMx->CNT，算出这段时间里计数增加了多少（Δ脉冲），就是当前转速的反馈值。低速场景脉冲太少不准，可以用 M/T 法改进，但入门阶段固定周期测增量就够了。

驱动芯片：给肌肉接上”功放”

MCU 的 GPIO 引脚只能输出几毫安的小电流，电机一启动就要几百毫安甚至几安培——直接连上去，引脚瞬间烧掉。中间必须有个”功率放大器”，这就是驱动芯片。

驱动芯片内部的核心结构是 H 桥——四个开关搭成的电路。

选型：按电机的堵转电流分档

选驱动芯片，最关键的指标是电机堵转电流（电机被卡死时的最大电流，远大于正常工作电流）。芯片的电流能力必须扛得住堵转，否则一卡就烧。下面这张表是电赛圈里的主流选择：

缺货时，国产的 GC8871、BDR 系列可以做 TB6612/同类的平替。

小电机选 TB6612，大电机选 DRV8701，这是两条最常走的路。下面分别说说它俩。

TB6612：小电机的省事之选

TB6612 把”指挥”和”开关”都集成在一颗芯片里，外围简单，特别适合 N20 这类小电机。引脚和真值表必须记牢：

• PWMA / PWMB：调速（接 PWM 信号）
• AIN1 / AIN2 / BIN1 / BIN2：控制方向
• STBY：待机脚，必须置高芯片才工作
• VM：电机电源；VCC：逻辑电源（2.7~5.5V）

真值表（以 A 通道为例）：

下面是 STM32 HAL 库下 TB6612 调速 + 换向的核心代码，PWM 配成 24kHz：

// 占空比 = (Pulse+1)/(ARR+1)
// 72MHz 主频, Prescaler=2, ARR=999  ->  PWM 频率 = 72M/3/1000 = 24kHz
HAL_TIM_PWM_Start(&htim3, TIM_CHANNEL_2);          // 启动 PWM 通道

// 设置转向：BIN1=1, BIN2=0 -> 正转
HAL_GPIO_WritePin(BIN1_GPIO_Port, BIN1_Pin, GPIO_PIN_SET);
HAL_GPIO_WritePin(BIN2_GPIO_Port, BIN2_Pin, GPIO_PIN_RESET);

// 改占空比就是调速：pulse 越大越快（0 ~ ARR）
__HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_2, pulse);

代码思路参考 喵呜实验室的 TB6612 教程。

这里引出一个非常好用的编程抽象：带符号速度。我们希望上层 PID 算出一个数，正数就前进、负数就后退、绝对值就是快慢，不用每次都手动管方向。封装一下：

#define ARR_MAX  999      // 与 PWM 的 ARR 对应, 占空比上限

// speed: 带符号速度, 正前进负后退, 范围 [-ARR_MAX, ARR_MAX]
void Motor_SetSpeed(int16_t speed)
{
    if (speed >= 0) {
        // 正转
        HAL_GPIO_WritePin(BIN1_GPIO_Port, BIN1_Pin, GPIO_PIN_SET);
        HAL_GPIO_WritePin(BIN2_GPIO_Port, BIN2_Pin, GPIO_PIN_RESET);
    } else {
        // 反转
        HAL_GPIO_WritePin(BIN1_GPIO_Port, BIN1_Pin, GPIO_PIN_RESET);
        HAL_GPIO_WritePin(BIN2_GPIO_Port, BIN2_Pin, GPIO_PIN_SET);
        speed = -speed;                               // 取绝对值当占空比
    }
    if (speed > ARR_MAX) speed = ARR_MAX;             // 输出限幅, 别超 ARR
    __HAL_TIM_SET_COMPARE(&htim3, TIM_CHANNEL_2, speed);
}

方向 GPIO + 占空比 = 带符号速度，这个封装一做，后面写 PID 的人就只管甩一个数过来，世界清静了。

DRV8701：大电流场景的指挥官

当你用 RS380 这类大电机、或者要跑高速大扭矩时，TB6612 那点电流就不够看了。DRV8701 是另一种思路——它本身不直接驱动电机，而是一个”栅极驱动器”：

它的几个亮点：

• 宽压 6.5~45V，免升压：直接吃高压电池，不用额外的 BOOST 升压电路，也就避免了升压带来的干扰（不同手册标注略有出入，这里取保守的 6.5~45V）
• 内置电流采样，放大增益 $A_v = 20\,\text{V/V}$
• 定时关断斩波限流：能给电机设一个电流上限，堵转时自动斩波保护
• 支持 100% 占空比

它有两种工作模式，接线时要分清：

• E 型：PH/EN 模式。EN 进 PWM（调速），PH 给方向。一路 PWM 一路电平，省 IO。
• P 型：双 PWM 模式。IN1/IN2 各接一路 PWM。

斩波限流的电流上限怎么算：

$$I_{chop} = \frac{V_{REF}}{A_v \times R_{sense}}$$

其中 $A_v = 20\,\text{V/V}$ 是内部放大增益，$R_{sense}$ 是你外接的采样电阻，$V_{REF}$ 是你设的参考电压。

立创开源上有一个现成的参考设计 smart-car-drv8701-dual-drive（yy28），6-45V 宽压、堵转仍工作、信号与地平面隔离，可以克隆工程改板用（注意页面暂无 BOM，MOS 和采样电阻要自己核对）。

L298N 为什么劝退

你可能在很多老教程里见过 L298N，但正式比赛真心不推荐：

• 它是 BJT 老工艺，导通时饱和压降大，发热严重，必须挂大散热片
• 没有寄生体二极管，得外接 8 个续流二极管（电机是感性负载，关断时会产生反向电压尖峰，需要二极管给它一条泄放路径），电路又乱又占地方
• 效率低，同样的电池跑不了多久

相比之下，TB6612、DRV8833、A4950 这些 MOS 方案导通损耗低、自带续流、效率高。L298N 只在你手头恰好有现成模块、临时凑合时用用，别当主力。

PWM 调速：为什么频率定在 15~20kHz

我们一直说”占空比调速”，到底什么原理？

占空比的定义很简单：

$$\text{占空比} = \frac{T_{on}}{T_{on} + T_{off}}$$

那频率（一秒钟开关多少次）选多少？这里有个非常实际的考量——人耳的听觉范围是 20Hz ~ 20kHz。

如果你的 PWM 频率落在这个范围内（比如常见的几 kHz），电机线圈会跟着这个频率机械振动，你就听到了刺耳的”嗡嗡”啸叫声。把频率推到 20kHz 以上，超出人耳听觉，世界瞬间安静。

但也不是越高越好：

一个特别要注意的特殊情况，留给电磁循迹组：

如果你用的是互补 PWM（上下桥臂用一对互补信号驱动），还有一条铁律：

电源树：给整车”供血”

到这儿肌肉（电机）和功放（驱动）都有了，最后一块地基是供电。电源问题最隐蔽——它不会让你的代码报错，而是让你的车在最关键的时候莫名其妙复位、串口乱码、ADC 跳变，查到怀疑人生。

电源树的标准结构

一条典型的供电链路是这样分级的：

几条要点：

1. 电池直供电机功率轨（VM）：电机要大电流，让它直接吃电池，别经过 DC-DC（DC-DC 带不动那么大瞬时电流）。
2. DC-DC（Buck）降到 5V：给舵机、5V 传感器用。TPS 系列是常见选择，效率高。
3. MCU 务必走独立 LDO 降到 3.3V。LDO 噪声低、外围简单、输出干净，特别适合给敏感的 MCU 和 ADC 基准供电（缺点是压差大时效率低、发热，所以只用它做最后一级精滤，不要拿它扛大电流降压）。

地线规划：单点共地

电源里最玄学、也最容易翻车的，是地线。

具体怎么做：电机功率地和 MCU/传感器控制地各自单独走线，最后在电源入口附近用一个点（0Ω 电阻或磁珠）汇接到一起。

VM 并大电容：给电机配个”水箱”

电机是感性负载，启动、堵转、换向的瞬间电流会猛地飙升，把 VM 电压拽下去一大截。

所以驱动 VM 引脚要并两种电容：

• 大电解电容（bulk，数十~数百 uF）：抗电机启动/换向时的电压跌落，做能量缓冲。选低 ESR 的，就近放在驱动 VM 引脚旁。
• 小陶瓷电容（0.1uF）：就近滤高频毛刺。

低电量电压补偿：让车后半程不掉速

最后一个常被忽略、却能直接拉开名次的细节。

锂电池从满电到亏电，电压能跌 20% 以上。问题来了：你的 PID 输出的是占空比，占空比固定时，电压越低、给电机的实际平均电压就越低、转速就越慢。

做法很简单——用 ADC 实时采电池电压，把占空比按比例放大：

$$\text{实际占空比} = \text{期望占空比} \times \frac{V_{\text{标称}}}{V_{\text{实测}}}$$

电池越亏（$V_{实测}$ 越小），补偿系数越大，等效给电机的平均电压就恒定了。

// V_nominal: 标称电压(常数); V_batt: ADC 实测电池电压(已滤波)
float comp = V_nominal / V_batt;       // 补偿系数, 电压越低系数越大
duty_out = duty_target * comp;
if (duty_out > DUTY_MAX) duty_out = DUTY_MAX;   // 限幅, 别超 100%

代码思路参考 电压补偿的实现。

一点点剧透：地基之上是 PID

讲到电压补偿，已经摸到控制环的门口了。这里先埋个伏笔，把和地基直接相关的几条结论给你（详细的原理和调参后面几篇专门讲，这里不展开）：

• 速度环用增量式 PID：它只输出”控制增量”（油门加一点/松一点），正反向切换平顺、对积分天然限幅，适合电机连续调速。
• 方向环/位置环用位置式 PID：直接算绝对量（方向盘打到 30 度这个位置），精度高，适合一步到位的定位。
• 串级（双环）：外环管方向/位置，内环管速度，外环输出作为内环目标，外环周期比内环慢 2~5 倍。
• 控制周期：速度环 5~10ms（100~200Hz）起步，方向/外环 10~50ms，用定时器中断保证周期严格恒定。
• 铁律：必做积分限幅 + 输出限幅；切换 PID 模式或电机换向时，一定要清积分项，否则积分饱和（windup）会让输出冲顶、响应迟滞。
• 调参口诀：先 P 后 I 再 D。

收尾：地基自检清单

照着下面这几条逐项过一遍，你的电控地基基本就立住了：

• ☐ 电机减速比按”目标线速度 + 爬坡扭矩”反推，动力留余量
• ☐ 编码器和电机供电分两路；机械安装同心、固定牢、无过盈摩擦
• ☐ 驱动芯片按堵转电流选型：小电机 TB6612，大电流 DRV8701，别用 L298N 当主力
• ☐ TB6612 记得给 PWM、STBY 置高；把方向 + 占空比封装成”带符号速度”
• ☐ PWM 频率 18~20kHz 起步，电磁组干扰严重就压到 13-15kHz；互补 PWM 必加死区
• ☐ 电源树分级：电池直供 VM，DC-DC 降 5V，MCU 走独立 LDO 降 3.3V
• ☐ 功率地与控制地分开走线，单点共地，别绕成地环路
• ☐ 驱动 VM 并大电解（低 ESR）+ 0.1uF 陶瓷，电机端加 TVS
• ☐ 上电池电压补偿（ADC 滤波 + 占空比限幅），低压报警降速
• ☐ 务必在赛场同款地面上调参

地基稳了，软件才有发挥的余地。但光有”肌肉”还不够——小车还得有”眼睛”和”平衡感”，才知道自己在哪、有没有跑偏。下一篇我们就来给小车装上感知系统：灰度、电磁、编码器和 IMU。

本文是 「从 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 和电源这套电控地基，我们下一篇见。