Arduino BLDC 基于串口指令的远程控制工业巡检机器人

基于 Arduino 的 BLDC 串口指令远程控制工业巡检机器人

该系统以 Arduino 为核心控制器，驱动 BLDC 电机实现高机动性移动，通过串口通信链路接收上位机或远程终端的指令，实现对机器人的精确操控与状态监控。

1. 主要特点

高可靠性的串口通信架构

串口通信（UART）作为工业控制领域的基石，提供了稳定、低延迟的指令传输通道。

协议灵活性：系统可定义自定义的二进制或 ASCII 协议。例如，通过发送字符指令（如'F'前进，'B'后退，'L'左转，'R'右转）或结构化数据包（包含速度、方向、任务 ID 等字段），实现复杂的控制逻辑。
硬件接口多样性：物理层可采用标准 TTL 电平、RS232 或 RS485。其中，RS485 支持多点、长距离（可达 1200 米）差分传输，具有极强的抗共模干扰能力，非常适合工业现场复杂的电磁环境。
低延迟实时控制：相较于网络协议栈，串口通信的协议开销极小，数据传输延迟通常在微秒级。这使得操作员能够实时控制机器人的运动状态，快速响应突发情况。

BLDC 驱动的高机动性与长续航

BLDC 电机为巡检机器人提供了适应复杂工业环境的动力保障。

高能效比：BLDC 电机效率通常高达 85%-90%，配合电子调速器（ESC），在频繁启停的巡检任务中能显著降低能耗，延长单次充电的巡检时长。
宽调速范围与高动态响应：通过 PWM 信号精确控制 BLDC 电机，机器人可实现从极低速（用于精细检查设备仪表）到高速（用于快速转移阵地）的平滑调速。电机的快速扭矩响应特性确保了机器人在接收到急停或变向指令时能迅速执行。
低维护与高可靠性：无电刷设计消除了机械磨损和火花干扰，使驱动系统能在粉尘、油污等恶劣工业环境中长期稳定运行，减少了停机维护成本。

模块化与可扩展性

Arduino 的开源生态为系统功能的扩展提供了极大便利。

多传感器集成：通过串口、I2C 或 SPI 总线，可轻松集成红外热像仪、气体传感器、高清摄像头等多种巡检传感器。Arduino 负责协调这些传感器的数据采集，并通过串口回传给上位机。
分级控制架构：通常采用'上位机规划 + Arduino 执行'的模式。上位机负责复杂的路径规划、图像处理和数据分析，Arduino 则专注于底层的电机控制、传感器数据读取和紧急避障，实现了计算资源的合理分配。

2. 应用场景

电力与石化设施巡检：在变电站、炼油厂等高危环境中，机器人代替人工进入现场，通过串口接收远程指令，对变压器、管道、阀门等设备进行巡检。操作员可在控制室实时查看机器人回传的红外热图、气体浓度数据和视频画面，及时发现漏电、漏油、过热等隐患。
轨道交通与隧道检测：在地铁隧道、铁路涵洞等狭长、封闭的空间内，机器人沿轨道或预设路径行进，利用串口链路与基站保持通信。通过远程控制，操作员可指挥机器人对轨道状态、隧道壁结构进行详细检查，解决了人工巡检视野受限、效率低下的问题。
大型仓储与数据中心：在面积广阔的仓库或数据中心机房，机器人执行环境监测任务。通过串口指令，系统可调度机器人前往指定区域检测温湿度、烟雾浓度，或对服务器机柜的指示灯状态进行视觉识别，实现无人化、全天候的智能巡检。
应急救援与排爆：在发生事故或存在爆炸风险的现场，机器人作为侦查先锋，通过有线或无线串口（如数传电台）接收远程指令。其强大的越障能力和灵活的运动性能，使其能够深入复杂废墟，回传现场音视频信息，为救援决策提供依据。

3. 注意事项

通信稳定性与抗干扰

