基于Arduino与BLDC（无刷直流电机）实现的机器人双电机差速同步动态控制，是移动机器人底盘运动控制的核心技术。它旨在解决差速底盘在动态负载变化、地面扰动及电机特性差异下，左右轮速度无法严格同步，导致机器人跑偏、轨迹精度下降的问题。该方案通过引入速度闭环反馈与同步协调算法，将传统的开环PWM驱动升级为高精度的动态伺服系统。

一、 主要特点
双闭环控制结构
内环（电流/力矩环）：利用BLDC的FOC（磁场定向控制）驱动器或带电流反馈的ESC，实现对电机输出力矩的精确控制，抑制因负载突变引起的转速波动。
外环（速度环）：基于电机霍尔传感器或编码器反馈，构建PID速度闭环。Arduino作为主控，实时计算左右轮的实际转速，并与目标指令比较，动态调整PWM输出，确保速度恒定。
动态同步策略
主从同步：指定一个电机为主电机（Master），另一个为从电机（Slave）。从电机的目标速度不仅取决于上层指令，还跟随主电机的实际速度进行微调，消除累积误差。
交叉耦合控制：引入同步误差（左右轮速度差）作为反馈量。当检测到一侧轮子因打滑或阻力增大而减速时，算法会同时降低另一侧轮子的速度，强制保持两轮线速度一致，维持直线运动。
抗扰动与自适应
通过PID控制器的微分项（D）和积分项（I），系统能快速响应地面不平、单侧轮子悬空或负载重心偏移等扰动，自动补偿力矩输出，保持机器人姿态稳定。

二、 核心应用场景
高精度AGV/AMR：在仓储物流中，要求机器人沿磁导或二维码轨迹精确行走（误差<10mm）。差速同步控制能有效克服地面摩擦系数不均、轮胎磨损差异导致的“蛇形”跑偏现象。
巡检与安防机器人：在长距离走廊巡逻时，需保持绝对直线行驶，避免因累积航向角误差撞上墙壁。同步控制确保里程计（Odometry）积分准确，为SLAM定位提供可靠数据源。
重载移动平台：当机器人携带不对称重物（如机械臂偏置安装）时，重心偏移会导致两侧轮子负载不同。同步动态控制能分配差异化的力矩，抵消偏载力矩，使机器人仍能走直线。
教育/竞赛机器人：在RoboMaster等竞速或对抗场景中，快速启停和精准转向依赖于电机响应的同步性，避免因左右轮响应延迟导致的原地“画圈”或转向过度。

三、 注意事项与关键技术挑战
反馈传感器的精度与分辨率
挑战：低分辨率霍尔传感器（如6步/转）在低速下测速不准，会产生量化噪声，导致PID控制器高頻震荡。
对策：优先选用增量式编码器（如1000线）或高分辨率磁编码器（AS5048等）。若仅能用霍尔，需在软件中采用M法测速（计算固定时间内的脉冲数）并配合低通滤波，且避免在极低速下运行。
控制周期的实时性
挑战：Arduino Uno（ATmega328P）的主频较低，若控制周期过长（>20ms），系统响应迟滞，无法及时抑制扰动。
对策：使用Timer中断严格定时执行PID计算，禁用delay()函数。对于高性能需求，建议升级至ESP32或Teensy 4.0，将控制频率提升至1kHz以上。
PID参数整定与抗饱和
挑战：直线行走时，若同步误差长期存在，积分项（I）会无限累积（Windup），导致输出饱和，一旦误差消除会产生巨大超调，使机器人反向跑偏。
对策：必须实施积分抗饱和（Anti-windup）​ 机制。当PWM输出达到限幅值时，冻结积分项累加。同时，针对空载和满载工况分别整定PID参数，或采用自适应PID。
通信延迟与信号干扰
挑战：若使用PWM信号控制独立的ESC，长线传输易受电磁干扰；若使用串口（UART）指令，协议解析延迟会导致左右轮响应不同步。
对策：动力线（电机线）与信号线分开布线，或使用双绞线。推荐使用CAN总线通信，具有高可靠性和优先级仲裁机制，能确保控制指令的同步到达。
机械安装与标定
挑战：左右轮直径的微小差异、轮胎胎压不同、减速器间隙，都会在硬件层面引入固定的速度偏差。
对策：上线前必须进行标定（Calibration）。让机器人空载直线行走一定距离，测量实际偏移量，在软件中为左右轮设置一个微小的速度补偿系数（如左轮×1.0，右轮×0.998），以抵消硬件不对称性。

