Arduino BLDC 之“工业机器人多轴联动 Modbus RTU 协同控制”，本质上是“上位控制器/PLC 通过 RS485 总线以 Modbus RTU 主从轮询方式，向多个 BLDC 关节驱动器下发目标位置、速度或电子齿轮比等寄存器指令，各关节驱动器在本地完成 FOC 位置/速度/电流闭环，再由上位机按插补周期协调各轴目标，实现末端轨迹跟踪”的分层控制架构：Modbus RTU 负责“跨轴指令与状态交换”，BLDC FOC 负责“单轴高精度柔顺执行”，多轴联动则由插补器、逆运动学和同步时序共同保证。 在严格意义上，Modbus RTU 只能提供逻辑级协同，不能替代 EtherCAT/CANopen 级别的硬实时分布式时钟同步；因此它更适合中低速、非硬实时插补的工业场景。

主要特点

1. Modbus RTU 提供低成本、强兼容的工业通信通道
   Modbus RTU 基于 RS485 差分传输，支持较长布线距离和较强抗干扰能力，协议结构简单，常用功能码包括 03 读保持寄存器、06 写单个寄存器、16 写多个寄存器。 在工业机器人或多轴平台中，它可以把上位控制器、PLC、HMI 与多个 BLDC 驱动器连接起来，实现参数下发、状态读取、故障查询和简单运动指令交换。
2. 多轴联动依赖“寄存器映射 + 插补周期”而非总线硬同步
   每个 BLDC 关节驱动器通常对应一个 Modbus 从站地址，寄存器空间中会映射目标位置、目标速度、控制字、状态字、报警码、电流/温度反馈等字段。上位机按固定周期轮询或组播写寄存器，将插补器生成的关节角度序列下发到各轴。 但由于 Modbus RTU 是半双工主从协议，轴间同步主要靠上位机统一调度、指令预置和驱动器本地插补实现，不能达到 EtherCAT 级别的微秒级同步。
3. BLDC FOC 关节是执行层关键，保证低脉动与柔顺跟踪
   工业多轴联动对低速平稳性、启停柔顺性和转矩响应要求较高。BLDC 配合 FOC 后，电流环可抑制转矩脉动，速度环和位置环可分别跟踪上位机下发的参考轨迹。 若只使用开环 ESC 或纯 PWM 驱动，多轴在低速、换向、负载变化时容易出现抖动和不同步，末端轨迹精度会明显下降。
4. 分层架构更适合 Arduino/ESP32 平台落地
   完整系统建议分为四层：
   任务/轨迹层：给定末端位姿或工艺路径，生成笛卡尔轨迹。
   运动学/插补层：逆运动学求解关节角度，进行直线/圆弧/样条插补和 S 型速度规划。
   通信层：通过 Modbus RTU 将各轴目标位置、速度、控制字写入对应从站寄存器，并读取状态反馈。
   执行层：各 BLDC 驱动器本地运行 FOC 位置/速度/电流闭环，完成关节跟踪。
   Arduino Uno/Nano 适合做单轴 BLDC 控制、Modbus 从站节点或简单主站轮询；若要同时承担多轴逆运动学、插补、Modbus 主站调度和 FOC 闭环，更建议使用 ESP32-S3、Teensy 4.1、STM32 或 PLC/工控机作为上位控制器。
5. 可用作“参数级协同”或“低速逻辑协同”
   在部分工业伺服方案中，Modbus RTU 并不直接高频下发每毫秒级位置指令，而是用于动态修改电子齿轮比、目标速度、加减时间、位置偏置等稳态参数；实时位置闭环由驱动器本地完成。 这种用法能规避 Modbus RTU 轮询延迟带来的同步问题，更适合对硬实时要求不高的多轴协同。

应用场景
小型多关节机械臂：3~6 轴 BLDC 机械臂通过 Modbus RTU 接收关节目标角度，实现抓取、搬运、示教复现。
三轴/四轴运动平台：如小型 CNC、绘图机、点胶平台、激光雕刻平台，通过寄存器下发插补点实现多轴联动。
传送带/分拣线多轴协同：多台 BLDC 驱动辊道或分拣机构，通过 Modbus RTU 统一下发速度、启停和同步比例。
PLC + BLDC 伺服/驱动器集成：PLC 作为 Modbus 主站，BLDC 驱动器作为从站，实现参数配置、状态监控和中低速运动控制。
教学与科研验证平台：用于学习 Modbus RTU 帧结构、CRC 校验、寄存器映射、逆运动学、插补和 BLDC FOC 闭环。

