Arduino BLDC之机器人主速度-从扭矩同步模式，是一套通过"主轴定速、从轴出力"的非对称控制架构，将刚性连接双电机间的"速度互搏"转化为"柔性跟随"的协同驱动方案，其核心优势在于以扭矩闭环替代速度闭环消除机械内力，主要适用于双驱AGV、同步升降机构及重载搬运等场景，但落地时需重点攻克同步增益标定、编码器精度匹配与通信延迟三大工程难题。

1、系统架构与技术原理
该方案的核心思想是打破双电机"对称控制"的惯性思维，采用非对称的主从分工架构：
主轴（Master）：运行在FOC速度模式下，作为整个系统的"速度基准源"。主轴通过PID速度环精确跟踪目标速度，同时通过编码器实时输出自身的角度和速度信息，作为从轴的同步参考信号。
从轴（Slave）：运行在FOC扭矩（电流）模式下，而非速度模式。从轴不追求"转速一致"，而是根据主轴与自身的位置/速度误差，动态调整输出扭矩，实现"柔性跟随"。其控制公式可简化为：T_slave = T_base + Kp × (θ_master - θ_slave)，其中T_base为基础跟随扭矩，Kp为同步增益系数。
FOC底层执行：两轴均基于FOC（磁场定向控制）实现电流环（扭矩环）→速度环→位置环的三环嵌套控制。扭矩模式直接作用于最内层电流环，响应速度最快（千赫兹级），确保从轴能实时补偿负载差异。

2、主要特点
从根本上消除"互搏"现象
互搏的成因：当两个BLDC电机刚性连接（如同一车轴、同步升降丝杠）且都运行在速度模式时，由于机械装配误差、轮径差异、地面附着力不均等因素，两轴实际转速不可能完全一致。两个速度环各自"较劲"——一个加速追赶、一个减速抵抗——形成内部环流，表现为电流激增、电机发热、机械结构承受额外应力。
主从模式的解决思路：主轴"说了算"，从轴"配合出力"。从轴不追求速度一致，而是通过扭矩补偿来消除位置误差。当从轴落后时自动加大扭矩追赶，超前时自动减小扭矩甚至反向制动，形成柔性跟随而非刚性对抗。
自适应同步补偿机制
误差驱动的动态扭矩分配：从轴的扭矩输出由"基础扭矩+同步补偿扭矩"两部分组成。基础扭矩保证从轴始终有正向驱动力，同步补偿扭矩根据主轴与从轴的实时角度差（或速度差）动态调整，误差越大补偿越强。
补偿量限幅保护：同步补偿扭矩必须设置上下限（如constrain(sync_torque, -0.2, 0.2)），防止极端工况下补偿量过大导致从轴过流或机械冲击。
负载自适应：当一侧轮子遇到障碍物或地面附着力突变时，从轴扭矩自动增大以维持同步，无需人工干预或上层调度介入。
机械应力最小化
消除内部环流：传统双速度模式下，两电机间的"推拉"会在传动轴、齿轮箱、联轴器上产生持续的交变应力，长期运行导致机械疲劳。主从模式下，从轴始终以扭矩方式"顺应"主轴，机械内力趋近于零。
延长传动机构寿命：对于丝杠同步升降、链条传动等多电机刚性耦合机构，主从模式可显著降低齿轮啮合冲击和链条张力波动。
控制层次清晰、调试友好
三层解耦架构：上层给出速度指令（V, ω），中层主从分配器计算各轴扭矩，底层FOC电流环执行。各层职责明确，避免"在分配器里又限速又限流又PID"的耦合混乱。
调参口诀：先稳主轴速度环，再调从轴同步增益，最后微调基础扭矩。内环（电流环）稳定是外环（速度环、同步环）可靠的前提。

