本文介绍了一种基于Arduino与无刷直流电机(BLDC)的

基于Arduino与BLDC（无刷直流电机）构建的AGV差速驱动机器人，是一种在仓储物流、工业自动化领域广泛应用的经典移动平台方案。其核心原理是利用左右两侧驱动轮的速度差（差速）来合成机器人的前进、后退及转向动作。结合BLDC电机的高效率、大扭矩特性，该方案旨在实现低成本、高可靠性的物料搬运与自主导航。

一、 主要特点
差速运动学模型简单
控制解耦：运动控制仅需两个自由度（左轮速度、右轮速度）。通过简单的运动学公式，即可将上层规划的路径速度指令分解为两个独立的电机控制指令，算法复杂度低，对MCU算力要求不高。
BLDC电机带来的性能优势
大扭矩与高过载能力：BLDC电机配合行星齿轮减速器（如用户提供的71.5:1减速比电机），能提供极大的轮端扭矩，轻松应对AGV满载启动、爬坡（通常<5°）等工况。
高效率与长寿命：相比有刷直流电机，BLDC无电刷磨损，免维护，适合7x24小时连续运行的工业场景。
平滑低速控制：通过FOC（磁场定向控制）算法（如SimpleFOC库），可实现极低速下的平稳转动，消除传统方波驱动在低速时的“顿挫感”，这对于AGV在狭窄货架间的精准停靠至关重要。
结构简单与成本优势
机械结构仅需两个驱动轮加一个或多个万向从动轮（如脚轮），结构紧凑，机械加工与装配难度低。相较于全向轮或舵轮AGV，硬件成本显著降低。

二、 核心应用场景
仓储物流AGV/AMR：在仓库、分拣中心执行托盘、料箱的搬运任务。差速结构适合在宽阔通道或固定路径（如磁导/色带）上运行，实现点到点的物料转运。
工业产线物料配送：在汽车、电子装配产线，负责将零部件从仓库配送至工位。差速AGV转弯半径小（理论上原地旋转），能适应产线工位间狭窄的转弯空间。
服务机器人底盘：作为清洁机器人、安防巡检机器人的移动平台，利用其灵活的转向能力在复杂室内环境中避障穿梭。

三、 注意事项与关键技术挑战
差速转向的“滑动”与精度损失
问题：差速转向本质上是“滑动转向”，即依靠左右轮与地面的滑动摩擦来改变方向。在光滑地面或急转弯时，实际转弯半径会偏离理论值，导致航向角累积误差增大。
对策：必须引入闭环反馈。仅靠开环控制电机转速无法保证轨迹精度。需结合IMU（惯性测量单元）​ 或陀螺仪进行航向角闭环校正，或通过激光SLAM/视觉里程计进行全局位姿纠正。
电机同步性与直线行走保持
问题：由于左右轮电机特性（减速比、轮胎磨损）的微小差异，即使给定相同PWM占空比，机器人也容易跑偏，无法走直线。
对策：实施双闭环速度控制。利用电机尾部的霍尔传感器或加装的编码器（用户提供的电机带霍尔反馈，可用于测速），分别对左右轮进行独立的PID速度闭环。将速度而非PWM作为控制目标，可有效抑制因负载不均或地面打滑引起的跑偏。
地面附着与打滑检测
问题：AGV负载变化大（空载 vs 满载），地面可能有油污或水渍，导致驱动轮打滑，使里程计（编码器积分）失效。
对策：利用IMU的加速度计数据与编码器积分速度进行数据融合。当检测到“编码器有速度，但IMU无加速度”或两者差异过大时，判定为打滑，应触发报警或降速运行，防止因打滑导致的定位丢失。
通信协议与实时性
注意：用户提供的电机带霍尔反馈，若用于速度闭环，需确保Arduino读取霍尔信号的频率足够高（建议中断触发）。对于大功率BLDC，建议使用CAN总线或RS485与ESC（电调）通信，替代传统的PWM信号，以提高抗干扰能力和指令传输的确定性，避免因PWM线缆过长受干扰导致电机失控。
机械结构与万向轮选型
注意：差速AGV的灵活性高度依赖于从动万向轮（脚轮）的灵活性。若脚轮转向阻力大或发生“卡死”，会严重阻碍差速转向，甚至导致电机过载。必须选择高精度、低阻力的工业脚轮，并确保其安装位置满足三点支撑或四点支撑的稳定性要求。