需要注意的事项
Modbus RTU 不适合硬实时多轴同步
由于半双工轮询、帧间隔、从站响应时间和 CRC 校验存在延迟，多轴很难做到微秒级同步。 若需要高精度插补和严格轴间同步，应优先考虑 CANopen、EtherCAT 或脉冲+方向硬件同步。
波特率、帧间隔和超时必须统一配置
所有从站的波特率、数据位、停止位、校验方式必须一致。常见配置为 9600/19200/38400/115200 bps，8N1 或 8E1。 帧间隔不足会导致从站解析错误，超时设置过短会频繁重传，过长则降低系统响应速度。
RS485 总线需要终端匹配和方向控制
RS485 长距离布线应加终端电阻，必要时使用中继器。DE/RE 引脚需正确控制收发切换，避免总线冲突。 工业现场电磁干扰较强，建议使用屏蔽双绞线，并做好接地。
寄存器地址映射必须与驱动器手册一致
不同 BLDC 驱动器或伺服驱动器的 Modbus 寄存器地址含义不同，目标位置、控制字、状态字、报警码可能分布在保持寄存器或输入寄存器中。 写错地址可能导致误动作、无法使能或报警锁定。
轮询周期应低于插补周期，避免指令堆积
若上位机每 10 ms 生成一次插补点，但 Modbus 轮询一周需要 30 ms，则多轴目标会滞后甚至失步。应减少单帧数据量、使用写多寄存器功能码 16、合并写入，或降低插补频率。
Arduino 平台算力有限，不宜同时承担重负载计算和多轴高频轮询
ATmega328P 的 SRAM、主频和串口资源不足以支撑多轴高频 Modbus 主站、逆运动学和 FOC 同时运行。 更合理的方式是让 Arduino 做单关节控制或 Modbus 从站，由 ESP32、STM32、PLC 或上位机承担多轴协调。
必须加入使能、限位、过流和急停保护
多轴联动时，单轴故障可能引发碰撞。应在寄存器层面监控驱动器状态字，并在硬件层面保留急停回路、限位开关和过流保护。广播复位或广播停机需谨慎使用，因为从站通常不返回响应。
联动前应先完成单轴标定
每个 BLDC 关节的编码器方向、零位、减速比、运动范围和 PID/FOC 参数应单独整定。若单轴存在反向、零位漂移或增益不一致，多轴联动末端轨迹会明显偏离。

1、Arduino 主站轮询多轴 BLDC 位置指令（基础级）
场景说明：三轴直角坐标机器人或机械臂的关节空间协同。Arduino 作为 Modbus RTU 主站，通过 RS485 总线依次向三个从站驱动器（每个控制一个 BLDC 关节）发送目标位置，并读取各轴的实际位置和状态。适合 Arduino Mega 或 ESP32。

#include <ModbusRTUMaster.h>  // CMB27/ModbusRTUMaster 或类似库
#include <SimpleFOC.h>

// ===== RS485 硬件配置 =====
// 使用 Serial1 作为 Modbus RTU 总线
// DE/RE 引脚控制收发切换（半双工 RS485）
#define RS485_DE_RE 2

// ===== Modbus 从站地址 =====
#define SLAVE_AXIS_X 1
#define SLAVE_AXIS_Y 2
#define SLAVE_AXIS_Z 3

// ===== 寄存器映射（与从站约定） =====
#define REG_TARGET_POS_L  0   // 目标位置低16位
#define REG_TARGET_POS_H  1   // 目标位置高16位
#define REG_ACTUAL_POS_L  2   // 实际位置低16位
#define REG_ACTUAL_POS_H  3   // 实际位置高16位
#define REG_STATUS        4   // 状态字

// ===== 本地 BLDC（可选：Arduino 自身也驱动一轴） =====
// 若 Arduino 仅作主站，可省略以下电机配置

// ===== Modbus 主站对象 =====
ModbusRTUMaster modbus;