3、典型应用场景
双驱AGV/AMR底盘
两台BLDC电机分别驱动左右驱动轮，通过刚性车轴或独立悬挂连接。主从模式下，主轴控制直线行驶速度，从轴根据左右轮的实际转速差动态调整扭矩，实现类似"电子差速器"的效果——转弯时外侧轮自动获得更多扭矩，内侧轮减少扭矩，避免轮胎拖滑和车体偏航。
同步升降机构（双丝杠/双链条）
在舞台升降平台、立体仓库提升机等场景中，两侧丝杠必须严格同步，否则平台倾斜甚至卡死。主轴控制升降速度，从轴根据两侧位置偏差动态补偿扭矩，确保两侧丝杠始终同步运行。
重载搬运机器人
在搬运大尺寸、大重量工件时，多个驱动电机共同承载。主从模式确保各电机出力均衡，避免因负载分配不均导致某一电机过载而其他电机"空转"。
履带式机器人差速转向
履带机器人的左右履带通过各自的BLDC电机驱动。主从模式下，直线行驶时从轴柔性跟随主轴；转向时，上层控制器调整主轴速度，从轴根据差速需求自动调整扭矩，实现平滑的弧线转向而非生硬的原地旋转。
教育科研与算法验证
作为多电机协同控制的教学实验平台，学生可直观对比"双速度模式"与"主速度-从扭矩模式"的电流波形、温度变化和机械振动差异，深入理解电机协同控制的工程本质。

4、注意事项与关键技术挑战
同步增益（Kp）的标定
痛点：同步增益过小，从轴跟随迟缓，位置误差持续累积；增益过大，从轴响应过激，产生扭矩振荡甚至系统不稳定。
对策：先在空载条件下逐步增大Kp，观察从轴扭矩波形是否出现高频振荡；再在额定负载下微调，确保同步误差在允许范围内且无超调。建议使用串口绘图器实时观察angle_error和sync_torque的变化趋势。
编码器精度与安装一致性
痛点：主从同步的核心依赖编码器反馈的位置/速度信息。若两轴编码器分辨率不同、安装偏心或零点未对齐，会导致"虚假误差"，从轴持续输出不必要的补偿扭矩。
对策：两轴必须使用同型号、同分辨率的编码器；安装时严格对中，确保联轴器无间隙；上电后执行"零点校准"程序，将两轴编码器零点统一到同一机械参考位置。
控制周期与实时性
痛点：主从同步要求主轴状态信息以足够高的频率传递给从轴。若控制周期过长（如超过50ms），PID修正滞后，机器人轨迹呈锯齿状或震荡。
对策：使用定时器中断保证控制频率的稳定性（建议≥100Hz）；若使用Arduino单MCU方案，主轴与从轴的控制循环必须在同一loop()中顺序执行，避免delay()阻塞；若使用双MCU方案，通过SPI或CAN总线实现高速状态同步。
扭矩限幅与过流保护
痛点：从轴在极端工况下（如一侧轮子卡死）可能输出过大补偿扭矩，导致电流激增烧毁驱动板。
对策：从轴扭矩输出必须加限幅（constrain(final_slave_torque, -Tmax, Tmax)）；FOC电流环设置硬件过流保护阈值；在软件中加入"电流+温度+速度"多维故障判断矩阵，异常时毫秒级切断输出。
主轴故障的级联风险
痛点：主从模式下，从轴完全依赖主轴的状态信息。若主轴编码器故障或MCU死机，从轴将失去同步基准，可能失控。
对策：启用看门狗定时器（WDT）监测主轴MCU运行状态；从轴设置"心跳超时"检测——若连续N个周期未收到主轴数据，自动切换到独立速度模式或安全停机；关键系统可采用双MCU热备冗余。
电源隔离与电磁兼容
痛点：双电机同时运行时，电流波动通过共地线路相互干扰，可能导致编码器信号失真或MCU复位。
对策：两轴电机驱动电源与逻辑控制电源物理隔离；电源入口加入大容量低ESR电解电容（≥470μF）；编码器信号线使用屏蔽双绞线，远离电机相线布线。
基础扭矩（T_base）的合理设置
痛点：基础扭矩设置过低，从轴驱动力不足，无法有效跟随主轴；设置过高，空载时从轴"推过头"，反而产生反向误差。
对策：基础扭矩应略大于从轴在额定工况下的平均负载扭矩，但不超过额定扭矩的50%。可通过空载和满载两种工况分别测试，取中间值作为初始设定，再根据实际运行微调。

1、双电机刚性连接防互搏（基础模式）
场景：双驱AGV、龙门机构等，两个电机通过齿轮或皮带刚性连接驱动同一负载。
核心逻辑：主轴运行速度模式，从轴运行扭矩模式。通过计算主轴与从轴的速度差，动态调整从轴的扭矩输出，实现柔性跟随，消除硬连接带来的应力。