1、基于编码器的差速PID转向控制

#include <SimpleFOC.h>

// 左轮电机
BLDCMotor leftMotor(7);
BLDCDriver3PWM leftDriver(9, 10, 11, 8);
MagneticSensorI2C leftEncoder(AS5600_I2C);

// 右轮电机
BLDCMotor rightMotor(12);
BLDCDriver3PWM rightDriver(13, 14, 15, 16);
MagneticSensorI2C rightEncoder(AS5600_I2C);

// PID参数
float Kp = 0.5, Ki = 0.1, Kd = 0.05;
float targetHeading = 90.0; // 目标朝向角度（度）
float currentHeading = 0;

void setup() {
  // 左轮初始化
  leftMotor.linkSensor(&leftEncoder);
  leftMotor.linkDriver(&leftDriver);
  leftMotor.controller = MotionControlType::velocity;
  leftMotor.PID_velocity.P = Kp;
  leftMotor.PID_velocity.I = Ki;
  leftMotor.PID_velocity.D = Kd;
  leftMotor.initFOC();

  // 右轮初始化（参数与左轮相同）
  rightMotor.linkSensor(&rightEncoder);
  rightMotor.linkDriver(&rightDriver);
  rightMotor.controller = MotionControlType::velocity;
  rightMotor.PID_velocity.P = Kp;
  rightMotor.PID_velocity.I = Ki;
  rightMotor.PID_velocity.D = Kd;
  rightMotor.initFOC();

  Serial.begin(115200);
}

void loop() {
  // 模拟通过IMU或编码器融合获取当前朝向（此处简化处理）
  currentHeading += (leftMotor.shaft_velocity - rightMotor.shaft_velocity) * 0.1; 
  currentHeading = fmod(currentHeading, 360); // 角度归一化

  // 计算转向误差
  float error = targetHeading - currentHeading;
  error = (error > 180) ? error - 360 : (error < -180) ? error + 360 : error; // 处理角度跳变

  // 差速转向：误差越大，左右轮速度差越大
  float baseSpeed = 5.0; // 基础速度（rad/s）
  float turnGain = 0.8;  // 转向增益
  float leftSpeed = baseSpeed - error * turnGain;
  float rightSpeed = baseSpeed + error * turnGain;

  leftMotor.move(leftSpeed);
  rightMotor.move(rightSpeed);

  Serial.print("Heading: "); Serial.print(currentHeading);
  Serial.print(" Error: "); Serial.println(error);
  delay(20);
}

2、基于IMU的闭环差速转向（融合加速度计+陀螺仪）

#include <SimpleFOC.h>
#include <MPU6050.h> // IMU库

// 电机和驱动器配置同案例1
MPU6050 imu; // IMU对象

float targetHeading = 0.0; // 目标朝向（初始为0度）
float currentHeading = 0;
float gyroOffset = 0; // 陀螺仪零偏补偿

void setup() {
  // 电机初始化同案例1
  imu.initialize();
  imu.setFullScaleGyroRange(MPU6050_GYRO_FS_250); // 设置陀螺仪量程
  calibrateGyro(); // 校准陀螺仪零偏
  Serial.begin(115200);
}

void calibrateGyro() {
  float sum = 0;
  for (int i = 0; i < 100; i++) {
    sum += imu.getRotationY(); // 读取Y轴陀螺仪数据（假设绕Z轴旋转）
    delay(10);
  }
  gyroOffset = sum / 100;
}

