Arduino BLDC 电机串口远程控制工业巡检机器人设计

安全机制与故障处理

• 看门狗与超时保护：必须启用 Arduino 的硬件看门狗定时器。同时，在程序中设置通信超时机制，若在设定时间内未接收到上位机的'心跳包'或有效指令，系统应自动进入安全模式（如停止电机、启动声光报警）。
• 急停与限位保护：物理急停按钮是必须的硬件安全措施。此外，还应设置软件限位，当传感器检测到障碍物过近或电机电流异常（可能卡死）时，立即切断电机动力。

协议设计与状态同步

• 指令冲突处理：需设计合理的协议优先级。例如，急停指令应具有最高优先级，任何时刻接收到急停指令都必须立即响应，而速度调节指令则应平滑过渡。
• 双向通信与状态反馈：远程控制不应是单向的。Arduino 应定期或在事件触发时向上位机回传机器人的状态信息（如当前坐标、电池电压、电机温度、传感器读数），以便操作员全面掌握现场情况，实现闭环控制。

4、代码示例

基础串口速度控制（PWM 信号）

#include <Servo.h>
Servo esc; // 电调控制对象
String inputCommand;
int currentSpeed = 1000; // 默认低脉冲（停止）

void setup() {
  Serial.begin(115200);
  esc.attach(9, 1000, 2000); // 信号线接 9 号引脚
  esc.writeMicroseconds(currentSpeed); // 初始化电调
  Serial.println("BLDC Control Ready (PWM Mode)");
  Serial.println("Commands: SPEED:<1000-2000> | STOP");
}

void loop() {
  if (Serial.available() > 0) {
    inputCommand = Serial.readStringUntil('\n');
    inputCommand.trim();
    if (inputCommand.startsWith("SPEED:")) {
      currentSpeed = inputCommand.substring(6).toInt();
      currentSpeed = constrain(currentSpeed, 1000, 2000); // 限制范围
      esc.writeMicroseconds(currentSpeed);
      Serial.print("Speed set to: ");
      Serial.println(currentSpeed);
    } else if (inputCommand == "STOP") {
      currentSpeed = 1000;
      esc.writeMicroseconds(currentSpeed);
      Serial.println("Emergency Stop");
    }
  }
}

应用场景：通过上位机（如 Python 脚本）发送串口指令控制机器人电机启停和调速。

多电机协同控制（差速转向）

#include <Servo.h>
Servo escLeft, escRight; // 左右电机电调
String command;

void setup() {
  Serial.begin(115200);
  escLeft.attach(9, 1000, 2000);
  escRight.attach(10, 1000, 2000);
  Serial.println("Differential Drive Ready");
  Serial.println("Commands: FORWARD:<speed> | TURN:<left_speed>:<right_speed> | STOP");
}

void loop() {
  if (Serial.available()) {
    command = Serial.readStringUntil('\n');
    command.trim();
    if (command.startsWith("FORWARD:")) {
      int speed = command.substring(8).toInt();
      speed = constrain(speed, 1000, 2000);
      escLeft.writeMicroseconds(speed);
      escRight.writeMicroseconds(speed);
      Serial.print("Moving forward at: ");
      Serial.println(speed);
    } else if (command.startsWith("TURN:")) {
      int colonIndex = command.indexOf(':', 5);
      int leftSpeed = command.substring(5, colonIndex).toInt();
      int rightSpeed = command.substring(colonIndex + 1).toInt();
      escLeft.writeMicroseconds(constrain(leftSpeed, 1000, 2000));
      escRight.writeMicroseconds(constrain(rightSpeed, 1000, 2000));
      Serial.print("Turning - Left: ");
      Serial.print(leftSpeed);
      Serial.print(" | Right: ");
      Serial.println(rightSpeed);
    } else if (command == "STOP") {
      escLeft.writeMicroseconds(1000);
      escRight.writeMicroseconds(1000);
      Serial.println("Stopped");
    }
  }
}

应用场景：差速驱动机器人（如巡检小车），通过串口指令实现直行、转向和停止。

带反馈的闭环控制（PID 调速）

#include <Servo.h>
#include <PID_v1.h> // 需要安装 PID 库
Servo esc;
int encoderPin = 2; // 编码器信号输入（需中断引脚）
volatile long pulseCount = 0;
double targetRPM = 100, actualRPM = 0;
double outputPWM = 1000;
PID myPID(&actualRPM, &outputPWM, &targetRPM, 0.5, 0.1, 0.01, DIRECT); // PID 参数需调试