#include <SimpleFOC.h>

// 电机与驱动/传感器定义 (以SimpleFOC库为例)
BLDCMotor motorMaster = BLDCMotor(7);
BLDCMotor motorSlave = BLDCMotor(7);
// ... 此处需实例化对应的驱动器和传感器对象，如driverMaster, sensorMaster等

// 控制参数
float target_velocity = 2.0;   // 主轴目标速度 (rad/s)
float sync_gain = 0.2;         // 同步补偿系数，需调试
float base_torque = 0.1;       // 从轴基础扭矩

void setup() {
    // 1. 初始化主轴 (速度模式)
    motorMaster.controller = MotionControlType::velocity;
    motorMaster.linkDriver(&driverMaster);
    motorMaster.linkSensor(&sensorMaster);
    motorMaster.init();
    motorMaster.initFOC();

    // 2. 初始化从轴 (扭矩模式)
    motorSlave.controller = MotionControlType::torque;
    motorSlave.linkDriver(&driverSlave);
    motorSlave.linkSensor(&sensorSlave);
    motorSlave.init();
    motorSlave.initFOC();
}

void loop() {
    // 主轴：执行速度闭环
    motorMaster.loopFOC();
    motorMaster.move(target_velocity);

    // 从轴：执行扭矩闭环，并计算补偿扭矩
    motorSlave.loopFOC();
    
    // 获取主轴和从轴的实际速度
    float vel_error = motorMaster.shaft_velocity - motorSlave.shaft_velocity;
    
    // 核心：根据速度差计算补偿扭矩，叠加到基础扭矩上
    float compensation_torque = vel_error * sync_gain;
    float final_torque = base_torque + compensation_torque;
    final_torque = constrain(final_torque, -2.0, 2.0); // 限幅保护

    motorSlave.move(final_torque);
    
    delay(10); // 控制循环周期
}

说明：本案例代码基于SimpleFOC库框架编写。实际使用时，需根据你的硬件（驱动板、编码器）正确配置BLDCMotor、BLDCDriver3PWM和传感器对象。

2、基于CAN总线的多轴同步跟随（高级网络化）
场景：印刷机辊轴、多关节机器人等，需要多台电机在空间上严格同步运动。
核心逻辑：一个主控节点通过CAN总线广播同步指令（目标位置/速度），多个从节点接收指令并各自运行闭环控制，同时反馈状态，实现分布式高精度同步。

#include <SPI.h>
#include <MCP2515.h>

MCP2515 canBus(10, 2); // CS, INT
// ... 主电机PID与驱动初始化 (略)

void loop() {
    // 1. 主电机自身双环控制 (位置环+速度环)
    // ... mainPosPID计算，输出PWM等

    // 2. 构建并广播CAN同步帧 (ID: 0x100)
    CanMsg syncMsg;
    syncMsg.id = 0x100;
    syncMsg.data[0] = (uint8_t)(target_position >> 8);
    syncMsg.data[1] = (uint8_t)(target_position & 0xFF);
    syncMsg.data[2] = (uint8_t)(target_velocity >> 8);
    syncMsg.data[3] = (uint8_t)(target_velocity & 0xFF);
    canBus.sendMessage(syncMsg);

    // 3. 接收从机反馈，检查同步误差
    if (canBus.available()) {
        CanMsg feedback = canBus.readMessage();
        // 解析从机位置，若误差超限则发送调整指令
        float slave_pos = (feedback.data[0] << 8) | feedback.data[1];
        if (abs(target_position - slave_pos) > 5.0) {
            canBus.sendMessage(createAdjustFrame(error));
        }
    }
    delay(10);
}
从节点代码 (Arduino Uno)：

cpp
#include <SPI.h>
#include <MCP2515.h>

MCP2515 canBus(10, 2);
float sync_target_pos = 0, sync_target_vel = 0;
// ... 从电机PID与驱动初始化 (略)

