企业官网建设流程全解析

简介：基于STM32F407VET6的麦克纳姆轮小车PID控制程序，定位为嵌入式控制与智能车竞赛的实用工程参考。面向电子设计初学者及进阶开发者，解决四轮全向移动平台的精确速度与姿态控制问题。程序通过串口接收上位机指令，精简显示与遥控等非核心功能，聚焦PID闭环算法在电机调速上的实际落地。

压缩包共188个文件，约4.48MB，以C源文件与头文件为主，同时包含Keil工程配置（uvprojx）、编译中间文件（o、crf、d）及最终hex烧录文件，结构完整，便于对照学习源码和直接烧录验证。已有8285人浏览学习。

资源详细展开PID比例、积分、微分三个环节的整定过程，配合STM32F407VET6的FPU浮点运算、定时器中断及PWM输出，实现麦克纳姆轮差速控制与全向移动。读者可从中理解串口中断解析、电机驱动电路接口、参数调节思路和嵌入式调试方法，是结合理论与实践的完整样例。

1. 先搞明白这套程序到底解决什么问题

一个基于 STM32 的麦克纳姆轮小车，核心难点从来不是「让四个电机转起来」，而是「让四个电机按什么速度转」。麦克纳姆轮小车可以全向移动——前进、横移、原地旋转、斜向漂移，靠的是四个轮子转速的精确配合。PID 控制程序就是那个让轮子实际转速死死咬住目标转速的闭环系统：没有它，小车空载时跑得飞快，压上负载就慢半拍，遇到地面不平还会一抖一抖地跑偏。这篇文章面向的是准备自己写底盘控制代码的开发者——你可能已经点亮过 LED、驱动过电机，但还没把「运动学解算 + PID 闭环」串成一条完整的控制链路。我会从轮速解算公式讲起，给出可直接移植的 STM32 代码，再逐个说清楚采样周期、积分限幅、死区补偿这些参数怎么调，最后把我在实际调试中踩过的坑按「现象 → 原因 → 解决」写给你看。这套方案适合做竞速小车、搬运机器人底盘或者想学习嵌入式闭环控制的入门者，读完你就能在开发板上跑通一套能稳定走直线的麦克纳姆轮底盘。

2. 麦克纳姆轮运动学：先把四个轮子的转速算出来

PID 控制的是轮速，但你的控制目标通常是底盘的前向速度、横移速度和旋转角速度。所以程序的第一步，是把底盘速度拆成四个轮子的目标转速，这就是麦克纳姆轮运动学反解。

2.1 轮子为什么斜着装：速度分解的基本原理

麦克纳姆轮的外圈是一圈斜 45 度安装的从动辊子。电机驱动轮子旋转时，轮毂给地面的力是沿着轮子轴向的，但辊子与地面的接触点会把力分解成两个方向：一个是垂直于辊子轴线的有效驱动力，另一个是沿辊子轴线方向的自由滑动分量。这两个分量的合成效果，就是轮子实际推动底盘运动的方向。

四个轮子的辊子安装方向不同，推力方向也不同。常见配置是左前轮和右后轮辊子方向一致（朝一个斜向），右前轮和左后轮朝另一个斜向。这样组合起来，四个轮子就能合成任意方向的水平力：同向旋转产生前后运动，异侧反向旋转产生横移，全部同向但转速不同产生旋转。这个斜装方式是整个运动学的几何基础，理解它你才能明白为什么反解公式里会有那些 1 和 -1 的系数。

写代码之前建议先用笔在纸上画一下四个轮子的推力方向。左前轮和左后轮如果辊子方向画反了，公式里的符号就要整体取反，这是后文避坑章节里第一个要检查的点。画图时以底盘中心为原点，X 轴朝前，Y 轴朝左，Z 轴朝上，按右手定则定义旋转正方向。

2.2 从底盘速度到轮速：反解公式与代码实现