// ===== 三轴目标位置（编码器计数） =====
int32_t targetPos[3] = {0, 0, 0};
int32_t actualPos[3] = {0, 0, 0};

// ===== 协同控制参数 =====
float maxSpeed = 2000.0f;   // 最大速度（计数/秒）
float dt = 0.05f;           // 控制周期 50ms
float lastPos[3] = {0, 0, 0};

void setup() {
  Serial.begin(115200);       // 调试串口
  Serial1.begin(38400, SERIAL_8E1);  // Modbus RTU 总线
  modbus.begin(38400, SERIAL_8E1);   // 初始化主站

  // RS485 方向控制引脚
  pinMode(RS485_DE_RE, OUTPUT);
  digitalWrite(RS485_DE_RE, LOW);  // 默认接收模式

  Serial.println("三轴 Modbus RTU 主站就绪");
}

void loop() {
  static unsigned long lastControl = 0;
  if (millis() - lastControl < 50) return;  // 50ms 控制周期
  lastControl = millis();

  // ===== 1. 计算协同轨迹（简化为同步梯形速度） =====
  // 三轴同时以相同速度比例运动，保持姿态协调
  // 实际应用中可用多项式或S曲线规划

  for (int i = 0; i < 3; i++) {
    // 简化：匀速逼近目标
    int32_t delta = targetPos[i] - actualPos[i];
    int32_t step = (int32_t)(maxSpeed * dt);
    if (delta > step) actualPos[i] += step;
    else if (delta < -step) actualPos[i] -= step;
    else actualPos[i] = targetPos[i];
  }

  // ===== 2. 通过 Modbus 写入各轴目标位置 =====
  for (int axis = 0; axis < 3; axis++) {
    uint8_t slaveAddr = SLAVE_AXIS_X + axis;
    int32_t pos = actualPos[axis];

    uint16_t lowWord = (uint16_t)(pos & 0xFFFF);
    uint16_t highWord = (uint16_t)((pos >> 16) & 0xFFFF);

    // 写入目标位置（两个寄存器）
    writeHoldingRegister(slaveAddr, REG_TARGET_POS_L, lowWord);
    writeHoldingRegister(slaveAddr, REG_TARGET_POS_H, highWord);
  }

  // ===== 3. 读取各轴实际位置与状态 =====
  for (int axis = 0; axis < 3; axis++) {
    uint8_t slaveAddr = SLAVE_AXIS_X + axis;
    uint16_t rxBuf[5];

    // 读取5个寄存器：实际位置(2) + 状态(1) + 预留(2)
    if (modbus.readHoldingRegisters(slaveAddr, REG_ACTUAL_POS_L, rxBuf, 5) == 0) {
      int32_t actual = ((int32_t)rxBuf[1] << 16) | rxBuf[0];
      actualPos[axis] = actual;

      // 检查状态字
      uint16_t status = rxBuf[2];
      if (status & 0x01) {
        Serial.print("轴 "); Serial.print(axis);
        Serial.println(" 到达目标位置");
      }
    }
  }

  // ===== 4. 调试输出 =====
  static int cnt = 0;
  if (++cnt % 10 == 0) {
    Serial.print("X="); Serial.print(actualPos[0]);
    Serial.print(" Y="); Serial.print(actualPos[1]);
    Serial.print(" Z="); Serial.println(actualPos[2]);
  }
}

// 写单个保持寄存器（带 RS485 方向控制）
void writeHoldingRegister(uint8_t slave, uint16_t addr, uint16_t value) {
  digitalWrite(RS485_DE_RE, HIGH);  // 发送模式
  delayMicroseconds(50);
  modbus.writeSingleHoldingRegister(slave, addr, value);
  delayMicroseconds(50);
  digitalWrite(RS485_DE_RE, LOW);   // 接收模式
}

代码要点：Arduino 作为 Modbus 主站，通过 RS485 总线轮询三个从站 BLDC 驱动器。位置指令以 32 位整数拆分为两个 16 位寄存器写入，实际位置同样从两个寄存器拼合读取。RS485 半双工通信需要手动控制 DE/RE 引脚切换收发方向。