void loop() {
    if (canBus.available()) {
        CanMsg msg = canBus.readMessage();
        if (msg.id == 0x100) { // 收到同步帧
            sync_target_pos = (msg.data[0] << 8) | msg.data[1];
            sync_target_vel = (msg.data[2] << 8) | msg.data[3];
        }
    }
    
    // 运行从机的双环控制，目标值来自CAN同步帧
    slavePosPID.SetTarget(sync_target_pos);
    // ... 执行PID计算并输出PWM

    // 定期向主节点反馈自身状态
    // ...
}

3、仿人机器人膝关节阻抗与相位协同（仿生柔顺）
场景：仿生机器人、外骨骼的关节，需要根据不同步态相位（支撑相/摆动相）切换控制模式，实现柔顺且稳定的运动。
核心逻辑：利用阻抗控制模拟弹簧-阻尼模型，将位置误差转化为力矩输出。在支撑相提供“柔性支撑”，在摆动相进行位置跟踪，本质是力矩模式的一种高级应用。

#include <SimpleFOC.h>
#include <Encoder.h>

// 硬件初始化 (略)
BLDCMotor kneeMotor = BLDCMotor(7);
Encoder kneeEncoder(2, 3, 1000);

float gaitPhase = 0; // 0=支撑相，1=摆动相
float stance_stiffness = 1.5; // 支撑相刚度 (Nm/rad)
float swing_target_angle = -0.5; // 摆动相目标角度 (rad)

void setup() {
    // ... 电机、编码器、驱动初始化
    kneeMotor.controller = MotionControlType::torque; // 核心：使用扭矩模式
    // ... init() 和 initFOC()
}

void loop() {
    kneeMotor.loopFOC();
    float current_angle = kneeEncoder.getAngle();

    // 步态相位切换 (简化为2秒周期)
    if (millis() % 4000 < 2000) gaitPhase = 0; else gaitPhase = 1;

    // 核心：根据相位生成不同的控制力矩
    if (gaitPhase == 0) { 
        // 支撑相：阻抗控制 (位置误差 -> 力矩)
        float angle_error = 0 - current_angle; // 目标为直立(0 rad)
        float torque_cmd = -angle_error * stance_stiffness; // 虚拟弹簧
        kneeMotor.move(torque_cmd);
    } else { 
        // 摆动相：可以切换为位置控制，或继续用力矩模式追踪轨迹
        // 此处示意使用扭矩追踪一个轨迹
        float target_torque = (swing_target_angle - current_angle) * 1.0; 
        kneeMotor.move(target_torque);
    }
    delay(10);
}

要点解读
控制模式是基石：实现防“互搏”和柔性协同，从轴（或执行关节）必须运行在扭矩（Torque）或电流（Current）模式，而不是速度或位置模式。只有控制“力”，电机才具备“柔顺性”，才能被主轴“牵引”着走，从而消化掉机械上的微小位置差异。

“虚拟弹簧”的柔性连接：让从轴跟随主轴的实质，是在软件中构建一个“虚拟弹簧”。案例一中的vel_error * sync_gain和案例三中的angle_error * stance_stiffness都是如此——位置或速度偏差越大，“弹簧”产生的纠正力矩就越强，使两者维持动态平衡。增益sync_gain过大，弹簧太硬会导致震荡；过小则同步刚度不足。

同步误差的动态监测：系统稳定运行依赖于对同步误差的实时监控。案例二中，主节点定期接收从节点反馈，检查同步误差是否超限。更完善的系统甚至可以根据误差大小自适应调整PID增益，使系统在不同负载下保持一致的同步精度。

通信总线决定同步天花板：对于严格的多轴同步（如工业机器人），必须使用CAN FD、EtherCAT等具备广播和同步机制的工业总线。Arduino的UART或I2C在实时性和抗干扰性上无法满足需求。CAN总线的广播帧机制天然支持“一发多收”，是实现分布式同步控制的绝佳选择。

安全与物理限制是底线：在力矩模式下，必须为电机的扭矩输出设置安全限幅（如案例一中的constrain函数）。因为在刚性连接场景下，失控的力矩输出可能导致机械结构损坏。同时，应设置软件限位、过流保护和独立的硬件急停逻辑，作为系统安全的最后一道防线。