假设底盘的前向速度为 vx（沿 X 轴）、横移速度为 vy（沿 Y 轴）、旋转角速度为 wz（绕 Z 轴），四个轮子的目标转速分别为 n1、n2、n3、n4，对应左前、右前、左后、右后。麦克纳姆轮运动学反解的简化公式如下：

• 左前轮：n1 = (vx - vy - wz × (a + b)) / r
• 右前轮：n2 = (vx + vy + wz × (a + b)) / r
• 左后轮：n3 = (vx + vy - wz × (a + b)) / r
• 右后轮：n4 = (vx - vy + wz × (a + b)) / r

其中 a 是底盘中心到轮子前后轴线的距离，b 是底盘中心到轮子左右中线的距离，r 是轮子半径。括号里的 (a + b) 是旋转分量折算到轮速的等效力臂，实际调试时如果底盘尺寸量不准，这个值就是一个可调参数。

下面是在 STM32 上实现反解运动的 C 代码，输入底盘速度，输出四个轮子的目标转速：

typedef struct { float vx; // 前向速度，单位 m/s float vy; // 横移速度，单位 m/s float wz; // 旋转角速度，单位 rad/s } ChassisSpeed; typedef struct { float n1; // 左前轮目标转速，单位 rpm float n2; // 右前轮目标转速，单位 rpm float n3; // 左后轮目标转速，单位 rpm float n4; // 右后轮目标转速，单位 rpm } WheelSpeed; void kinematics_inverse(ChassisSpeed *cmd, WheelSpeed *out, float a, float b, float r) { float l = a + b; // 等效力臂 out->n1 = ( cmd->vx - cmd->vy - cmd->wz * l) / r; out->n2 = ( cmd->vx + cmd->vy + cmd->wz * l) / r; out->n3 = ( cmd->vx + cmd->vy - cmd->wz * l) / r; out->n4 = ( cmd->vx - cmd->vy + cmd->wz * l) / r; }

这段代码的核心是三个速度分量到四个轮速的线性映射。每个轮子的转速由三个分量叠加而成：vx 对四个轮子都是正向贡献，vy 对左侧两个轮子和右侧两个轮子符号相反，wz 对前后轮符号也相反。这样组合下来，底盘才能实现全向移动。

参数说明：a 和 b 的单位是米，直接决定旋转分量的权重。如果小车旋转时实际角速度明显偏小，优先检查这两个值是否偏小；r 是轮子半径，如果轮子实际直径和标称值差 3% 以上，直行时可能没问题，但旋转时轮速算出来就不准。建议把这三个值放在一个配置结构体里，方便整车调参时统一修改。

2.3 前进/横移/旋转的组合：用运动学验证程序逻辑

反解公式写完之后不要急着接 PID，先在逻辑上验证几个典型工况。只给 vx = 0.5，其它分量为 0，四个轮子转速应该完全相等；只给 vy = 0.5，左前和右后是一组，右前和左后是另一组，两组转速绝对值相等但符号相反；只给 wz = 0.5，则前后轮反向、左右轮同向。如果你算出来的符号和这个规律对不上，说明公式里的正负号或者轮子序号标错了。

我习惯在调试助手上做一个「轮速映射检查」：用手缓慢转动某一个轮子，观察编码器读数是否正确反映转速和转向。这个检查能同时验证编码器相序、定时器配置和运动学公式的符号一致性。等到四个轮子的方向和转速都能正确反馈到上位机，再去接 PID，你排错的范围就能缩小很多。运动学这块的坑，越早暴露越省时间——等 PID 闭环以后再去查方向问题，你会分不清是运动学算错了还是 PID 调反了。

实际项目里，底盘速度指令通常来自遥控器摇杆或者上位机串口，而串口数据经过解析后不要直接丢给运动学函数。先做一步限幅：vx、vy、wz 各自夹在一个最大允许范围内，防止异常数据让轮速超限。这一步在调试初期尤其重要，因为一个超出电机物理极限的转速指令，轻则让小车猛地窜出去，重则烧毁驱动。

3. 在 STM32 上写 PID：位置式算法的代码与参数整定

运动学反解算出来的是每个轮子的目标转速，接下来要让电机实际转速跟随目标值。轮速控制我用的是位置式 PID，逆变器输出 PWM 占空比，编码器反馈实际转速，控制器在每个采样周期里计算一次误差并更新输出。这一章给出代码骨架，再讲采样周期、限幅、积分处理的工程细节。

3.1 PID 结构体设计与代码骨架

PID 控制器需要保存上一次误差、积分累计值和输出限幅值。在 STM32 上我用一个结构体封装这些状态，避免全局变量满天飞。下面是位置式 PID 的实现：

typedef struct { float kp; // 比例系数 float ki; // 积分系数 float kd; // 微分系数 float err_last; // 上一次误差 float integral; // 积分累计值 float integral_limit; // 积分限幅，防止积分饱和 float output_limit; // 输出限幅，限制 PWM 占空比 } PidObject; float pid_update(PidObject *pid, float target, float actual) { float err = target - actual; // 积分分离：误差大时切断积分，防止积分饱和 if (fabsf(err) < 50.0f) { pid->integral += err; } // 积分限幅 if (pid->integral > pid->integral_limit) pid->integral = pid->integral_limit; if (pid->integral < -pid->integral_limit) pid->integral = -pid->integral_limit; // 微分项：这里用的是误差变化率，不是测量值变化率 float derivative = err - pid->err_last; pid->err_last = err; float output = pid->kp * err + pid->ki * pid->integral + pid->kd * derivative; // 输出限幅 if (output > pid->output_limit) output = pid->output_limit; if (output < -pid->output_limit) output = -pid->output_limit; return output; }

这段代码几处设计值得说明。积分分离的阈值 50 是经验值，要看你轮速的量纲和误差范围来调整——如果目标转速是 300 rpm，误差超过 50 说明系统离目标还很远，此时积分只会积累一个很大的值，等误差变小后输出会被这个「历史包袱」拖慢响应。微分项用误差变化率而不是测量值变化率，是因为编码器数据在高转速下本身噪声就大，测量值变化率会把噪声放大成输出抖动；误差变化率在目标值变化时虽然会有跳变，但系统运行时目标值通常是缓变的，这个影响可接受。

3.2 采样周期、限幅与积分饱和处理

PID 是离散系统，采样周期的选择直接影响控制效果。轮速控制的采样周期我一般取 10ms（100Hz），前提是编码器分辨率不要太低——如果你用的电机编码器每转只有 13 个脉冲，10ms 采样周期内可能只采到几个脉冲，速度计算噪声会非常大。这种情况下要么换更高分辨率的编码器，要么把采样周期拉长到 20ms，但响应会变慢。实际工程里 500 线编码器配 10ms 周期是常见组合，轮速反馈的波动能控制在 5% 以内。

输出限幅的取值要结合你 PWM 的物理意义。假设 PWM 是 16 位定时器，占空比范围 0 到 10000（对应 ARR 值），那输出限幅就设成 8000 左右，留 20% 余量给堵转和欠压工况。不要设满到 10000，因为当电池电压正常时满占空比可能让电机超速，而 PID 输出一旦进饱和区，系统就开环了，控制效果完全失控。

积分限幅我设置时遵循一个原则：积分项的最大贡献不超过输出限幅的 30%。比如输出限幅 8000，那 integral_limit 就设为 2400 再除以 ki。这样即使积分累计到最大值，也不会单独占据整个输出，比例和微分项仍然有调节空间。这个比例是我在调试多套底盘后确定的经验值，太大会让系统震荡收敛慢，太小则消除稳态误差的能力变弱。

3.3 三个参数的整定顺序与手感测试

整定 PID 参数我有一套固定顺序，新手照这个流程能少走弯路。先把 ki 和 kd 设为 0，只保留 kp，从一个小值开始逐步增加，直到小车轮子出现轻微抖动。这个临界点的 kp 大约是最终值的 50% 到 70%，再往回退一点。然后加 kd，从零开始增加，目标是让轮子在踩下负载后能迅速恢复目标转速而不 overshoot。最后加 ki，每次增大一点点，观察轮子长时间运行后的稳态误差——如果误差始终不为零，说明 ki 不够；如果轮子周期性「喘振」，说明 ki 太大或者积分限幅太小。

整定参数时不只看轮子转不转，要用手捏住轮子感受扭矩波动。一个调好的速度环，捏住轮子时应该能感觉到有力地和你的手对抗，松开后转速立刻恢复；调得不好时会感觉到轮子一松一紧地「打嗝」。这个手感测试比看曲线更能快速发现问题，因为示波器只能看到数据，手感能捕捉到机械谐振和轴承摩擦这些数据里不明显的现象。

调参常常遇到的问题是三个参数互相耦合：加大 kp 后系统抖动，减小 ki 后稳态误差回来，你以为是两个参数没配合好，实际上是采样周期内的延迟太大了。先检查你的控制周期是否精确——如果主循环里混入了 LCD 刷新或者串口打印这些耗时操作，控制周期会从 10ms 漂到 15ms 甚至 20ms，PID 参数自然怎么调都不对。我用定时器触发 ADC 采样和 PID 计算，确保周期稳定。

4. 把程序组装起来：定时器、编码器与主循环

运动学反解和 PID 控制器都是孤立函数，真正跑起来还需要三块基础设施：编码器读取轮速、PWM 输出驱动电机、主循环把这两件事和 PID 串起来。这一章按模块给出配置代码和联调步骤。

4.1 编码器模式读取轮速：定时器配置与数据校准

STM32 的定时器自带编码器模式，两个输入通道接正交编码器的 A、B 相，硬件自动计数，不需要外部中断。配置代码如下，这里用 TIM2 的通道 1 和通道 2：

void encoder_tim2_init(void) { GPIO_InitTypeDef gpio = {0}; TIM_Encoder_InitTypeDef enc = {0}; __HAL_RCC_TIM2_CLK_ENABLE(); __HAL_RCC_GPIOA_CLK_ENABLE(); gpio.Pin = GPIO_PIN_0 | GPIO_PIN_1; gpio.Mode = GPIO_MODE_AF_PP; gpio.Pull = GPIO_PULLUP; gpio.Speed = GPIO_SPEED_FREQ_HIGH; gpio.Alternate = GPIO_AF1_TIM2; HAL_GPIO_Init(GPIOA, &gpio); // 4倍频模式：每个完整的正交周期产生4个计数脉冲 enc.EncoderMode = TIM_ENCODERMODE_TI1_TI2; enc.IC1Polarity = TIM_ICPOLARITY_RISING; enc.IC2Polarity = TIM_ICPOLARITY_RISING; enc.IC1Filter = 0x0F; // 输入滤波，滤除毛刺 enc.IC2Filter = 0x0F; HAL_TIM_Encoder_Init(&htim2, &enc); HAL_TIM_Encoder_Start(&htim2, TIM_CHANNEL_ALL); __HAL_TIM_SET_COUNTER(&htim2, 0); }

编码器模式的关键参数是 EncoderMode 和输入滤波。TI1_TI2 模式是 4 倍频，一个正交周期计数 4 次，分辨率最高，适合低速工况；如果电机转速很高导致定时器溢出频繁，可以改成 TI1 模式（2 倍频）降低计数频率。输入滤波设为 0x0F 能滤掉机械振动产生的毛刺脉冲，但滤波太深会引入相位延迟——编码器信号滞后于实际轮速，PID 的微分项会因此产生超前补偿，导致参数整定困难。

速度换算公式：

float get_wheel_speed_rpm(TIM_HandleTypeDef *htim) { int16_t cnt = (int16_t)__HAL_TIM_GET_COUNTER(htim); __HAL_TIM_SET_COUNTER(htim, 0); // 转速 = 计数脉冲 / (编码器分辨率 x 4倍频) / 采样周期 x 60 float rpm = (float)cnt / (500.0f * 4.0f) / 0.01f * 60.0f; return rpm; }

注意 cnt 强转成 int16_t，因为定时器计数器是 16 位，正转加计数、反转减计数，符号由硬件自动处理。500 是编码器每转线数，4 是倍频数，0.01 是采样周期（10ms），60 是把「转每秒」换算成「转每分钟」。这个函数写在定时器中断里或者主循环的固定周期任务里，每次调用后清零计数器，下一次采样周期再累计。

一个容易忽略的点：编码器线与电机的减速比。如果你的电机是 1:30 减速箱，编码器装在电机后端（高速端），那么 500 线编码器转一圈对应轮子只转 1/30 圈，速度换算要除以减速比。我见过不止一次有人在这里少了除减速比，导致 PID 目标转速与实际转速差 30 倍，参数怎么调都是振荡。

4.2 PWM 输出与方向控制：让电机按 PID 输出转起来

PID 输出是一个有符号数，正值表示正转，负值表示反转。电机驱动通常需要 PWM 占空比加方向引脚两路信号，我把 PID 输出映射到这个组合上：

void motor_set_output(int motor_id, float output) { // output 范围 [-8000, 8000]，映射到 PWM 占空比 0-8000 if (output >= 0) { set_motor_direction(motor_id, MOTOR_FORWARD); set_motor_pwm(motor_id, (uint16_t)output); } else { set_motor_direction(motor_id, MOTOR_BACKWARD); set_motor_pwm(motor_id, (uint16_t)(-output)); } }

direction 引脚切换时要注意死区时间。电机驱动芯片在方向切换瞬间如果 PWM 还开着，可能会产生瞬间的大电流冲击。常见的做法是先设 PWM 为 0，等待几微秒，再切换方向，最后恢复 PWM。实际工程里我在驱动板上加了硬件死区电路，但程序里仍然保留了这个顺序——软件死区是最后一道保险。

PWM 定时器的频率我设置在 20kHz 左右。太高了 MOS 管开关损耗大，太低了电机噪音明显。20kHz 超出人耳听觉上限，噪音控制在电机本身的机械声上，调试体验好很多。如果你用带霍尔传感器的直流无刷电机，PWM 频率要跟着驱动器的要求走，通常是 20kHz 到 50kHz 之间。

4.3 主循环架构：100Hz 控制周期下的任务分工

主循环不是一个空 while(1)，我建议用定时器中断做时基，主循环只处理慢速任务。控制周期 10ms，中断代码里做的只有三件事：读取四个编码器、跑四个 PID、设置四个 PWM 输出。串口打印、按键扫描、LED 刷新这些全放主循环里，避免中断被拖累。

void TIM6_IRQHandler(void) { HAL_TIM_IRQHandler(&htim6); // 10ms 定时器中断 // 1. 读取四个轮子的实际转速 float speed[4]; speed[0] = get_wheel_speed_rpm(&htim2); speed[1] = get_wheel_speed_rpm(&htim3); speed[2] = get_wheel_speed_rpm(&htim4); speed[3] = get_wheel_speed_rpm(&htim5); // 2. 运动学反解：根据目标底盘速度算目标轮速 ChassisSpeed cmd = {target_vx, target_vy, target_wz}; WheelSpeed target; kinematics_inverse(&cmd, &target, CHASSIS_A, CHASSIS_B, WHEEL_RADIUS); // 3. 对每个轮子执行 PID 更新 float output[4]; output[0] = pid_update(&pid1, target.n1, speed[0]); output[1] = pid_update(&pid2, target.n2, speed[1]); output[2] = pid_update(&pid3, target.n3, speed[2]); output[3] = pid_update(&pid4, target.n4, speed[3]); // 4. 输出到电机 motor_set_output(0, output[0]); motor_set_output(1, output[1]); motor_set_output(2, output[2]); motor_set_output(3, output[3]); }

这个中断函数里的每一步都是纯计算和寄存器操作，没有耗时调用，10ms 内执行完绰绰有余。target_vx、target_vy、target_wz 是在主循环里接收串口指令后更新的全局变量，中断里只读不写，避免数据竞争。如果你用的是 Cortex-M4 内核，还可以把 PID 计算放到 FPU 指令里，但实际测试下来，几个 float 乘法在 10ms 周期内完全不是瓶颈，没必要刻意优化。

主循环那边，我一般放一个简单的状态机：等待指令、执行运动、停止保护。收到急停指令时，主循环置一个刹车标志，中断里读到这个标志就把目标速度全部清为零，同时 PID 输出改为零。注意这时不要直接把 PWM 拉到满占空比反转——那是「硬刹车」，会让底盘瞬间锁死，冲击电流很大。要留给 PID 自然减速的时间，或者额外做斜坡减速。

5. 麦克纳姆轮 PID 控制的常见坑与排查路径

这一章是我整理的实际调试记录，按「现象 → 原因 → 解决」写。每一条都是真实踩过的坑，有些花了整整两天才定位到原因，希望你读完不用重走这些弯路。

5.1 坑一：轮子装反了，程序再好也白搭

现象：给小车一个纯直行的指令，结果四个轮子的转速对不上，小车斜着走；给一个横移指令，小车却原地转圈。运动学公式检查了几遍，符号没有错，PID 参数也正常。

原因：麦克纳姆轮的辊子安装方向标错了。左前轮和右后轮的辊子方向必须一致，右前轮和左后轮的辊子方向必须一致，否则四个轮子的推力方向不匹配，合成出来的力就和运动学公式假设的完全不符。这个坑在安装阶段就可能埋下——轮子外观看起来一样，辊子方向却有左右旋之分。

解决：拆下四个轮子逐一检查辊子斜向，确定每组对角的轮子辊子方向一致。然后在没有 PID 的情况下，用手推着小车前进，观察四个轮子是否都朝正确方向自由转动——麦克纳姆轮自由滚动时，如果四个轮子都能顺畅地被动转动而没有一个「卡住」，说明轮子安装方向基本正确。

5.2 坑二：编码器数据跳变导致 PID 输出抖动

现象：小车空载运行时轮速波动在 ±10% 以内，但一放上负载或者跑粗糙地面，轮速波动瞬间拉到 ±40%，PID 输出跟着剧烈抖动，底盘发出明显的「咔咔」声。

原因：编码器读数在受到机械振动时产生毛刺脉冲。虽然配置了输入滤波，但滤波时间常数不够长，无法完全消除高频抖动。更关键的是，速度换算公式里把抖动误差放大了 60 倍——计数多一跳，转速计算就跳好几转。

解决：先加大输入滤波参数到 0x1F，观察改善情况。如果还不够，就在速度计算时做滑动平均滤波。取最近 4 次采样周期的计数值做平均，这样单个周期的毛刺会被均值吸收。代价是采样延迟增加了两个周期，PID 的 kd 要相应调小，不然微分项会放大延迟造成新的震荡。

#define SPEED_FILTER_N 4 static int16_t cnt_buf[SPEED_FILTER_N]; static uint8_t buf_idx = 0; float get_wheel_speed_rpm_filtered(TIM_HandleTypeDef *htim) { int16_t cnt = (int16_t)__HAL_TIM_GET_COUNTER(htim); __HAL_TIM_SET_COUNTER(htim, 0); cnt_buf[buf_idx] = cnt; buf_idx = (buf_idx + 1) % SPEED_FILTER_N; int32_t sum = 0; for (int i = 0; i < SPEED_FILTER_N; i++) { sum += cnt_buf[i]; } return (float)sum / SPEED_FILTER_N / 500.0f / 4.0f / 0.01f * 60.0f; }

滤波窗口的长度要权衡：4 次平均在 10ms 采样周期下等于额外 20ms 延迟，对速度环来说还能承受；如果你改成 10 次平均，控制环路的相位裕度会明显下降，PID 参数要重新整定。

5.3 坑三：电机死区让小车低速时「点头」

现象：给小车一个很低的转速指令，比如对应 PWM 占空比 300，电机不转；加大到 400，电机突然跳起来转得很快。PID 输出在低速段来回跳动，小车像在「点头」。

原因：直流电机的摩擦力矩和驱动器的最小开通占空比共同构成了一个死区。PWM 占空比低于某个阈值时，电机转矩克服不了静摩擦和驱动器压降，完全不转。PID 看到轮速为零，继续增大输出，一旦跨过阈值，电机猛转，误差反向，PID 又把输出压回来——于是形成了低速段的极限环振荡。

解决：最有效的是死区补偿——在 PID 输出基础上叠加一个固定补偿量，让输出在死区范围内也能维持电机转动。具体做法是，在 PID 输出加上一个开环的 base_pwm，大约为死区阈值的 50%，然后在这个基础上做 PID 调节。补偿量的方向跟随目标转速的符号，目标为负时补偿也取负值。这个补偿量的标定很简单：手动输出 PWM，从 0 慢慢增加，记录电机刚转起来时的值，把这个值乘以 0.5 作为补偿基准。

低速工况下的另一个选择是换用带减速比更大的电机，让相同 PWM 下轮端转矩更大。但这是机械层面的改动，调试周期长；软件死区补偿是当天的后悔药。

5.4 坑四：积分饱和让小车冲出线

现象：小车从静止直接给一个 300 rpm 的高速指令，启动瞬间轮子以最大 PWM 全力加速，但实际转速超过目标值后还在继续往前冲，要等一两秒才回到目标转速，期间已经跑出很远的距离。

原因：PID 的积分项在启动阶段累计了一个非常大的值。误差从 300 逐步减小的过程中，积分一直在增加，等到误差归零时积分已经大到让输出长期保持在限幅值，必须等误差变成负的、积分慢慢回退，输出才能降下来。这个「冲过头」就是积分饱和。

解决：代码里已经做了积分分离，但分离阈值 50 在启动阶段还是太大。更激进的方案是用增量式 PID——输出只在上一拍基础上加增量，天然消除了积分累计的历史包袱。但增量式 PID 对输出限幅的处理更麻烦，需要额外的积分状态跟踪。我这边用的折中方案是「变速积分」：误差越大，积分增益越小，误差接近零时积分增益恢复正常。

// 变速积分：误差大时积分系数自动减小 float error_abs = fabsf(err); float ki_effective = pid->ki; if (error_abs > 100.0f) { ki_effective = pid->ki * 0.1f; } else if (error_abs > 50.0f) { ki_effective = pid->ki * 0.5f; }

这样启动阶段积分增长被压到很小的速率，输出主要靠比例项拉动，等误差收窄后再放开积分力度消除稳态误差。上面代码里的阈值 100 和 50 是配合 300 rpm 目标转速的量纲，如果你目标转速不同要按比例调整。

5.5 坑五：PID 极性接反，输出越大转速反而越小

现象：PID 参数无论怎么调，轮子的实际转速总是和目标值相差越来越大，最终飞转或停转。检查编码器方向，转动的正方向计数符号正确，PWM 输出和电机转向也一致，但整个闭环就是正反馈。

原因：编码器反馈的符号和运动学目标转速的符号不一致。比如运动学算出来正转，编码器在正转时计数值减小，于是 target - actual 变成了 target + |actual|，误差越来越大。这在单个轮子调试时不容易发现，因为你只看一个轮子让它转到一个固定转速，PID 会把输出推到极限，看起来像是参数没调好。

解决：在接入 PID 之前单独测试每个轮子的闭环符号。写一个固定的开环输出让轮子正转，打印编码器计数符号，确认是正的；然后让轮子反转，确认计数是负的。之后再接入 PID，在目标转速为 0 的情况下用手转动轮子，观察 PID 输出是否朝阻止转动的方向变化——往阻止方向变化就是负反馈，往同方向推就是正反馈。正反馈时把编码器 A、B 相对调一下，或者把运动学公式里对应轮的系数取反，两者选其一，不要两处都改。

6. 进阶：串级 PID 与动态参数——把小车调得更好开

基础的速度环 PID 能让每个轮子按目标转速旋转，但麦克纳姆轮底盘的直行性能还取决于四个轮子转速的一致性。更进一步的方案是加一个底盘层面的运动控制环：在上层的角速度环和位置环，下层的速度环之上，再做一层差速协调。常见做法是串级 PID：外层环读取陀螺仪的角度或角速度，输出底盘旋转修正量，叠加到运动学的 wz 目标值上。这样一来，即使某个轮子因为地面摩擦打滑，陀螺仪也能感知到底盘在偏转，并通过修正 wz 目标来让四个轮子差速补偿，直行就稳了。

串级 PID 的内环参数沿用速度环整定的成果，外环的周期可以放慢到 20ms 或 50ms。外环 kp 从 0.5 开始调，观察底盘在转向时的响应速度；kd 用来抑制转向过冲，但要非常小心——角速度数据来自陀螺仪，本身带有零漂，微分项会把零漂放大成持续的偏转力矩。解决零漂的办法是在底盘静止时采样 1000 次陀螺仪数据取平均，作为静态偏移量保存，运行时从采样值里减去这个偏移量再做控制。

动态参数主要是根据底盘速度实时调整 kp。高速运行时（超过 1m/s），把 kp 调小 30%，防止轮子对微小误差过度反应而产生高频抖动；低速时（低于 0.2m/s），把 kp 调大 30%，补偿摩擦阻力造成的慢速不线性。这个速度分段的参数表，我在工程里用一个数组加线性插值实现，比查表跳变更平滑：

typedef struct { float speed_threshold; float kp_scale; } SpeedScalePoint; // 速度-比例系数缩放表 const SpeedScalePoint scale_table[] = { {0.0f, 1.3f}, {0.2f, 1.0f}, {1.0f, 0.7f}, }; float get_kp_scale(float current_speed) { for (int i = 0; i < 2; i++) { if (current_speed < scale_table[i].speed_threshold) { // 线性插值 float t = (current_speed - scale_table[i].speed_threshold) / (scale_table[i+1].speed_threshold - scale_table[i].speed_threshold); return scale_table[i].kp_scale + t * (scale_table[i+1].kp_scale - scale_table[i].kp_scale); } } return scale_table[2].kp_scale; }

这里的 current_speed 用底盘合成速度 sqrt(vx^2 + vy^2)，不要用某个轮子的单独转速，否则斜向运动时参数切换会不顺畅。动态参数的关键是过渡平滑，跳变式的参数切换会在速度分段点造成肉眼可见的顿挫感。

另一个值得做的验证方法是让小车跑出一个边长为 1m 的正方形：先直行 1m，再横移 1m，再直行 1m，再横移 1m，记录起点和终点的位置偏差。这个测试能同时验证运动学精度、轮速闭环和机电装配质量——偏差超过 20cm 说明至少一个环节有问题。我习惯在每次调整参数后都跑一遍这个测试，把偏差值记下来，作为横向对比的基准。

做这些进阶调优时，最快的验证工具是蓝牙串口把轮速和 PID 输出波形实时发到手机上看。不要用 USB 线拖着跑，线会干扰小车运动，尤其做正方形测试时，线的拉力会让偏航数据失真。我这套程序里留了一个轻量级协议，直接用板载 LED 的翻转频率粗略观察控制状态——LED 快闪表示 PID 输出饱和，慢闪表示正常调节。这算是我调试时的最后一项「玄学」技巧，但关键时刻它比串口数据更能救命。

希望这些从运动学公式到 PID 参数整定、再到底层驱动和排错的经验能帮到你。踩过的坑我都写了，剩下的就是让你的小车跑起来。

本文还有配套的精品资源，点击获取