2、多轴插补运动 + 广播同步启动（进阶级）
场景说明：多轴需要同时到达目标点（如直线插补、圆弧插补）。采用“预计算各轴轨迹点 + 缓存下发 + 广播同步启动”的架构。主站先将所有轴的运动轨迹点下发到各从站的背景缓冲区，然后发送广播帧（地址 0x00）触发所有轴同时开始执行。

#include <ModbusRTUMaster.h>

#define RS485_DE_RE 2

// ===== 从站地址 =====
#define SLAVE_X 1
#define SLAVE_Y 2
#define SLAVE_Z 3

// ===== 扩展寄存器映射 =====
#define REG_TRAJ_CMD       0    // 轨迹控制字
#define REG_TRAJ_POINT     1    // 轨迹点索引
#define REG_TARGET_POS_L   2    // 目标位置低
#define REG_TARGET_POS_H   3    // 目标位置高
#define REG_SYNC_CMD       4    // 同步命令

#define CMD_LOAD_POINT     0x01  // 装载轨迹点
#define CMD_EXECUTE        0x02  // 执行缓冲轨迹
#define CMD_STOP           0x03  // 停止

// ===== 广播同步 =====
#define BROADCAST_ADDR     0x00

ModbusRTUMaster modbus;

// ===== 轨迹规划（简化直线插补） =====
#define TRAJ_POINTS 20

struct AxisTraj {
  int32_t points[TRAJ_POINTS];
  int pointCount;
};

AxisTraj traj[3];
int32_t startPos[3] = {0, 0, 0};
int32_t endPos[3] = {5000, 3000, 2000};

void setup() {
  Serial.begin(115200);
  Serial1.begin(38400, SERIAL_8E1);
  modbus.begin(38400, SERIAL_8E1);

  pinMode(RS485_DE_RE, OUTPUT);
  digitalWrite(RS485_DE_RE, LOW);

  Serial.println("多轴插补 + 广播同步就绪");

  // ===== 1. 规划三轴直线插补轨迹 =====
  planLinearInterpolation();

  // ===== 2. 下发轨迹到各从站缓冲区 =====
  downloadTrajectories();

  // ===== 3. 广播同步启动 =====
  broadcastStart();
}

void loop() {
  // 周期性读取各轴状态
  static unsigned long lastRead = 0;
  if (millis() - lastRead < 100) return;
  lastRead = millis();

  for (int axis = 0; axis < 3; axis++) {
    uint16_t rxBuf[3];
    uint8_t slave = SLAVE_X + axis;
    if (modbus.readHoldingRegisters(slave, REG_TARGET_POS_L, rxBuf, 3) == 0) {
      int32_t pos = ((int32_t)rxBuf[1] << 16) | rxBuf[0];
      Serial.print("轴"); Serial.print(axis);
      Serial.print("="); Serial.print(pos);
      Serial.print(" 状态="); Serial.println(rxBuf[2], HEX);
    }
  }
}

void planLinearInterpolation() {
  // 计算三轴的总位移，按最大位移轴归一化
  float maxDelta = 0;
  for (int i = 0; i < 3; i++) {
    float d = abs(endPos[i] - startPos[i]);
    if (d > maxDelta) maxDelta = d;
  }
  if (maxDelta < 1) maxDelta = 1;

  for (int axis = 0; axis < 3; axis++) {
    traj[axis].pointCount = TRAJ_POINTS;
    for (int p = 0; p < TRAJ_POINTS; p++) {
      float t = (float)p / (TRAJ_POINTS - 1);
      // 直线插补：各轴按比例运动
      traj[axis].points[p] = startPos[axis] +
        (int32_t)((endPos[axis] - startPos[axis]) * t);
    }
  }
}

void downloadTrajectories() {
  // 逐轴下发轨迹点到从站背景缓冲区
  for (int axis = 0; axis < 3; axis++) {
    uint8_t slave = SLAVE_X + axis;

    for (int p = 0; p < TRAJ_POINTS; p++) {
      int32_t pos = traj[axis].points[p];
      uint16_t low = (uint16_t)(pos & 0xFFFF);
      uint16_t high = (uint16_t)((pos >> 16) & 0xFFFF);

      // 写入轨迹点
      writeReg(slave, REG_TARGET_POS_L, low);
      writeReg(slave, REG_TARGET_POS_H, high);
      writeReg(slave, REG_TRAJ_POINT, p);
      writeReg(slave, REG_TRAJ_CMD, CMD_LOAD_POINT);

      delayMicroseconds(200);  // 从站处理时间
    }
    Serial.print("轴"); Serial.print(axis);
    Serial.println(" 轨迹下发完成");
  }
}