4、机械臂关节主从协同控制系统——解决机械臂多关节刚性互搏
适用场景：工业机械臂、协作机器人的关节协同控制，主关节（如基座旋转关节）按设定速度运行，从关节（如大臂俯仰关节）根据主关节速度实时调整扭矩，避免刚性连杆因速度不同步导致的关节互搏（如主关节加速时，从关节因扭矩不匹配产生拉扯）。

核心设计：
主从角色定义：主关节采用速度控制模式，按目标轨迹运行；从关节采用扭矩同步模式，根据主关节速度动态计算目标扭矩；
互搏抑制算法：引入扭矩误差PID闭环，实时补偿主从速度偏差导致的扭矩差，确保从关节扭矩与主关节速度匹配；
通信与反馈：通过CAN总线实现主从关节的状态同步，主关节广播速度，从关节反馈实际扭矩，形成闭环控制。

/* 机械臂关节主从协同控制系统
   核心逻辑：主关节速度控制，从关节扭矩同步，避免刚性连杆互搏
   硬件：Arduino Mega + 2路BLDC电机 + CAN收发器 + 电流传感器
   参数：主关节目标速度50rpm，扭矩误差闭环PID系数Kp=0.8, Ki=0.1, Kd=0.05
*/

#include <CAN.h>
#include <PID_v1.h>

// --- 硬件引脚与参数定义 ---
#define CAN_CS 10
#define MOTOR_MAIN_PWM 3
#define MOTOR_SLAVE_PWM 4
#define CURRENT_SENSOR_MAIN A0 // 主电机电流（换算扭矩）
#define CURRENT_SENSOR_SLAVE A1 // 从电机电流（换算扭矩）

// --- 核心参数 ---
const float MAIN_TARGET_SPEED = 50; // 主关节目标速度（rpm）
const float TORQUE_SCALE = 0.01; // 电流到扭矩的换算系数（A→N·m）

// --- 变量声明 ---
float mainActualSpeed = 0;
float slaveTargetTorque = 0;
float slaveActualTorque = 0;
float torqueError = 0;

// PID控制器：扭矩误差闭环
PID torquePID(&torqueError, &slaveTargetTorque, 0, 0.8, 0.1, 0.05, 20);

// CAN消息结构
struct JointMessage {
  float speed;
  float torque;
  unsigned long timestamp;
};

void setup() {
  Serial.begin(9600);
  pinMode(CAN_CS, OUTPUT);
  digitalWrite(CAN_CS, HIGH);
  
  // 初始化CAN通信（500kbps）
  if (!CAN.begin(500000)) {
    Serial.println("CAN初始化失败");
    while (1);
  }
  
  // 主关节：速度PID初始化
  mainSpeedPID.SetMode(AUTOMATIC);
  mainSpeedPID.SetOutputLimits(0, 255);
  
  // 从关节：扭矩PID初始化
  torquePID.SetMode(AUTOMATIC);
  torquePID.SetOutputLimits(0, 255);
  
  Serial.println("机械臂主从协同系统启动");
}

void loop() {
  // 1. 主关节：速度控制闭环
  mainActualSpeed = readSpeedSensor(); // 读取主关节编码器速度
  mainSpeedPID.Compute(mainActualSpeed, MAIN_TARGET_SPEED);
  analogWrite(MOTOR_MAIN_PWM, mainSpeedPID.GetOutput());

  // 2. 从关节：扭矩同步计算
  slaveActualTorque = analogRead(CURRENT_SENSOR_SLAVE) * TORQUE_SCALE;
  // 扭矩误差=主关节速度对应的理论扭矩 - 从关节实际扭矩
  torqueError = map(mainActualSpeed, 0, MAIN_TARGET_SPEED, 0, 1.5) - slaveActualTorque;
  torquePID.Compute(torqueError, slaveTargetTorque);
  analogWrite(MOTOR_SLAVE_PWM, torquePID.GetOutput());

  // 3. CAN总线主从同步
  JointMessage msg;
  msg.speed = mainActualSpeed;
  msg.torque = slaveTargetTorque;
  msg.timestamp = millis();
  // 主关节广播状态，从关节接收后校准（若从关节作为接收端，需补充接收逻辑）
  CAN.beginPacket();
  CAN.write((uint8_t*)&msg, sizeof(msg));
  CAN.endPacket();

  // 4. 互搏监测：若扭矩误差超过阈值，强制降速
  if (abs(torqueError) > 0.5) {
    Serial.println("检测到刚性互搏，启动保护！");
    analogWrite(MOTOR_MAIN_PWM, analogRead(MOTOR_MAIN_PWM) * 0.5);
  }

  delay(20); // 控制循环频率50Hz
}