1、基于编码器反馈的差速底盘闭环控制（PID+FOC）

#include <SimpleFOC.h>
// 电机与编码器配置
BLDCMotor motorLeft(7), motorRight(7);  // 7对极电机
BLDCDriver3PWM driverLeft(9,10,11,8), driverRight(5,6,7,4);  // PWM引脚
Encoder encLeft(2,3), encRight(18,19);  // 编码器A/B相

// 运动学参数
const float wheelbase = 0.3;  // 轮距(m)
const float wheel_radius = 0.05;  // 轮半径(m)

void setup() {
  Serial.begin(115200);
  // 初始化左电机
  motorLeft.linkDriver(&driverLeft);
  motorLeft.linkEncoder(&encLeft);
  motorLeft.PID_velocity.P = 0.2;  // 速度环P参数
  motorLeft.init();
  motorLeft.initFOC();

  // 初始化右电机
  motorRight.linkDriver(&driverRight);
  motorRight.linkEncoder(&encRight);
  motorRight.PID_velocity.P = 0.2;
  motorRight.init();
  motorRight.initFOC();
}

void loop() {
  float v = 0.5;  // 目标线速度(m/s)
  float omega = 0.3;  // 目标角速度(rad/s)

  // 运动学解算：计算左右轮目标速度(rad/s)
  float w_left = (v - omega * wheelbase / 2) / wheel_radius;
  float w_right = (v + omega * wheelbase / 2) / wheel_radius;

  // 闭环速度控制
  motorLeft.move(w_left);
  motorRight.move(w_right);

  // 调试输出（可选）
  static unsigned long lastDebug = 0;
  if (millis() - lastDebug > 100) {
    lastDebug = millis();
    Serial.print("左轮速度:"); Serial.print(motorLeft.shaftVelocity);
    Serial.print(" 右轮速度:"); Serial.println(motorRight.shaftVelocity);
  }
}

2、基于超声波矩阵的动态避障差速控制

#include <Servo.h>
#include <NewPing.h>  // 超声波库

#define SONAR_NUM 3      // 超声波探头数量
#define MAX_DISTANCE 200 // 最大检测距离(cm)
#define FORWARD_SPEED 150 // 前进PWM值
#define TURN_SPEED 100   // 转向PWM值

Servo escLeft, escRight;  // ESC控制
NewPing sonar[SONAR_NUM] = {
  NewPing(2, 3, MAX_DISTANCE),  // 左探头
  NewPing(4, 5, MAX_DISTANCE),  // 中探头
  NewPing(6, 7, MAX_DISTANCE)   // 右探头
};

void setup() {
  Serial.begin(9600);
  escLeft.attach(9);  // 左ESC引脚
  escRight.attach(10); // 右ESC引脚
  escLeft.writeMicroseconds(1000);  // 初始化停止
  escRight.writeMicroseconds(1000);
  delay(2000);
}

void loop() {
  // 读取超声波数据（中值滤波去噪）
  int distances[SONAR_NUM];
  for (int i = 0; i < SONAR_NUM; i++) {
    distances[i] = sonar[i].ping_median(5);  // 5次采样取中值
  }

  // 动态避障逻辑
  if (distances[1] > 30) {  // 中路安全，前进
    escLeft.writeMicroseconds(1000 + FORWARD_SPEED);
    escRight.writeMicroseconds(1000 + FORWARD_SPEED);
  } else {  // 中路有障碍，根据侧方距离转向
    if (distances[0] > distances[2]) {  // 左转
      escLeft.writeMicroseconds(1000 - TURN_SPEED);
      escRight.writeMicroseconds(1000 + TURN_SPEED);
    } else {  // 右转
      escLeft.writeMicroseconds(1000 + TURN_SPEED);
      escRight.writeMicroseconds(1000 - TURN_SPEED);
    }
  }
  delay(100);  // 控制周期
}