void broadcastStart() {
  // 广播同步启动：所有从站同时收到执行命令
  digitalWrite(RS485_DE_RE, HIGH);
  delayMicroseconds(50);

  // 广播地址 0x00，所有从站接收但不响应
  // 写入同步命令寄存器
  modbus.writeSingleHoldingRegister(BROADCAST_ADDR, REG_SYNC_CMD, CMD_EXECUTE);

  delayMicroseconds(50);
  digitalWrite(RS485_DE_RE, LOW);

  Serial.println("广播同步启动！");
}

void writeReg(uint8_t slave, uint16_t addr, uint16_t value) {
  digitalWrite(RS485_DE_RE, HIGH);
  delayMicroseconds(30);
  modbus.writeSingleHoldingRegister(slave, addr, value);
  delayMicroseconds(30);
  digitalWrite(RS485_DE_RE, LOW);
}

代码要点：广播同步是 Modbus RTU 实现多轴联动的关键手段——广播地址 0x00 使所有从站同时接收命令且不返回响应，避免了轮询通信的累积延迟。轨迹预下载到从站缓冲区后，一次广播即可触发所有轴同时执行。轨迹规划采用直线插补，各轴按最大位移轴的比例同步运动。

3、Arduino 从站模式 + 上位机多轴协同（工业架构）
场景说明：面向工业产线中的多关节机械臂。Arduino 作为 Modbus RTU 从站（地址可配置），接收上位机 PLC 或工控机的多轴位置指令，同时自身通过 SimpleFOC 驱动 BLDC 关节。上位机负责全局轨迹规划，Arduino 专注单轴伺服控制。

#include <ModbusRTUSlave.h>
#include <SimpleFOC.h>
#include <Wire.h>

// ===== RS485 从站配置 =====
#define RS485_DE_RE 2
#define SLAVE_ADDRESS 1  // 本轴从站地址

// ===== BLDC 电机（本轴关节） =====
BLDCMotor motor(7);  // 7极对
BLDCDriver3PWM driver(9, 10, 11, 8);
MagneticSensorI2C sensor = MagneticSensorI2C(AS5600_I2C);

// ===== Modbus 从站对象 =====
ModbusRTUSlave slave(Serial1);

// ===== 寄存器映射 =====
#define REG_TARGET_POS_L  0   // 目标位置低16位（写入）
#define REG_TARGET_POS_H  1   // 目标位置高16位（写入）
#define REG_ACTUAL_POS_L  2   // 实际位置低16位（读取）
#define REG_ACTUAL_POS_H  3   // 实际位置高16位（读取）
#define REG_STATUS        4   // 状态字
#define REG_CONTROL       5   // 控制字（使能/停止/复位）

// ===== 本地变量 =====
int32_t targetPos = 0;
int32_t actualPos = 0;
uint16_t statusWord = 0;
uint16_t controlWord = 0;

// ===== Modbus 寄存器缓冲区 =====
uint16_t holdingRegisters[16];  // 0-15 号保持寄存器

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

  // ===== 1. 初始化 SimpleFOC =====
  sensor.init();
  motor.linkSensor(&sensor);
  driver.voltage_power_supply = 24;
  driver.init();
  motor.linkDriver(&driver);

  motor.controller = MotionControlType::angle;
  motor.PID_velocity.P = 0.05f;
  motor.PID_velocity.I = 0.02f;
  motor.voltage_limit = 12;
  motor.velocity_limit = 20;
  motor.init();
  motor.initFOC();

  // ===== 2. 初始化 Modbus 从站 =====
  Serial1.begin(38400, SERIAL_8E1);
  slave.begin(SLAVE_ADDRESS, 38400, SERIAL_8E1);
  // 注册寄存器回调
  slave.configureHoldingRegisters(holdingRegisters, 16);

  pinMode(RS485_DE_RE, OUTPUT);
  digitalWrite(RS485_DE_RE, LOW);

  Serial.println("Arduino BLDC 从站就绪，地址=1");
}