// 读取速度传感器（模拟编码器输出）
float readSpeedSensor() {
  // 简化实现，实际需对接编码器接口
  static float speed = 0;
  speed += 2.0;
  if (speed > MAIN_TARGET_SPEED) speed = MAIN_TARGET_SPEED;
  return speed;
}

5、轮式机器人差速驱动主从同步系统——解决差速轮刚性互搏
适用场景：轮式移动机器人（如AGV、巡检机器人）的差速驱动控制，主轮（主动力轮）按目标速度运行，从轮（辅助从动轮）根据主轮速度同步扭矩，避免刚性差速结构下因主从轮速度不匹配导致的齿轮互搏（如主轮加速时，从轮因扭矩滞后产生啮合冲击）。

核心设计：
差速同步模式：主轮采用速度控制，从轮采用扭矩同步，根据主轮速度计算从轮目标扭矩，确保从轮速度与主轮匹配；
扭矩与速度关联模型：基于轮式机器人差速原理，建立主轮速度→从轮目标扭矩的映射关系，实现扭矩与速度的线性同步；
互搏抑制触发：当从轮扭矩误差超过阈值时，主动降低主轮速度，避免刚性冲击。

/* 轮式机器人差速驱动主从同步系统
   核心逻辑：主轮速度控制，从轮扭矩同步，消除差速轮刚性互搏
   硬件：ESP32 + 2路BLDC电机 + 霍尔编码器 + 电流传感器
   参数：主轮目标速度60rpm，从轮扭矩同步系数K=0.02
*/

#include <SimpleFOC.h>

// --- 硬件引脚定义 ---
#define MOTOR_MAIN_PWM 12
#define MOTOR_SLAVE_PWM 13
#define ENC_MAIN_A 32
#define ENC_MAIN_B 33
#define CURRENT_SENSOR_SLAVE 35

// --- 核心参数 ---
const float MAIN_TARGET_SPEED = 60; // 主轮目标速度（rpm）
const float SYNC_K = 0.02; // 主轮速度到从轮扭矩的同步系数

// --- 变量声明 ---
float mainSpeed = 0, mainVelocity = 0;
float slaveTorque = 0, slaveActualCurrent = 0;

// BLDC电机对象
BLDCMotor mainMotor = BLDCMotor(11);
BLDCDriver3PWM mainDriver = BLDCDriver3PWM(9, 10, 11, 8);
BLDCMotor slaveMotor = BLDCMotor(11);
BLDCDriver3PWM slaveDriver = BLDCDriver3PWM(9, 10, 11, 8);

// 编码器对象
Encoder encMain = Encoder(ENC_MAIN_A, ENC_MAIN_B, 2048);

void setup() {
  Serial.begin(115200);
  
  // 初始化主电机（速度控制）
  mainDriver.init();
  mainMotor.linkDriver(&mainDriver);
  mainMotor.init();
  mainMotor.initFOC();
  mainMotor.target = MAIN_TARGET_SPEED; // 速度控制目标

  // 初始化从电机（扭矩控制）
  slaveDriver.init();
  slaveMotor.linkDriver(&slaveDriver);
  slaveMotor.init();
  slaveMotor.initFOC();

  // 初始化编码器
  encMain.init();
  
  Serial.println("差速驱动主从同步系统启动");
}