3、基于PS2遥控器的差速同步控制（开环+死区补偿）

#include <PS2X_lib.h>  // PS2遥控器库
PS2X ps2x;

#define LEFT_MOTOR_PWM 12  // 左电机PWM引脚
#define RIGHT_MOTOR_PWM 13 // 右电机PWM引脚
#define DEADZONE 20        // 摇杆死区阈值

void setup() {
  Serial.begin(115200);
  // 初始化PS2遥控器
  int error = ps2x.config_gamepad(18, 19, 23, 21);  // CLK, CMD, ATT, DAT
  if (error != 0) Serial.println("PS2初始化失败");

  // 初始化PWM引脚
  pinMode(LEFT_MOTOR_PWM, OUTPUT);
  pinMode(RIGHT_MOTOR_PWM, OUTPUT);
}

void loop() {
  ps2x.read_gamepad();  // 读取遥控器数据

  // 获取摇杆值（-128~127），映射到PWM范围（0~255）
  int ly = ps2x.Analog(PSS_LY) - 128;  // 左摇杆Y轴（前后）
  int rx = ps2x.Analog(PSS_RX) - 128;  // 右摇杆X轴（转向）

  // 死区补偿：摇杆在中心附近时不动作
  if (abs(ly) < DEADZONE) ly = 0;
  if (abs(rx) < DEADZONE) rx = 0;

  // 差速控制：速度=Y轴，转向=X轴
  int leftSpeed = constrain(ly - rx, -255, 255);  // 左电机速度
  int rightSpeed = constrain(ly + rx, -255, 255); // 右电机速度

  // 输出PWM（开环控制）
  analogWrite(LEFT_MOTOR_PWM, map(leftSpeed, -255, 255, 0, 255));
  analogWrite(RIGHT_MOTOR_PWM, map(rightSpeed, -255, 255, 0, 255));

  delay(50);  // 控制周期
}

要点解读
运动学解算与差速原理
案例1通过(v ± ω*L/2)/R公式将线速度和角速度分解为左右轮转速，实现差速转向。
关键参数：轮距（wheelbase）、轮半径（wheel_radius）需精确测量，误差会导致轨迹偏移。
闭环控制与传感器融合
案例1使用编码器+PID实现速度闭环，消除负载变化和地面摩擦的影响。
案例2通过超声波矩阵构建环境感知，结合动态避障算法调整差速策略，提升鲁棒性。
开环控制的死区补偿
案例3在摇杆输入中引入死区（DEADZONE），避免电机在微小输入下抖动，提升操作平滑性。
开环控制需通过机械标定（如轮径补偿）和PID参数整定弥补精度不足。
实时性与硬件资源优化
案例1使用SimpleFOC库和32位MCU（如Teensy 4.0）实现高频控制（>1kHz），避免算力瓶颈。
案例2通过中值滤波降低超声波噪声，案例3用constrain()限制PWM范围防止电机过载。
工程实践中的抗干扰设计
电源隔离：电机电源与逻辑电源分开，加电解电容滤波（如2200μF）。
信号线屏蔽：编码器和超声波线使用屏蔽线，远离电机动力线。
机械对称性：左右轮直径误差需<1%，否则需通过软件补偿（如案例1中的独立PID参数）。

4、基于 SimpleFOC 的双闭环速度同步
功能描述：这是目前最主流的高精度方案。利用 SimpleFOC 库，为左右电机分别建立速度闭环。通过编码器实时反馈，PID 算法会自动补偿两个电机的差异，确保左右轮转速严格一致，实现完美的直线行驶。

#include <SimpleFOC.h>

// --- 硬件定义 (左右对称) ---
// 左电机
BLDCMotor motorL(7); 
BLDCDriver3PWM driverL(9, 10, 11, 8);
Encoder encoderL(2, 3); // A, B 相

// 右电机
BLDCMotor motorR(7);
BLDCDriver3PWM driverR(5, 6, 7, 4);
Encoder encoderR(18, 19);