硬件隔离与保护：工业现场存在强烈的电磁干扰和浪涌电压。必须在串口通信线路中加入光耦隔离、磁耦隔离或 RS485 收发器（如 MAX485）的保护电路，防止干扰信号或高压尖峰损坏 Arduino 和上位机。
数据校验与重传机制：在软件层面，必须设计完善的数据包结构，包含帧头、地址、指令、数据、校验和（如 CRC16）及帧尾。若接收方校验失败，应丢弃数据包并请求重传，确保指令的准确无误。

电源管理与系统分区

强弱电分离：BLDC 电机驱动属于强电回路，其启动和换向会产生巨大的电流冲击和电压波动。必须使用独立的 DC-DC 模块为 Arduino 及其逻辑电路供电，严禁与电机共用电源路径，防止电机噪声导致单片机复位。
电源滤波：在电源输入端和逻辑电路端并联大容量电解电容和高频陶瓷电容，以吸收电压尖峰，平滑电源噪声。

安全机制与故障处理

看门狗与超时保护：必须启用 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 = ;
      esc.(currentSpeed);
      Serial.();
    }
  }
}

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

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

#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.(, );
       leftSpeed = command.(, colonIndex).();
       rightSpeed = command.(colonIndex + ).();
      escLeft.((leftSpeed, , ));
      escRight.((rightSpeed, , ));
      Serial.();
      Serial.(leftSpeed);
      Serial.();
      Serial.(rightSpeed);
    }   (command == ) {
      escLeft.();
      escRight.();
      Serial.();
    }
  }
}

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

6. 带反馈的闭环控制（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   lastTime = ;
   (() - lastTime >= ) { 
    ();
     currentPulses = pulseCount;
    pulseCount = ;
    ();
    actualRPM = (currentPulses / ) * ; 
    myPID.(); 
    esc.(outputPWM);
    Serial.();
    Serial.(targetRPM);
    Serial.();
    Serial.(actualRPM);
    Serial.();
    Serial.(outputPWM);
    lastTime = ();
  }
  
   (Serial.()) {
    String cmd = Serial.();
     (cmd.()) {
      targetRPM = cmd.().();
      Serial.();
      Serial.(targetRPM);
    }
  }
}

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

7. 要点解读

通信协议设计

指令格式：采用易解析的字符串协议（如"SPEED:1500"），避免二进制协议的兼容性问题。
校验机制：工业场景建议增加 CRC 校验或 ACK 响应（如案例 1 可扩展为"SPEED:1500\nACK"）。

多电机同步控制

时间同步：案例 2 中通过独立 PWM 信号控制多电机，需确保串口指令同时到达（或通过硬件同步）。
仲裁逻辑：优先级高的指令（如急停）应立即覆盖当前动作。

闭环控制必要性

PID 调参：案例 3 中 Kp、Ki、Kd 需根据负载调整（如空载 Kp=0.5，重载 Kp=1.2）。
传感器选择：编码器分辨率需匹配电机转速（如高速电机用增量式编码器，低速用霍尔传感器）。

安全与容错

看门狗机制：若串口通信中断，应自动降速至安全值（如案例 1 中可添加超时检测）。
硬件保护：电机驱动回路加熔断器，防止堵转烧毁（如案例 3 中建议增加电流监测）。

扩展性与模块化

协议扩展：预留自定义指令（如"LED:ON"控制指示灯）。
多设备通信：通过 RS485 总线替代串口，实现多机器人协同（需修改案例 1 的通信接口）。

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

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

#include <SimpleFOC.h> // BLDC 电机对象

BLDCMotor motorL = BLDCMotor(7);
BLDCMotor motorR = BLDCMotor(7); // 编码器
Encoder encoderL(2, 3, 2048);
Encoder encoderR(18, 19, 2048);

void doA_L() { encoderL.handleA(); }
void doB_L() { encoderL.handleB(); }
void doA_R() { encoderR.handleA(); }
void doB_R() { encoderR.handleB(); }

// 控制参数
float linearSpeed = 0.0; // 线速度 m/s
float angularSpeed = 0.0; // 角速度 rad/s
float maxSpeed = 1.0; // 最大速度 1m/s
float wheelSeparation = 0.3; // 轮距 0.3m
float wheelRadius = 0.05; // 轮半径 0.05m