void loop() {
  // 读取IMU数据
  float gyroRate = imu.getRotationY() - gyroOffset; // 角速度（度/s）
  float accelZ = imu.getAccelerationZ(); // Z轴加速度（用于水平校准）

  // 互补滤波融合陀螺仪和加速度计（简化版）
  static float alpha = 0.98; // 滤波系数
  currentHeading = alpha * (currentHeading + gyroRate * 0.02) + (1 - alpha) * atan2(
    imu.getAccelerationY(), 
    imu.getAccelerationX()
  ) * 180 / PI;

  // 目标朝向控制（例如通过串口接收目标角度）
  if (Serial.available() > 0) {
    targetHeading = Serial.parseFloat();
  }

  // 差速转向PID（同案例1）
  float error = targetHeading - currentHeading;
  error = (error > 180) ? error - 360 : (error < -180) ? error + 360 : error;

  float baseSpeed = 3.0;
  float turnGain = 0.6;
  leftMotor.move(baseSpeed - error * turnGain);
  rightMotor.move(baseSpeed + error * turnGain);

  Serial.print("Heading: "); Serial.print(currentHeading);
  Serial.print(" Target: "); Serial.println(targetHeading);
  delay(20);
}

3、基于路径跟踪的纯追踪转向算法

#include <SimpleFOC.h>
#include <Vector2.h> // 自定义二维向量库

// 电机配置同案例1
Vector2 robotPos(0, 0); // 机器人当前位置（单位：米）
float robotHeading = 0; // 当前朝向（弧度）
float lookaheadDistance = 0.3; // 预瞄距离

// 模拟路径点（实际应用中可通过SLAM或导航算法获取）
Vector2 path[] = {{0, 0}, {1, 1}, {2, 0}, {3, 1}};
int pathIndex = 0;

void setup() {
  // 电机初始化同案例1
  Serial.begin(115200);
}

void loop() {
  // 假设通过编码器或里程计更新机器人位置和朝向（此处简化处理）
  static float counter = 0;
  robotPos.x += 0.01 * cos(robotHeading);
  robotPos.y += 0.01 * sin(robotHeading);
  counter += 0.01;
  if (counter > 1.0) {
    robotHeading += 0.5; // 模拟机器人转向
    counter = 0;
  }

  // 纯追踪算法：计算目标路径点
  Vector2 targetPoint;
  float minDist = INFINITY;
  for (int i = pathIndex; i < sizeof(path)/sizeof(path[0]); i++) {
    float dist = path[i].distanceTo(robotPos);
    if (dist < minDist) {
      minDist = dist;
      targetPoint = path[i];
    }
  }

  // 预瞄点选择
  if (minDist > lookaheadDistance) {
    // 在路径上找到预瞄点
    Vector2 dir = targetPoint - robotPos;
    dir.normalize();
    targetPoint = robotPos + dir * lookaheadDistance;
  } else {
    pathIndex++; // 切换到下一个路径点
  }

  // 计算目标朝向（预瞄点与机器人位置的夹角）
  Vector2 delta = targetPoint - robotPos;
  float targetHeading = atan2(delta.y, delta.x);

  // 差速转向控制
  float error = targetHeading - robotHeading;
  error = (error > PI) ? error - 2*PI : (error < -PI) ? error + 2*PI : error; // 弧度归一化

  float baseSpeed = 2.0;
  float turnGain = 1.0;
  leftMotor.move(baseSpeed - error * turnGain);
  rightMotor.move(baseSpeed + error * turnGain);

  Serial.print("Pos: ("); Serial.print(robotPos.x);
  Serial.print(","); Serial.print(robotPos.y);
  Serial.print(") Heading: "); Serial.println(robotHeading * 180 / PI);
  delay(20);
}

技术解读
差速运动学模型
转向原理：通过左右轮速度差实现转向，转弯半径 。
案例1中通过直接调整速度差实现转向，案例3中通过纯追踪算法动态计算目标速度差。
传感器融合与姿态估计
案例2使用IMU（陀螺仪+加速度计）通过互补滤波融合数据，解决陀螺仪积分漂移和加速度计噪声问题。
实际应用中可扩展至卡尔曼滤波（如EKF）或磁力计（解决俯仰角影响）。
闭环控制与PID调参
案例1和案例2均采用PID控制速度环，需根据电机特性调整消除静态误差。
路径跟踪算法优化
案例3的纯追踪算法通过预瞄距离平衡跟踪精度与转向平滑性，需根据车速动态调整预瞄距离（车速越高，预瞄距离越大）。
可扩展为动态窗口法（DWA）或模型预测控制（MPC）处理动态障碍物。
硬件与执行层优化
电机选型：选择低齿槽转矩（Cogging Torque）的BLDC电机，减少转向时的抖动。
编码器分辨率：高分辨率编码器（如1000PPR以上）可提高速度反馈精度。
电源管理：差速驱动需独立驱动左右轮，避免电源干扰导致单侧电机失速。