void loop() {
  // 1. 读取主轮速度（编码器反馈）
  encMain.update();
  mainVelocity = encMain.getVelocity(); // 单位：脉冲/秒，换算为rpm
  mainSpeed = mainVelocity * 60 / 2048; // 编码器一圈2048脉冲

  // 2. 从轮扭矩同步计算
  slaveActualCurrent = analogRead(CURRENT_SENSOR_SLAVE);
  // 目标扭矩=主轮速度×同步系数（线性映射）
  slaveTorque = mainSpeed * SYNC_K;
  // 扭矩闭环控制（简化为电流控制，实际需PID闭环）
  slaveMotor.target = map(slaveTorque, 0, 2.0, 0, 255);
  slaveMotor.move(slaveMotor.target);

  // 3. 主轮速度控制
  mainMotor.move(mainMotor.target);

  // 4. 互搏监测与保护
  if (abs(slaveTorque - slaveActualCurrent * 0.01) > 0.3) {
    Serial.println("差速轮互搏预警，降低主轮速度");
    mainMotor.target *= 0.8; // 主轮降速20%
    delay(500);
    mainMotor.target = MAIN_TARGET_SPEED; // 恢复目标速度
  }

  // 执行FOC控制
  mainMotor.loopFOC();
  slaveMotor.loopFOC();

  delay(10); // 100Hz控制频率
}

6、多机器人协作装配主从同步系统——解决协作装配的刚性互搏
适用场景：多机器人协作装配场景（如汽车生产线，主机器人负责抓取工件，从机器人负责对接装配），主机器人按速度轨迹运行，从机器人根据主机器人速度同步调整装配扭矩，避免因刚性装配导致的机器人关节互搏（如主机器人进给时，从机器人扭矩不匹配产生挤压或拉扯）。

核心设计：
协作同步协议：通过无线通信（如ESP-NOW）实现主机器人向从机器人广播速度指令，从机器人接收后计算目标扭矩；
柔性装配逻辑：从机器人扭矩与主机器人速度关联，主机器人速度越快，从机器人扭矩同步提升，确保装配力与进给速度匹配；
互搏应急处理：当从机器人扭矩误差超过阈值时，主从机器人同时降速，实现柔性保护。

#include <esp_now.h>
#include <WiFi.h>
#include <SimpleFOC.h>

/* 多机器人协作装配主从同步系统
   核心逻辑：主机器人广播速度，从机器人扭矩同步，消除协作装配的刚性互搏
   硬件：2台ESP32（主/从）+ BLDC电机 + 扭矩传感器 + ESP-NOW通信
   参数：主机器人速度0-100rpm，从机器人扭矩同步系数K=0.05
*/

// 主机器人代码（发送速度）
#ifdef MAIN_ROBOT

// 主机器人硬件
BLDCMotor mainRobot = BLDCMotor(11);
BLDCDriver3PWM mainDriver = BLDCDriver3PWM(9, 10, 11, 8);

// 通信数据结构
struct VelocityMsg {
  float velocity;
  unsigned long timestamp;
};

// ESP-NOW接收地址（从机器人MAC）
uint8_t slaveBroadcastAddress[] = {0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC};

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  
  // 初始化ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW初始化失败");
    return;
  }
  esp_now_register_send_cb(onDataSend);

  // 初始化主机器人电机（速度控制）
  mainDriver.init();
  mainRobot.linkDriver(&mainDriver);
  mainRobot.init();
  mainRobot.initFOC();
  mainRobot.target = 50; // 目标速度50rpm
  
  Serial.println("主机器人启动，开始广播速度");
}

void loop() {
  mainRobot.move(mainRobot.target);
  mainRobot.loopFOC();

  // 广播主机器人速度
  VelocityMsg msg;
  msg.velocity = mainRobot.target;
  msg.timestamp = millis();
  esp_now_send(slaveBroadcastAddress, (uint8_t*)&msg, sizeof(msg));

  delay(20);
}

void onDataSend(uint8_t* mac_addr, esp_now_send_status_t status) {
  // 发送状态回调，可添加重发逻辑
}

#endif

// 从机器人代码（接收速度，同步扭矩）
#ifdef SLAVE_ROBOT

// 从机器人硬件
BLDCMotor slaveRobot = BLDCMotor(11);
BLDCDriver3PWM slaveDriver = BLDCDriver3PWM(9, 10, 11, 8);

// 通信数据结构
struct VelocityMsg {
  float velocity;
  unsigned long timestamp;
};

// 主机器人发送地址
uint8_t mainBroadcastAddress[] = {0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56};

float mainVelocity = 0;
float slaveTorque = 0;

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  
  // 初始化ESP-NOW
  if (esp_now_init() != ESP_OK) {
    Serial.println("ESP-NOW初始化失败");
    return;
  }
  esp_now_register_recv_cb(onDataRecv);

  // 初始化从机器人电机（扭矩控制）
  slaveDriver.init();
  slaveRobot.linkDriver(&slaveDriver);
  slaveRobot.init();
  slaveRobot.initFOC();
  
  Serial.println("从机器人启动，等待接收速度指令");
}