// 指令结构
  {
   type; 
   param1; 
   param2; 
    timestamp; 
};
Command currentCmd = {, , , };
 newCommand = ;
String serialBuffer = ;


  {
   posX = , posY = ; 
   heading = ; 
   battery = ; 
   temp = ; 
    uptime = ; 
};
RobotState state;




 obstacleDistance = ;

{
  Serial.();
  Serial(); 
  
  encoderL.();
  encoderR.();
  encoderL.(doA_L, doB_L);
  encoderR.(doA_R, doB_R);
  
  motorL.(&encoderL);
  motorR.(&encoderR);
  
  motorL.();
  motorR.();
  motorL.();
  motorR.();
  
  (SONAR_TRIG, OUTPUT);
  (SONAR_ECHO, INPUT);
  
  Serial.();
  Serial.();
  Serial.();
}

{
  
  ();
  
   (newCommand) {
    (currentCmd);
    newCommand = ;
  }
  
  ();
  
  ();
  
  ();
  
  motorL.();
  motorR.();
  
     lastReport = ;
   (() - lastReport > ) { 
    ();
    lastReport = ();
  }
}

{
   (Serial.()) {
     c = Serial.();
     (c ==  || c == ) {
       (serialBuffer.() > ) {
        (serialBuffer);
        serialBuffer = ;
      }
    }  {
      serialBuffer += c;
    }
  }
}

{
  buffer.();
  buffer.();
  Command cmd = {, , , ()};
   (buffer.() == ) { 
    cmd.type = buffer[];
     (buffer[]) {
       : 
        cmd.param1 = ; 
        ;
       : 
        cmd.param1 = ;
        ;
       : 
        cmd.type = ;
        cmd.param1 = ; 
        ;
       : 
        cmd.type = ;
        cmd.param1 = ;
        ;
       : 
        cmd.type = ;
        ;
       : 
        cmd.type = ;
        ;
    }
  }   (buffer.()) { 
    cmd.type = ;
    buffer.(, );
    cmd.param1 = buffer.();
  }   (buffer.()) { 
    cmd.type = ;
    buffer.(, );
    cmd.param1 = buffer.();
  }   (buffer.()) { 
    (buffer, cmd);
  }   (buffer.()) { 
    cmd.type = ;
    (buffer, cmd);
  }
  currentCmd = cmd;
  newCommand = ; 
  Serial.();
  Serial.(buffer);
}

{
   (cmd.type) {
     : 
      linearSpeed = (cmd.param1, -maxSpeed, maxSpeed);
      angularSpeed = ;
      Serial.();
      Serial.(linearSpeed, );
      ;
     : 
      angularSpeed = (cmd.param1, , );
      linearSpeed = ;
      Serial.();
      Serial.(angularSpeed, );
      ;
     : 
      linearSpeed = ;
      angularSpeed = ;
      Serial.();
      ;
     : 
      ();
      ;
     : 
      (cmd.param1, cmd.param2);
      ;
     : 
      (cmd);
      ;
  }
}

{
  
   leftSpeed = linearSpeed - (angularSpeed * wheelSeparation / );
   rightSpeed = linearSpeed + (angularSpeed * wheelSeparation / );
  
   leftMotorSpeed = leftSpeed / wheelRadius;
   rightMotorSpeed = rightSpeed / wheelRadius;
  
  leftMotorSpeed = (leftMotorSpeed, , );
  rightMotorSpeed = (rightMotorSpeed, , );
  
  motorL.(leftMotorSpeed);
  motorR.(rightMotorSpeed);
}

{
  
    lastLeftPos = , lastRightPos = ;
   leftPos = motorL.shaft_angle;
   rightPos = motorR.shaft_angle;
   deltaLeft = leftPos - lastLeftPos;
   deltaRight = rightPos - lastRightPos;
  
   linearDelta = (deltaLeft + deltaRight) * wheelRadius / ;
   angularDelta = (deltaRight - deltaLeft) * wheelRadius / wheelSeparation;
  
  state.heading += angularDelta;
  state.posX += linearDelta * (state.heading);
  state.posY += linearDelta * (state.heading);
  lastLeftPos = leftPos;
  lastRightPos = rightPos;
  
  state.uptime = () / ;
  
  state.battery =  + (, ) / ;
  state.temp =  + (, ) / ;
}