4、基础差速运动学解算与闭环控制
功能描述：这是最通用的差速驱动模型。通过设定机器人的线速度（ vv ）和角速度（ ωω ），利用运动学公式解算出左右轮的目标转速，并结合编码器反馈实现 PID 闭环控制，确保转向精准。

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

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

// --- 硬件定义 ---
Encoder encLeft(2, 3);
Encoder encRight(18, 19);
const int motorLeftPin = 9;
const int motorRightPin = 10;

// --- 控制变量 ---
double target_v = 0.5;   // 目标线速度 (m/s)
double target_omega = 0.3; // 目标角速度 (rad/s), >0 左转, <0 右转

// PID 变量
double inputL, outputL, setpointL;
double inputR, outputR, setpointR;
PID pidLeft(&inputL, &outputL, &setpointL, 1.5, 0.5, 0.1, DIRECT);
PID pidRight(&inputR, &outputR, &setpointR, 1.5, 0.5, 0.1, DIRECT);

void setup() {
  Serial.begin(115200);
  pidLeft.SetMode(AUTOMATIC);
  pidRight.SetMode(AUTOMATIC);
  pidLeft.SetOutputLimits(-255, 255);
  pidRight.SetOutputLimits(-255, 255);
}

void loop() {
  // 1. 运动学逆解算
  // 左轮速度 = 线速度 - 角速度 * 轮距 / 2
  float v_left = target_v - (target_omega * WHEEL_BASE / 2.0);
  // 右轮速度 = 线速度 + 角速度 * 轮距 / 2
  float v_right = target_v + (target_omega * WHEEL_BASE / 2.0);

  // 线速度转 RPM: RPM = (v / (2 * PI * r)) * 60
  setpointL = (v_left / (2 * PI * WHEEL_RADIUS)) * 60.0;
  setpointR = (v_right / (2 * PI * WHEEL_RADIUS)) * 60.0;

  // 2. 读取编码器计算实际 RPM (简化版)
  inputL = read_rpm(encLeft);
  inputR = read_rpm(encRight);

  // 3. PID 闭环计算
  pidLeft.Compute();
  pidRight.Compute();

  // 4. 驱动电机
  analogWrite(motorLeftPin, outputL);
  analogWrite(motorRightPin, outputR);

  // 调试输出
  Serial.print("L_RPM: "); Serial.print(inputL);
  Serial.print(" R_RPM: "); Serial.println(inputR);
  
  delay(10);
}

// 辅助函数：读取 RPM
float read_rpm(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;
}

5、阿克曼转向几何模拟（虚拟转向中心）
功能描述：虽然差速驱动没有物理转向轴，但在大半径转弯时，为了模拟汽车般的平滑转向（减少轮胎磨损和侧滑），我们可以引入“虚拟转向中心”的概念。通过计算内外轮的转速比，使机器人绕着某个虚拟圆心旋转。

// --- 转向参数 ---
float turnRadius = 1.0; // 虚拟转向半径 (米)，越小转得越急
float baseSpeed = 0.5;  // 基础行驶速度 (m/s)