void countPulses() { pulseCount++; } // 编码器中断函数

void setup() {
  Serial.begin(115200);
  esc.attach(9, 1000, 2000);
  pinMode(encoderPin, INPUT_PULLUP);
  attachInterrupt(digitalPinToInterrupt(encoderPin), countPulses, RISING);
  myPID.SetMode(AUTOMATIC);
  myPID.SetOutputLimits(1000, 2000); // 限制 PWM 范围
  Serial.println("Closed-Loop Control Ready");
}

void loop() {
  static unsigned long lastTime = 0;
  if (millis() - lastTime >= 100) { // 每 100ms 计算一次转速
    noInterrupts();
    long currentPulses = pulseCount;
    pulseCount = 0;
    interrupts();
    actualRPM = (currentPulses / 20.0) * 60; // 假设编码器每转 20 脉冲
    myPID.Compute(); // 更新 PID 输出
    esc.writeMicroseconds(outputPWM);
    Serial.print("Target: ");
    Serial.print(targetRPM);
    Serial.print(" | Actual: ");
    Serial.print(actualRPM);
    Serial.print(" | PWM: ");
    Serial.println(outputPWM);
    lastTime = millis();
  }
  // 串口接收新目标转速
  if (Serial.available()) {
    String cmd = Serial.readStringUntil('\n');
    if (cmd.startsWith("RPM:")) {
      targetRPM = cmd.substring(4).toDouble();
      Serial.print("New RPM Target: ");
      Serial.println(targetRPM);
    }
  }
}

应用场景：需要精确控制轮速的巡检机器人（如爬坡时保持恒定速度），通过编码器反馈实现 PID 闭环控制。

基础串口指令控制巡检机器人

场景：室内简单巡检，通过串口接收控制指令。核心逻辑：ASCII 指令解析 + 差速控制。

#include <SimpleFOC.h> // BLDC 电机对象
BLDCMotor motorL = BLDCMotor(7);
BLDCMotor motorR = BLDCMotor(7);
// 编码器 Encoder encoderL(2,3,2048); Encoder encoderR(18,19,2048);
// ... (简化示意，实际需完整配置)

struct Command {
  char type; // 指令类型：M=移动，S=停止，C=配置，R=读取
  float param1; // 参数 1
  float param2; // 参数 2
  unsigned long timestamp; // 时间戳
};
Command currentCmd = {'S', 0, 0, 0};
bool newCommand = false;
String serialBuffer = "";

void setup() {
  Serial.begin(115200);
  Serial1.begin(115200); // 用于扩展通信
  // 初始化电机...
  Serial.println("INSPECT> Robot Ready");
  Serial.println("INSPECT> Commands: F-forward B-back L-left R-right S-stop");
}

void loop() {
  readSerialCommands();
  if (newCommand) {
    executeCommand(currentCmd);
    newCommand = false;
  }
  motionControl();
  updateRobotState();
  checkObstacles();
  motorL.loopFOC();
  motorR.loopFOC();
}

void readSerialCommands() {
  while (Serial.available()) {
    char c = Serial.read();
    if (c == '\n' || c == '\r') {
      if (serialBuffer.length() > 0) {
        parseCommand(serialBuffer);
        serialBuffer = "";
      }
    } else {
      serialBuffer += c;
    }
  }
}

void parseCommand(String buffer) {
  buffer.trim();
  buffer.toUpperCase();
  Command cmd = {'S', 0, 0, millis()};
  if (buffer.length() == 1) {
    cmd.type = buffer[0];
    switch (buffer[0]) {
      case 'F': cmd.param1 = 0.3; break; // 前进
      case 'B': cmd.param1 = -0.3; break; // 后退
      case 'L': cmd.type = 'T'; cmd.param1 = 0.5; break; // 左转
      case 'R': cmd.type = 'T'; cmd.param1 = -0.5; break; // 右转
      case 'S': cmd.type = 'S'; break; // 停止
    }
  }
  currentCmd = cmd;
  newCommand = true;
}

void executeCommand(Command cmd) {
  switch (cmd.type) {
    case 'M': linearSpeed = constrain(cmd.param1, -maxSpeed, maxSpeed); break;
    case 'T': angularSpeed = constrain(cmd.param1, -1.0, 1.0); break;
    case 'S': linearSpeed = 0; angularSpeed = 0; break;
  }
}