{
  
  (SONAR_TRIG, LOW);
  ();
  (SONAR_TRIG, HIGH);
  ();
  (SONAR_TRIG, LOW);
   duration = (SONAR_ECHO, HIGH, );
  obstacleDistance = duration *  / ;
  
   (obstacleDistance >  && obstacleDistance < ) { 
     (linearSpeed > ) { 
      linearSpeed = ;
      angularSpeed = ; 
      Serial.();
    }
  }
}

{
  Serial.();
  Serial.(state.posX, );
  Serial.();
  Serial.(state.posY, );
  Serial.();
  Serial.(state.heading, );
  Serial.();
  Serial.(state.battery, );
  Serial.();
  Serial.(state.temp, );
  Serial.();
  Serial.(obstacleDistance, );
  Serial.();
}

9. 工业 Modbus RTU 串口控制

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

#include <SimpleFOC.h>
#include <ModbusRTU.h> // Modbus 库

// BLDC 电机
BLDCMotor motorL, motorR;
// Modbus 从站
ModbusRTU mb;
#define MODBUS_SLAVE_ID 1
#define MODBUS_BAUDRATE 9600
#define MODBUS_SERIAL Serial2 // 硬件串口 2

// Modbus 寄存器映射
enum ModbusRegisters {
  // 保持寄存器 (可读可写)
  REG_SET_SPEED = 0, // 设置速度
  REG_SET_ANGLE,     // 设置角度
  REG_MAX_SPEED,     // 最大速度
  REG_ACCELERATION,  // 加速度
  REG_CONTROL_MODE,  // 控制模式
  REG_TARGET_X,      // 目标 X 坐标
  REG_TARGET_Y,      // 目标 Y 坐标
  // 输入寄存器 (只读)
  REG_ACTUAL_SPEED = 100, // 实际速度
  REG_ACTUAL_ANGLE,       // 实际角度
  REG_POSITION_X,         // 当前位置 X
  REG_POSITION_Y,         // 当前位置 Y
  REG_BATTERY_VOLTAGE,    // 电池电压
  REG_MOTOR_TEMP,         // 电机温度
  REG_OBSTACLE_DIST,      // 障碍物距离
  REG_ERROR_CODE,         // 错误代码
  REG_STATUS_WORD,        // 状态字
  REG_COUNT = 150
};

// 寄存器值
uint16_t mbRegisters[REG_COUNT] = {0};
uint16_t mbInputs[50] = {0};

// 机器人状态
struct  {
   speedActual = ;
   angleActual = ;
   posX = , posY = ;
   battery = ;
   temperature[] = {, };
   errorCode = ;
   statusWord = ; 
   emergencyStop = ;
};
IndustrialState iState;


  { SPEED_CTRL, POSITION_CTRL, TRAJECTORY_CTRL };
ControlMode ctrlMode = SPEED_CTRL;

{
  Serial.(); 
  MODBUS_SERIAL.(MODBUS_BAUDRATE, SERIAL_8N1);
  
  mb.(&MODBUS_SERIAL);
  mb.(MODBUS_BAUDRATE);
  mb.(MODBUS_SLAVE_ID);
  
  mb.(REG_SET_SPEED, , REG_COUNT);
  mb.((), writeRegisterCallback, REG_COUNT);
  mb.((), readRegisterCallback, REG_COUNT);
  
  ();
  
  ();
  Serial.();
  Serial.();
}

{
  
  mb.();
  
  ();
  
   (ctrlMode) {
     SPEED_CTRL:
      ();
      ;
     POSITION_CTRL:
      ();
      ;
     TRAJECTORY_CTRL:
      ();
      ;
  }
  
  ();
  
  ();
  
  motorL.();
  motorR.();
  
     lastDiag = ;
   (() - lastDiag > ) {
    ();
    lastDiag = ();
  }
}