// --- 目标变量 ---
float targetSpeed = 2.0; // 目标线速度 (rad/s)

void setup() {
  Serial.begin(115200);

  // --- 左电机初始化 ---
  driverL.voltage_power_supply = 12;
  driverL.init();
  motorL.linkDriver(&driverL);
  motorL.linkSensor(&encoderL);
  motorL.controller = MotionControlType::velocity; // 速度闭环模式
  motorL.PID_velocity.P = 0.5; // 需根据电机惯量整定
  motorL.init();
  motorL.initFOC();

  // --- 右电机初始化 ---
  driverR.voltage_power_supply = 12;
  driverR.init();
  motorR.linkDriver(&driverR);
  motorR.linkSensor(&encoderR);
  motorR.controller = MotionControlType::velocity;
  motorR.PID_velocity.P = 0.5;
  motorR.init();
  motorR.initFOC();
}

void loop() {
  // 1. 读取传感器并更新 FOC 算法 (必须高频调用)
  motorL.loopFOC();
  motorR.loopFOC();

  // 2. 速度同步控制
  // 由于是闭环，直接给相同的目标速度，PID 会自动调整电压来消除误差
  motorL.move(targetSpeed);
  motorR.move(targetSpeed);

  // 3. 监控实际速度差异
  Serial.print("L_Speed: "); Serial.print(motorL.shaft_velocity);
  Serial.print(" R_Speed: "); Serial.println(motorR.shaft_velocity);
  
  delay(10); // 100Hz 控制频率
}

5、差速转向运动学解算与 PID 协同
功能描述：机器人不仅要走直线，还要转弯。本案例结合了运动学公式，将“线速度”和“角速度”解算为左右轮的具体转速，并结合 PID 控制器消除转向时的打滑误差。

#include <Encoder.h>
#include <PID_v1.h>

// --- 运动学参数 ---
const float WHEEL_BASE = 0.35;    // 轮距 (米)
const float WHEEL_RADIUS = 0.05;  // 轮半径 (米)

// --- 硬件 ---
Encoder encL(2, 3);
Encoder encR(18, 19);
const int PWM_L = 9;
const int PWM_R = 10;

// --- 目标输入 ---
float v_linear = 0.5;  // 期望线速度 (m/s)
float v_angular = 0.2; // 期望角速度 (rad/s), >0 左转

// --- PID 变量 ---
double inL, outL, setL;
double inR, outR, setR;
PID pidL(&inL, &outL, &setL, 2.0, 0.5, 0.1, DIRECT);
PID pidR(&inR, &outR, &setR, 2.0, 0.5, 0.1, DIRECT);

void setup() {
  pidL.SetMode(AUTOMATIC);
  pidR.SetMode(AUTOMATIC);
  pidL.SetOutputLimits(-255, 255);
  pidR.SetOutputLimits(-255, 255);
}

void loop() {
  // 1. 差速运动学逆解算
  // 左轮目标速度 = 线速度 - 角速度 * 轮距 / 2
  float vL_target = v_linear - (v_angular * WHEEL_BASE / 2.0);
  // 右轮目标速度 = 线速度 + 角速度 * 轮距 / 2
  float vR_target = v_linear + (v_angular * WHEEL_BASE / 2.0);

  // 将线速度 m/s 转换为 RPM
  setL = (vL_target / (2 * PI * WHEEL_RADIUS)) * 60.0;
  setR = (vR_target / (2 * PI * WHEEL_RADIUS)) * 60.0;

  // 2. 读取实际 RPM
  inL = getRPM(encL);
  inR = getRPM(encR);

  // 3. PID 计算与输出
  pidL.Compute();
  pidR.Compute();

  analogWrite(PWM_L, outL);
  analogWrite(PWM_R, outR);

  delay(10);
}

// 辅助函数：计算 RPM
float getRPM(Encoder &enc) {
  static unsigned long lastTime = 0;
  static long lastPos = 0;
  unsigned long now = millis();
  long pos = enc.read();
  float dt = (now - lastTime) / 1000.0;
  if(dt==0) dt=0.001;
  float rpm = ((pos - lastPos) / 1000.0) / dt * 60.0; // 假设1000脉冲/转
  lastPos = pos;
  lastTime = now;
  return rpm;
}