工业 Modbus RTU 串口控制

场景：工业环境，需要标准 Modbus 协议与 PLC/DCS 集成。核心逻辑：Modbus RTU 协议 + 寄存器映射。

#include <SimpleFOC.h>
#include <ModbusRTU.h>
// Modbus 从站 ModbusRTU mb;
#define MODBUS_SLAVE_ID 1
#define MODBUS_BAUDRATE 9600
#define MODBUS_SERIAL Serial2

enum ModbusRegisters {
  REG_SET_SPEED = 0,
  REG_ACTUAL_SPEED = 100,
  REG_STATUS_WORD = 149,
  REG_COUNT = 150
};

void setup() {
  Serial.begin(115200);
  MODBUS_SERIAL.begin(MODBUS_BAUDRATE, SERIAL_8N1);
  mb.begin(&MODBUS_SERIAL);
  mb.slave(MODBUS_SLAVE_ID);
  mb.addHreg(REG_SET_SPEED, 0, REG_COUNT);
  initModbusRegisters();
  Serial.println("INSPECT> Modbus RTU Industrial Robot Ready");
}

void loop() {
  mb.task();
  processModbusCommands();
  motorL.loopFOC();
  motorR.loopFOC();
}

bool writeRegisterCallback(Modbus::ResultCode event, uint16_t address, uint16_t val) {
  if (event == Modbus::EX_SUCCESS) {
    switch (address) {
      case REG_SET_SPEED: handleSpeedCommand(val); break;
      default: mb.Hreg(address, val); break;
    }
    return true;
  }
  return false;
}

ROS 串行协议集成

场景：与 ROS 系统集成，实现高级导航和感知。核心逻辑：ROS Serial 协议 + Twist 消息。

#include <SimpleFOC.h>
#include <ros.h>
#include <geometry_msgs/Twist.h>
#include <nav_msgs/Odometry.h>

ros::NodeHandle nh;
BLDCMotor motorL, motorR;
geometry_msgs::Twist cmd_vel;

void cmdVelCallback(const geometry_msgs::Twist& msg) {
  cmd_vel = msg;
}

void setup() {
  Serial.begin(57600);
  nh.initNode();
  ros::Subscriber<geometry_msgs::Twist> cmd_vel_sub("cmd_vel", &cmdVelCallback);
  nh.subscribe(cmd_vel_sub);
  initMotorsROS();
  nh.loginfo("ROS Industrial Inspection Robot Ready");
}

void loop() {
  nh.spinOnce();
  velocityControl();
  motorL.loopFOC();
  motorR.loopFOC();
  delay(10);
}

void velocityControl() {
  float linear_vel = constrain(cmd_vel.linear.x, -1.0, 1.0);
  float angular_vel = constrain(cmd_vel.angular.z, -1.0, 1.0);
  // 差速运动学计算...
}

要点解读

通信协议设计与选择

• ASCII 协议：简单直观，适合调试和人机交互。优点是可读性强，缺点是效率低、无校验。
• Modbus RTU：工业标准，适合 PLC 集成。16 位寄存器映射，CRC 校验保证可靠。这是工业部署首选。
• ROS Serial：机器人标准，适合与 ROS 导航栈集成。支持 Twist 速度命令、Odometry 里程计、BatteryState 等标准消息。

指令处理的安全机制

• 速度限制：防止超速。工业环境通常限制在 1m/s 以内。
• 加速度限制：实现梯形速度曲线，避免急启急停对机械的冲击。
• 安全区域：实现地理围栏，超出预设区域自动急停。
• 通讯超时：检测无通讯自动停止，防止失控。

状态反馈与监控

• 里程计计算：通过编码器积分计算位置。
• 电池监控：包含电压、电流、电量百分比。工业应用需监控单节电芯电压。
• 状态字设计：16 位状态字，每 bit 表示一种状态，便于 PLC 快速读取。

部署实施的工程考量

• 波特率选择：调试用 115200，工业 Modbus 用 9600/19200，ROS 用 57600/115200。
• 电缆要求：RS-485 需双绞线，终端电阻 120Ω。
• 电源管理：工业机器人常采用 24VDC，需 DC-DC 降压。
• 防护等级：工业环境需 IP54 以上防护。

实际编程时，要根据硬件配置、使用场景和具体需求进行调整，并多次实际测试。涉及硬件操作的代码，使用前要确认引脚和电平等参数的正确性和安全性。