void loop() {
  // ===== 1. SimpleFOC 闭环控制 =====
  motor.loopFOC();
  motor.move();

  // ===== 2. 更新实际位置到寄存器 =====
  actualPos = (int32_t)(motor.shaft_angle * 10000);  // 弧度转计数
  holdingRegisters[REG_ACTUAL_POS_L] = (uint16_t)(actualPos & 0xFFFF);
  holdingRegisters[REG_ACTUAL_POS_H] = (uint16_t)((actualPos >> 16) & 0xFFFF);

  // ===== 3. 更新状态字 =====
  statusWord = 0;
  if (abs(motor.shaft_velocity) < 0.1f) statusWord |= 0x01;  // 静止
  if (motor.motor_status == FOCMotorStatus::motor_ready) statusWord |= 0x02;
  holdingRegisters[REG_STATUS] = statusWord;

  // ===== 4. 处理 Modbus 通信 =====
  slave.poll();

  // ===== 5. 执行控制字命令 =====
  controlWord = holdingRegisters[REG_CONTROL];
  if (controlWord & 0x01) {
    // 使能
    motor.enable();
  }
  if (controlWord & 0x02) {
    // 停止
    motor.disable();
  }

  // ===== 6. 读取目标位置并设置电机目标 =====
  int32_t newTarget = ((int32_t)holdingRegisters[REG_TARGET_POS_H] << 16)
                      | holdingRegisters[REG_TARGET_POS_L];

  if (newTarget != targetPos) {
    targetPos = newTarget;
    // 将计数转为弧度（标定值）
    float targetRad = (float)targetPos / 10000.0f;
    motor.move(targetRad);
  }
}

代码要点：Arduino 作为 Modbus RTU 从站，slave.poll() 非阻塞处理通信请求。SimpleFOC 的闭环控制独立运行，实际位置实时写入保持寄存器供主站读取。控制字和状态字实现了主从站之间的命令与反馈交换。这种架构下，一台工控机可以同时管理 32 个这样的从站轴。

要点解读

1. Modbus RTU 的“主站轮询 + 广播同步”是实现多轴联动的核心机制

Modbus RTU 本质上是一个主从协议，网络中只有一个主站，从站不主动发送数据。多轴协同的关键在于：常规位置指令通过主站轮询逐个下发，而同步启动必须依赖广播（地址 0x00）——广播帧被所有从站接收但不产生响应，避免了轮询带来的逐轴延迟累积。案例二展示了这一架构：轨迹先缓存到各从站，广播一次即触发所有轴同时运动。

2. 寄存器映射是多轴协同的“通信契约”

Modbus 只定义了帧格式，不定义数据含义。多轴系统中，主站与每个从站之间必须预先约定寄存器映射表：哪些寄存器是目标位置、哪些是实际位置、哪些是状态字和控制字。案例一和案例三中的 REG_TARGET_POS_L/H、REG_ACTUAL_POS_L/H、REG_STATUS 就是典型的工业约定。32 位位置数据必须拆分为两个 16 位寄存器传输，字节序（大端/小端）也需明确约定。

3. Arduino 既可作主站也可作从站，角色选择取决于系统架构

案例一和案例二使用 Arduino 作为 Modbus 主站，主动轮询从站驱动器；案例三使用 Arduino 作为从站，接收上位机的指令。选择依据是：如果系统有多个 BLDC 轴需要协同，且没有独立的工业 PLC，Arduino 做主站是合理选择；如果系统已有 PLC 或工控机作为全局控制器，Arduino 作为从站专注单轴伺服控制，架构更清晰、更符合工业惯例。

4. 通信周期与控制周期的匹配决定协同精度

Modbus RTU 在 38400bps 下，一次读/写事务约需 5-10ms。案例一中 3 轴轮询一轮约 30ms，控制周期设为 50ms 是合理的。如果控制周期远小于通信周期（如要求 10ms 控制但通信需 30ms），则无法实现真正的多轴同步。工业级做法是：位置指令以通信周期下发，从站内部以更高频率（如 1kHz）执行插值，Arduino 的 SimpleFOC 闭环控制在本地高频运行，通信只负责周期性更新目标值。