void loop() {
  // 从机器人扭矩同步：目标扭矩=主机器人速度×同步系数
  slaveTorque = mainVelocity * 0.05;
  slaveRobot.target = map(slaveTorque, 0, 5.0, 0, 255);
  slaveRobot.move(slaveRobot.target);
  slaveRobot.loopFOC();

  delay(20);
}

// 接收主机器人速度
void onDataRecv(const uint8_t* mac, const uint8_t* data, int len) {
  VelocityMsg msg;
  memcpy(&msg, data, sizeof(msg));
  mainVelocity = msg.velocity;
  Serial.printf("接收到主机器人速度：%.2f rpm\n", mainVelocity);
}

#endif

要点解读

1. 主从模式的刚性互搏抑制核心：速度-扭矩的动态解耦
   刚性连接下的互搏根源是主从设备的运动约束与控制模式冲突：主设备采用速度控制（主动输出动力），从设备若采用速度控制，易因刚性约束导致速度不同步，产生拉扯或挤压；而主从扭矩同步模式的核心是将从设备的控制模式从速度控制切换为扭矩同步，使从设备的扭矩输出与主设备的速度动态匹配，实现速度-扭矩的解耦。例如机械臂案例中，从关节扭矩随主关节速度线性变化，既满足刚性约束，又避免速度冲突，从根源消除互搏。

2. 主从通信协议的选择：实时性与可靠性的平衡
   主从同步的前提是主设备状态指令与从设备反馈的实时传输，通信延迟会直接导致扭矩同步滞后，引发互搏。案例中优先采用CAN总线（工业场景）和ESP-NOW（无线场景）：CAN总线具备毫秒级实时性、抗干扰能力强，适合工业机械臂、AGV等有线场景；ESP-NOW是无连接无线协议，延迟低，适合多机器人协作的无线场景。两者均避免了传统串口通信的轮询延迟，确保主设备速度指令能实时传递到从设备，同时从设备扭矩反馈能及时校正，保障同步的时效性。

3. 扭矩同步的PID闭环：误差补偿是精度保障
   扭矩同步并非简单的线性映射，实际场景中存在传感器噪声、电机特性差异、负载波动等干扰，会导致理论扭矩与实际扭矩存在误差。因此必须引入扭矩误差PID闭环，实时监测从设备实际扭矩与目标扭矩的偏差，通过PID算法动态调整输出，补偿干扰带来的误差。例如机械臂案例中，PID根据扭矩误差调整从关节PWM，确保从关节扭矩精准跟随主关节速度，避免因电机特性差异导致的同步偏差，是互搏抑制的精度保障。

4. 互搏的主动监测与保护机制：从预警到应急
   仅靠同步算法无法完全消除极端场景的互搏，需构建多层保护机制：
   互搏监测：通过扭矩误差、速度偏差等指标设定阈值，实时判断是否出现互搏风险；
   预警降速：当误差接近阈值时，主动降低主设备速度，从源头减少冲击；
   应急停机：当误差超过安全阈值时，强制主从设备停机，避免硬件损坏。例如案例1和案例2中，通过扭矩误差阈值触发降速，案例3中通过无线通信实现主从同步停机，形成完整的安全闭环，确保系统可靠性。

5. 硬件适配与参数校准：同步效果的落地基础
   Arduino BLDC平台的资源有限，主从扭矩同步的落地需解决硬件适配与参数校准问题：
   硬件资源匹配：复杂PID计算、CAN/ESP-NOW通信需选用32位MCU（如ESP32、Arduino Mega），避免8位MCU算力不足导致同步延迟；
   传感器校准：电流传感器、编码器需校准，确保速度、扭矩反馈的准确性，否则同步算法基于错误数据输出，反而加剧互搏；
   参数标定：同步系数、PID参数需根据实际负载、机械结构标定，例如案例2的同步系数需匹配轮式机器人的差速特性，案例1的PID参数需适配机械臂关节的负载惯性，参数不匹配会导致同步不稳定。

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