{
  
  
  mb.(REG_SET_SPEED, ); 
  mb.(REG_MAX_SPEED, ); 
  mb.(REG_ACCELERATION, ); 
  
  mb.(REG_TARGET_X, );
  mb.(REG_TARGET_Y, );
  
  mb.(REG_CONTROL_MODE, SPEED_CTRL);
  
   ( i = ; i < ; i++) {
    mb.(i, );
  }
}

{
  
   (event == Modbus::EX_SUCCESS) {
    Serial.();
    Serial.(address);
    Serial.();
    Serial.(val);
    
     (address) {
       REG_SET_SPEED:
        (val);
        ;
       REG_CONTROL_MODE:
        ctrlMode = (ControlMode)(val, , );
        Serial.();
        Serial.(ctrlMode);
        ;
       REG_TARGET_X:
       REG_TARGET_Y:
         (ctrlMode == POSITION_CTRL || ctrlMode == TRAJECTORY_CTRL) {
          ();
        }
        ;
      :
        
        mb.(address, val);
    }
     ;
  }
   ;
}

{
  
   speedSetpoint = speedReg / ; 
  
    currentSpeed = ;
   maxAccel = mb.(REG_ACCELERATION) / ;
   maxSpeed = mb.(REG_MAX_SPEED) / ;
  
   (speedSetpoint > currentSpeed) {
    currentSpeed = (currentSpeed + maxAccel * , speedSetpoint);
  }  {
    currentSpeed = (currentSpeed - maxAccel * , speedSetpoint);
  }
  
  currentSpeed = (currentSpeed, -maxSpeed, maxSpeed);
  
  iState.speedActual = currentSpeed;
  
   motorSpeed = currentSpeed / ; 
  motorL.(motorSpeed);
  motorR.(motorSpeed);
}

{
  
   targetX = mb.(REG_TARGET_X) / ;
   targetY = mb.(REG_TARGET_Y) / ;
  
   dx = targetX - iState.posX;
   dy = targetY - iState.posY;
   distance = (dx * dx + dy * dy);
   (distance > ) { 
    
     targetAngle = (dy, dx);
    
     angleError = targetAngle - iState.angleActual;
    
     (angleError > PI) angleError -=  * PI;
     (angleError < -PI) angleError +=  * PI;
    
     angularSpeed = angleError * ; 
    
     linearSpeed = (distance * , ); 
    
     wheelSep = ;
     leftSpeed = linearSpeed - (angularSpeed * wheelSep / );
     rightSpeed = linearSpeed + (angularSpeed * wheelSep / );
    motorL.(leftSpeed / );
    motorR.(rightSpeed / );
  }
}

{
  
  
  mb.(REG_ACTUAL_SPEED - , ()(iState.speedActual * ));
  
  mb.(REG_POSITION_X - , ()(iState.posX * ));
  mb.(REG_POSITION_Y - , ()(iState.posY * ));
  
  mb.(REG_BATTERY_VOLTAGE - , ()(iState.battery * ));
  
  mb.(REG_MOTOR_TEMP - , ()(iState.temperature[] * ));
  
  ();
  mb.(REG_STATUS_WORD - , iState.statusWord);
  
  mb.(REG_ERROR_CODE - , iState.errorCode);
}

{
  
  iState.statusWord = ;
  
  iState.statusWord |= ;
  
  iState.statusWord |= ;
  
   (iState.errorCode != ) {
    iState.statusWord |= ;
  }
  
   (iState.emergencyStop) {
    iState.statusWord |= ;
  }
  
   (iState.battery < ) {
    iState.statusWord |= ;
  }
  
  iState.statusWord |= ;
  
   ((iState.speedActual) < ) {
    iState.statusWord |= ;
  }
}

{
  
  
   (iState.battery < ) { 
    iState.errorCode = ;
    ();
  }
  
   (iState.temperature[] >  || iState.temperature[] > ) {
    iState.errorCode = ;
    (); 
  }
  
     lastComm = ;
   (() - lastComm > ) { 
    iState.errorCode = ;
    ();
  }
}