void loop() {
  // 1. 计算阿克曼几何下的内外轮速度
  // 假设绕左侧某点转向，左轮为内侧，右轮为外侧
  // 内侧轮速度 = 基础速度 * (R - L/2) / R
  // 外侧轮速度 = 基础速度 * (R + L/2) / R
  
  float v_inner = baseSpeed * (turnRadius - WHEEL_BASE/2) / turnRadius;
  float v_outer = baseSpeed * (turnRadius + WHEEL_BASE/2) / turnRadius;

  // 2. 确定左右轮速度
  float leftSpeed, rightSpeed;
  if (turnRadius > 0) {
    // 左转：左内右外
    leftSpeed = v_inner;
    rightSpeed = v_outer;
  } else {
    // 右转：右内左外 (取绝对值计算)
    float r_abs = abs(turnRadius);
    rightSpeed = baseSpeed * (r_abs - WHEEL_BASE/2) / r_abs;
    leftSpeed = baseSpeed * (r_abs + WHEEL_BASE/2) / r_abs;
  }

  // 3. 原地旋转特例
  if (turnRadius == 0) {
    // 原地左转：左轮后退，右轮前进
    leftSpeed = -baseSpeed;
    rightSpeed = baseSpeed;
  }

  // 4. 转换为 RPM 并驱动 (同案例一逻辑)
  // setMotorRPM(LEFT, leftSpeed);
  // setMotorRPM(RIGHT, rightSpeed);
  
  Serial.print("Turn Radius: "); Serial.print(turnRadius);
  Serial.print(" | L_Speed: "); Serial.print(leftSpeed);
  Serial.print(" R_Speed: "); Serial.println(rightSpeed);
  
  delay(20);
}

6、带速度补偿的平滑转向（防止掉速）
功能描述：在差速转向时，由于负载分配不均或摩擦力变化，机器人往往会发生“掉速”现象（转弯时整体速度变慢）。本案例通过实时监测两轮速度，动态补偿基础速度，确保转弯时机器人的平均速度保持恒定。

// --- 补偿参数 ---
float target_avg_speed = 0.5; // 期望的平均速度
float k_comp = 0.5;           // 补偿系数

void loop() {
  // 1. 基础差速计算
  float v_left = target_avg_speed - (target_omega * WHEEL_BASE / 2.0);
  float v_right = target_avg_speed + (target_omega * WHEEL_BASE / 2.0);

  // 2. 速度补偿逻辑
  // 读取当前实际平均速度
  float current_avg = (read_rpm(encLeft) + read_rpm(encRight)) / 2.0 * (2*PI*WHEEL_RADIUS/60.0);
  
  // 计算速度误差
  float speed_error = target_avg_speed - current_avg;
  
  // 动态补偿：如果转弯导致掉速，按比例增加两轮的目标速度
  float compensation = speed_error * k_comp;
  
  v_left += compensation;
  v_right += compensation;

  // 3. 限制最大速度 (防止补偿过大导致超速)
  // ... (添加 constrain 函数)

  // 4. 转换为 RPM 并驱动
  // setMotorRPM(LEFT, v_left);
  // setMotorRPM(RIGHT, v_right);

  Serial.print("Compensation: "); Serial.println(compensation);
  delay(10);
}

要点解读
差速运动学的数学本质
案例4展示了差速驱动的基石。
阿克曼几何的虚拟应用
案例5虽然用于差速底盘，但引入了阿克曼转向的思想。在差速驱动中，我们通常直接控制角速度，但在需要平滑大半径转弯（如 AGV 沿弧线行驶）时，计算内外轮的速差比能有效减少轮胎侧滑，延长电机寿命。
闭环控制的重要性
开环控制（直接给 PWM）在转向时极易失效，因为左右轮负载往往不一致（如地面摩擦系数不同）。案例4中的 PID 闭环能确保左轮真的跑到 100 RPM，右轮真的跑到 150 RPM，从而保证转向半径的精准度。
速度补偿对抗“掉速”
案例6解决了一个常见痛点：机器人一转弯就变慢。这是因为转向时电机负载增加。通过引入平均速度反馈，动态提升两轮的目标速度，可以抵消这种负载效应，实现“匀速转向”，这对于需要保持节拍的工业 AGV 尤为重要。
原地旋转的特殊处理在差速驱动中，当转向半径 R=0
R=0 时，理论上角速度无穷大。代码中需要单独处理这种情况（案例5中的 if (turnRadius == 0)），强制左轮反转、右轮正转，以实现零半径转向，这是 AGV 在狭窄仓库中调头或避障的关键能力。

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