5. 非阻塞通信是 Arduino 保持 FOC 实时性的前提

SimpleFOC 的 loopFOC() 需要以较高频率（通常 ≥1kHz）稳定运行。如果 Modbus 读取使用阻塞式等待响应，通信期间 FOC 循环会被打断，导致电机抖动甚至失控。案例三中 slave.poll() 是非阻塞的，案例一中使用的是非阻塞的 Modbus 主站库。选择 Modbus 库时务必确认其非阻塞特性，这是 Arduino 平台同时维持通信和伺服控制的关键。

4、3轴焊接机器人Modbus RTU协同控制
适用场景：三轴焊接机器人，通过Modbus RTU实现多轴速度、位置同步，保证焊接轨迹精度。

#include <ModbusRTU.h>
#include <SimpleFOC.h>

ModbusRTU mrtu;
// 3轴BLDC配置
SimpleFOCMotor2 axisX = SimpleFOCMotor2(2,3,4,A0,A1);
SimpleFOCMotor2 axisY = SimpleFOCMotor2(5,6,7,A2,A3);
SimpleFOCMotor2 axisZ = SimpleFOCMotor2(8,9,10,A4,A5);

// 共享数据寄存器（Modbus地址40000-40004）
int16_t cmd_vx = 0, cmd_vy = 0, cmd_vz = 0; // 速度指令
bool start_cmd = false;

// Modbus从机回调：接收多轴指令
void modbusCallback(int address, int size, int value) {
  switch(address) {
    case 1: cmd_vx = (int16_t)value; break;
    case 2: cmd_vy = (int16_t)value; break;
    case 3: cmd_vz = (int16_t)value; break;
    case 4: start_cmd = (value == 1); break;
    default: break;
  }
}

void setup() {
  Serial1.begin(9600); // Modbus硬件串口
  mrtu.begin(&Serial1);
  // 绑定回调到各轴地址
  mrtu.slave(1, modbusCallback, 4, 1); // 接收4个寄存器数据
  
  axisX.init(); axisY.init(); axisZ.init();
  axisX.controller = FOC_VELOCITY;
  axisY.controller = FOC_VELOCITY;
  axisZ.controller = FOC_VELOCITY;
}

void loop() {
  mrtu.poll();
  if (start_cmd) {
    // 多轴速度联动指令下发
    float vx = cmd_vx * 0.001f;
    float vy = cmd_vy * 0.001f;
    float vz = cmd_vz * 0.001f;
    axisX.setVelocity(constrain(vx, -150, 150));
    axisY.setVelocity(constrain(vy, -150, 150));
    axisZ.setVelocity(constrain(vz, -150, 150));
  } else {
    axisX.setVelocity(0);
    axisY.setVelocity(0);
    axisZ.setVelocity(0);
  }
  delay(10);
}

5、4轴装配机器人Modbus RTU同步控制
适用场景：四轴零件装配机器人，通过Modbus RTU实现继电器输出与多轴运动的逻辑协同。

#include <ModbusRTU.h>
#include <SimpleFOC.h>

ModbusRTU mrtu;
SimpleFOCMotor2 baseJoint = SimpleFOCMotor2(2,3,4,A0,A1);
SimpleFOCMotor2 armJoint = SimpleFOCMotor2(5,6,7,A2,A3);
SimpleFOCMotor2 wristJoint = SimpleFOCMotor2(8,9,10,A4,A5);
SimpleFOCMotor2 gripper = SimpleFOCMotor2(11,12,13,A6,A7);

// Modbus保持寄存器（40011-40014）
int16_t current_step = 0;
int32_t pos_tol = 500; // 位置容差计数
bool ready_flag = false;

// 从机接收装配任务参数
void modbusCallback(int address, int size, int value) {
  switch(address) {
    case 1: current_step = (int16_t)value; break;
    case 2: pos_tol = (int32_t)value; break; 
    case 3: ready_flag = (value == 1); break;
  }
}