10. ROS 串行协议集成

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

#include <SimpleFOC.h>
#include <ros.h> // ROS 库
#include <geometry_msgs/Twist.h>
#include <nav_msgs/Odometry.h>
#include <sensor_msgs/BatteryState.h>
#include <std_msgs/Bool.h>

// ROS 节点句柄
ros::NodeHandle nh;

// BLDC 电机
BLDCMotor motorL, motorR;

// 里程计参数
float wheel_radius = 0.05; // 轮半径
float wheel_base = 0.30;   // 轮距
float encoder_resolution = 2048 * 4; // 编码器分辨率
float left_ticks = 0, right_ticks = 0;
float last_left_ticks = 0, last_right_ticks = 0;

// ROS 消息
geometry_msgs::Twist cmd_vel;
nav_msgs::Odometry odom_msg;
sensor_msgs::BatteryState battery_msg;
std_msgs::Bool emergency_msg;

// ROS 发布者
ros::Publisher odom_pub("odom", &odom_msg);
ros::Publisher battery_pub("battery", &battery_msg);
ros::Publisher emergency_pub("emergency_stop", &emergency_msg);

// ROS 订阅者
{
  cmd_vel = msg;
}
;


{
   (msg.data) {
    ();
  }  {
    ();
  }
}
;


 max_linear_vel = ; 
 max_angular_vel = ; 
 linear_vel = ;
 angular_vel = ;
 emergency_stop = ;


 safe_zone_x_min = , safe_zone_x_max = ;
 safe_zone_y_min = , safe_zone_y_max = ;

{
  
  Serial.(); 
  
  nh.();
  nh.(odom_pub);
  nh.(battery_pub);
  nh.(emergency_pub);
  nh.(cmd_vel_sub);
  nh.(emergency_sub);
  
  ();
  
  ();
  
  ();
  
  nh.();
  
  odom_msg.header.frame_id = ;
  odom_msg.child_frame_id = ;
}

{
  
  nh.();
  
  ();
  
   (!emergency_stop) {
    ();
  }  {
    
    motorL.();
    motorR.();
  }
  
  ();
  
  ();
  
  motorL.();
  motorR.();
  
  (); 
}

{
  
  linear_vel = (cmd_vel.linear.x, -max_linear_vel, max_linear_vel);
  angular_vel = (cmd_vel.angular.z, -max_angular_vel, max_angular_vel);
  
   left_speed = (linear_vel - angular_vel * wheel_base / ) / wheel_radius;
   right_speed = (linear_vel + angular_vel * wheel_base / ) / wheel_radius;
  
  left_speed = (left_speed, , );
  right_speed = (right_speed, , );
  
  motorL.(left_speed);
  motorR.(right_speed);
}

{
  
   current_left = motorL.shaft_angle * encoder_resolution / ( * PI);
   current_right = motorR.shaft_angle * encoder_resolution / ( * PI);
  
   delta_left = current_left - last_left_ticks;
   delta_right = current_right - last_right_ticks;
  
  last_left_ticks = current_left;
  last_right_ticks = current_right;
  left_ticks += delta_left;
  right_ticks += delta_right;
  
   left_distance = delta_left *  * PI * wheel_radius / encoder_resolution;
   right_distance = delta_right *  * PI * wheel_radius / encoder_resolution;
    x = , y = , theta = ;
  
   linear = (left_distance + right_distance) / ;
   angular = (right_distance - left_distance) / wheel_base;
  
  x += linear * (theta + angular / );
  y += linear * (theta + angular / );
  theta += angular;
  
   (theta > PI) theta -=  * PI;
   (theta < -PI) theta +=  * PI;
  
  odom_msg.header.stamp = nh.();
  odom_msg.pose.pose.position.x = x;
  odom_msg.pose.pose.position.y = y;
  odom_msg.pose.pose.position.z = ;
  
  odom_msg.pose.pose.orientation.x = ;
  odom_msg.pose.pose.orientation.y = ;
  odom_msg.pose.pose.orientation.z = (theta / );
  odom_msg.pose.pose.orientation.w = (theta / );
  
  odom_msg.twist.twist.linear.x = linear_vel;
  odom_msg.twist.twist.angular.z = angular_vel;
}