6、基于主从模式的扭矩同步（防止互搏）
功能描述：在刚性连接或重载场景下，如果两个电机都强行控制速度，容易产生“互搏”（一个推一个拉）。本案例采用“主从模式”，主轴控制速度，从轴根据主轴的扭矩输出进行动态补偿，实现柔性同步。

#include <SimpleFOC.h>

// --- 硬件定义 ---
BLDCMotor motorMaster(7); // 主轴
BLDCMotor motorSlave(7);  // 从轴
// ... 驱动器和传感器定义 ...

// --- 同步参数 ---
float sync_gain = 0.2; // 同步补偿系数
float target_torque = 0.5; // 基础扭矩指令

void setup() {
  // 初始化电机...
  // 主轴设为速度模式
  motorMaster.controller = MotionControlType::velocity;
  motorMaster.init(); motorMaster.initFOC();
  
  // 从轴设为扭矩模式 (为了柔性跟随)
  motorSlave.controller = MotionControlType::torque;
  motorSlave.init(); motorSlave.initFOC();
}

void loop() {
  // 1. 主轴运行
  motorMaster.loopFOC();
  motorMaster.move(2.0); // 主轴以 2.0 rad/s 运行

  // 2. 从轴同步逻辑
  // 读取主轴的实际速度
  float master_vel = motorMaster.shaft_velocity;
  // 读取从轴的实际速度
  float slave_vel = motorSlave.shaft_velocity;
  
  // 计算速度差
  float vel_error = master_vel - slave_vel;
  
  // 动态调整从轴扭矩
  // 如果从轴慢了 (error > 0)，增加正向扭矩；反之减小
  float slave_torque_cmd = target_torque + (vel_error * sync_gain);
  
  motorSlave.loopFOC();
  motorSlave.move(slave_torque_cmd);

  delay(10);
}

要点解读
开环与闭环的本质区别
案例4和5都强调了闭环。对于 BLDC 差速底盘，开环控制（直接给 PWM）几乎无法走直线，因为电池电压波动、地面摩擦系数变化都会导致左右轮转速不一致。必须引入编码器反馈，通过 PID 实时修正，才能实现“指哪打哪”。
差速运动学的数学模型
案例5展示了核心公式。这是所有差速机器人的数学基石。不理解这个公式，就无法正确控制机器人的转向半径。注意在代码中要处理好单位换算（m/s 转 rad/s 或 RPM）。
SimpleFOC 库的优势
案例4和6使用了 SimpleFOC。相比传统的方波驱动，FOC（磁场定向控制）能让 BLDC 电机在低速下运行极其平稳，且扭矩响应线性度极高。这对于需要精细差速控制（如原地微小旋转）的机器人来说是最佳选择。
主从模式防止“互搏”
案例6解决了多电机刚性耦合的痛点。当两个电机硬连接或负载差异极大时，如果都设为速度模式，容易发生“互搏”（电流激增，电机发热）。采用“主速度、从扭矩”的策略，让从轴“柔性”地跟随主轴，能有效保护电机和机械结构。
控制频率与实时性
所有案例都强调了 delay(10) 或更高的频率。差速同步对实时性要求很高。如果控制周期太长（如超过 50ms），PID 的修正就会滞后，导致机器人走出的轨迹呈锯齿状或震荡。建议使用 Arduino 的定时器中断来保证控制频率的稳定性。

请注意：以上案例仅作为思路拓展的参考示例，不保证完全正确、适配所有场景或可直接编译运行。由于硬件平台、实际使用场景、Arduino 版本的差异，均可能影响代码的适配性与使用方法的选择。在实际编程开发时，请务必根据自身硬件配置、使用场景及具体功能需求进行针对性调整，并通过多次实测验证效果；同时需确保硬件接线正确，充分了解所用传感器、执行器等设备的技术规范与核心特性。对于涉及硬件操作的代码，使用前务必核对引脚定义、电平参数等关键信息的准确性与安全性，避免因参数错误导致硬件损坏或运行异常。