void executeAssemblyStep() {
  float stepSpeed = 30.0f;
  switch(current_step) {
    case 1: // 底座旋转到位
      baseJoint.set(0.8f, stepSpeed);
      delay(500);
      baseJoint.set(1.2f, stepSpeed);
      break;
    case 2: // 机械臂上升取料
      armJoint.set(0.3f, stepSpeed);
      wristJoint.set(0.0f);
      break;
    case 3: // 夹爪闭合抓取
      gripper.set(0.5f, stepSpeed);
      break;
    case 4: // 下压压合
      wristJoint.set(-0.4f, stepSpeed);
      delay(800);
      wristJoint.set(0.0f, stepSpeed);
      break;
  }
}

void setup() {
  Serial1.begin(9600);
  mrtu.begin(&Serial1);
  mrtu.slave(2, modbusCallback, 3, 1);
  baseJoint.init(); armJoint.init(); wristJoint.init(); gripper.init();
  baseJoint.controller = FOC_POSITION;
  armJoint.controller = FOC_POSITION;
  wristJoint.controller = FOC_POSITION;
  gripper.controller = FOC_VELOCITY;
}

void loop() {
  mrtu.poll();
  if (ready_flag && current_step > 0) {
    executeAssemblyStep();
    ready_flag = false; // 执行完成后清除标志
  }
  delay(10);
}

6、6轴喷涂机器人Modbus RTU多轴联动
适用场景：六轴喷涂机器人，通过Modbus RTU实现轨迹参数同步、速度匹配与全局状态上报。

#include <ModbusRTU.h>
#include <SimpleFOC.h>

ModbusRTU mrtu;
SimpleFOCMotor2 joints[6] = {/* 6个关节电机定义 */};

// Modbus输出寄存器（40001-40007）
int16_t trajectory[6]; // 各关节目标角度
int16_t target_speed = 60; // 喷涂速度
bool edge_command = false;

// 从机异常处理：模拟通信中断重连
void faultCallback() {
  // 通信中断时急停所有关节
  for(int i=0; i<6; i++) { joints[i].set(0, 0); }
}

void syncTrajectory() {
  for(int i=0; i<6; i++) {
    joints[i].set(trajectory[i] * 0.001f, target_speed);
    delay(5); // 微小延时保证关节动作协调
  }
}

void setup() {
  Serial1.begin(115200); // 喷涂场景需要高速率
  mrtu.begin(&Serial1);
  mrtu.slave(3, NULL, 0, 0);
  mrtu.onModbusEvent(faultCallback);
  for(int i=0;i<6;i++) {
    joints[i].init();
    joints[i].controller = FOC_POSITION;
  }
}

void loop() {
  mrtu.poll();
  if(edge_command && mrtu.requestFrom(1, 7, 5)) {
    // 读取主机下发的轨迹数据
    for(int i=0;i<6;i++) trajectory[i] = mrtu.getResponseBuffer()[i];
    syncTrajectory();
    edge_command = false;
  }
  
  // 上报各关节当前状态
  if(mrtu.requestFrom(1, 0, 0)) {
    mrtu.readRegisters(1, 1, nullptr); // 空读触发状态汇报
  }
  delay(10);
}

要点解读
多轴同步需基于Modbus时序一致性，避免动作错位
Modbus RTU通信存在轮询延迟，多轴联动需通过「主站统一下发同步指令+从站状态确认」机制保证时序对齐；关键场景可增加离散量硬线互锁，降低对单一通信总线的依赖。

寄存器映射需标准化，实现多轴数据共享
必须为各轴分配连续的保持寄存器地址，统一速度、位置、状态的报文格式；从站需主动上报轴体状态（如故障、完成），主机可据此实现自适应调度，避免指令冲突。

异常处理需具备断线回退能力，保障工业安全
通信中断或超时是工业场景高频异常，需设置Modbus看门狗定时器，一旦超时立刻触发所有轴急停；同时利用中断回调调用急停逻辑，确保故障时设备可靠停机，防止机械碰撞。

控制算法需分层设计，降低联动复杂度
底层使用SimpleFOC实现单轴闭环控制，上层通过Modbus实现联动调度；联脱模式需解耦，单轴可独立调试，联机时由主机配置同步参数，兼顾灵活性与稳定性。

参数需支持运行时在线配置，提升产线适应性
速度、位置容差、轨迹参数需通过Modbus在线读写，结合工业现场的工艺变更实时调整；代码需设置参数范围限制和合法性校验，防止参数越界导致设备损坏。

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