{
     last_odom_pub = ;
     last_battery_pub = ;
    now = ();
  
   (now - last_odom_pub >= ) {
    odom_pub.(&odom_msg);
    last_odom_pub = now;
  }
  
   (now - last_battery_pub >= ) {
    ();
    battery_pub.(&battery_msg);
    last_battery_pub = now;
  }
  
  emergency_msg.data = emergency_stop;
  emergency_pub.(&emergency_msg);
}

{
  battery_msg.header.stamp = nh.();
  battery_msg.voltage = ();
  battery_msg.current = ();
  battery_msg.percentage = (battery_msg.voltage);
  battery_msg.power_supply_status = sensor_msgs::BatteryState::POWER_SUPPLY_STATUS_DISCHARGING;
  battery_msg.power_supply_health = sensor_msgs::BatteryState::POWER_SUPPLY_HEALTH_GOOD;
  battery_msg.present = ;
}

{
  
   x = odom_msg.pose.pose.position.x;
   y = odom_msg.pose.pose.position.y;
   (x < safe_zone_x_min || x > safe_zone_x_max || y < safe_zone_y_min || y > safe_zone_y_max) {
     (!emergency_stop) {
      nh.();
      ();
      
      geometry_msgs::Twist return_cmd;
      return_cmd.linear.x = ;
      return_cmd.angular.z = ;
      cmd_vel = return_cmd;
    }
  }
}

{
  emergency_stop = ;
  linear_vel = ;
  angular_vel = ;
  
  motorL.();
  motorR.();
  nh.();
}

{
   (emergency_stop) {
    emergency_stop = ;
    nh.();
  }
}


{
  
  
}

11. 部署实施的工程考量

波特率选择：调试用 115200，工业 Modbus 用 9600/19200，ROS 用 57600/115200。长距离需降低波特率。
电缆要求：RS-485（Modbus）需双绞线，终端电阻 120Ω。ROS Serial 可用普通串口，但建议用 RS-485 转换抗干扰。
电源管理：工业机器人常采用 24VDC，需 DC-DC 降压为 12V（电机）和 5V/3.3V（控制板）。案例 5 的 battery < 18.0 欠压保护针对 24V 系统（6S 锂电）。
防护等级：工业环境需 IP54 以上防护，接头需防水。代码中应监控湿度传感器，高湿度报警。
维护接口：保留固件升级接口（如 USB DFU），支持远程升级。案例可扩展为通过 Modbus 写特定寄存器触发固件更新。

Arduino BLDC 基于串口指令的远程控制工业巡检机器人

基于 Arduino 的 BLDC 串口指令远程控制工业巡检机器人

1. 主要特点

高可靠性的串口通信架构

BLDC 驱动的高机动性与长续航

模块化与可扩展性

2. 应用场景

3. 注意事项

通信稳定性与抗干扰

电源管理与系统分区

安全机制与故障处理

协议设计与状态同步

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

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

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

7. 要点解读

通信协议设计

多电机同步控制

闭环控制必要性

安全与容错

扩展性与模块化

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

9. 工业 Modbus RTU 串口控制

10. ROS 串行协议集成

11. 部署实施的工程考量

更多推荐文章

相关免费在线工具

Arduino BLDC 基于串口指令的远程控制工业巡检机器人

基于 Arduino 的 BLDC 串口指令远程控制工业巡检机器人

1. 主要特点

高可靠性的串口通信架构

BLDC 驱动的高机动性与长续航

模块化与可扩展性

2. 应用场景

3. 注意事项

通信稳定性与抗干扰

电源管理与系统分区

安全机制与故障处理

协议设计与状态同步

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

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

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

7. 要点解读

通信协议设计

多电机同步控制

闭环控制必要性

安全与容错

扩展性与模块化

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

9. 工业 Modbus RTU 串口控制

10. ROS 串行协议集成

11. 部署实施的工程考量

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具