【花雕】ESP32 + 大功率双向 ESC｜机器人底盘动力控制方案

1、ESP32 + 标准双向ESC的CAN总线控制
场景：中型机器人底盘，需要高功率和精确速度控制。
核心逻辑：ESP32通过CAN总线发送DShot协议指令，控制多个ESC同步。

#include <SimpleFOC.h>
#include <CAN.h>  // ESP32 CAN库
#include <esp32-hal-timer.h>

// BLDC电机对象
BLDCMotor motor1 = BLDCMotor(7);
BLDCMotor motor2 = BLDCMotor(7);

// ESC参数
#define ESC_MIN_PULSE 1000   // 1ms脉冲宽度 (微秒)
#define ESC_MAX_PULSE 2000   // 2ms脉冲宽度
#define ESC_NEUTRAL 1500     // 1.5ms中性点
#define CAN_ID_ESC1 0x101
#define CAN_ID_ESC2 0x102

// DShot600协议参数
#define DSHOT_CMD_MOTOR_STOP 0
#define DSHOT_CMD_BEACON1 1
#define DSHOT_CMD_BEACON2 2
#define DSHOT_CMD_BEACON3 3
#define DSHOT_CMD_BEACON4 4
#define DSHOT_CMD_BEACON5 5
#define DSHOT_ESC_ARM 6

// CAN总线设置
#define CAN_TX_PIN GPIO_NUM_5
#define CAN_RX_PIN GPIO_NUM_4

hw_timer_t* dshotTimer = NULL;
volatile uint32_t dshotPacket1 = 0;
volatile uint32_t dshotPacket2 = 0;

void setup() {
  Serial.begin(115200);
  
  // 1. CAN总线初始化
  CAN.setPins(CAN_RX_PIN, CAN_TX_PIN);
  if (!CAN.begin(1000E3)) {  // 1Mbps CAN FD
    Serial.println("CAN初始化失败!");
    while(1);
  }
  Serial.println("CAN总线就绪");
  
  // 2. 电机FOC初始化
  motor1.init();
  motor2.init();
  motor1.initFOC();
  motor2.initFOC();
  
  // 3. DShot定时器初始化
  dshotTimer = timerBegin(0, 80, true);  // 80MHz/80 = 1MHz, 1us分辨率
  timerAttachInterrupt(dshotTimer, &dshotISR, true);
  timerAlarmWrite(dshotTimer, 5, true);  // 5us中断 (DShot600 ~2.6us bit)
  timerAlarmEnable(dshotTimer);
  
  // 4. ESC上电自检
  escArmSequence();
  
  Serial.println("系统初始化完成");
}

void loop() {
  // 1. 读取控制输入 (例如: 遥控器、上位机指令)
  float throttle = getThrottleInput();  // -1.0 ~ 1.0
  float steering = getSteeringInput();  // -1.0 ~ 1.0
  
  // 2. 差速计算
  float leftPower = throttle + steering;
  float rightPower = throttle - steering;
  
  // 3. 限制和死区处理
  leftPower = constrain(leftPower, -1.0, 1.0);
  rightPower = constrain(rightPower, -1.0, 1.0);
  if (abs(leftPower) < 0.05) leftPower = 0;
  if (abs(rightPower) < 0.05) rightPower = 0;
  
  // 4. 转换为ESC指令
  uint16_t escCmd1 = powerToDshot(leftPower);
  uint16_t escCmd2 = powerToDshot(rightPower);
  
  // 5. 发送CAN帧
  sendDshotOverCAN(CAN_ID_ESC1, escCmd1);
  sendDshotOverCAN(CAN_ID_ESC2, escCmd2);
  
  // 6. 更新FOC内部状态
  motor1.move(leftPower);
  motor2.move(rightPower);
  
  // 7. 读取ESC遥测数据
  if (CAN.parsePacket()) {
    processESCTelemetry(CAN.read());
  }
  
  delay(5);  // 200Hz控制频率
}

uint16_t powerToDshot(float power) {
  // 将-1.0~1.0功率转换为DShot指令
  if (power == 0) return 0;  // 电机停止
  
  // 双向ESC: 1500±500us
  uint16_t pulse = ESC_NEUTRAL + (int16_t)(power * 500);
  pulse = constrain(pulse, ESC_MIN_PULSE, ESC_MAX_PULSE);
  
  // 转换为DShot值 (0~2047)
  uint16_t dshotValue = map(pulse, ESC_MIN_PULSE, ESC_MAX_PULSE, 0, 2047);
  dshotValue = constrain(dshotValue, 48, 2047);  // 有效范围
  
  return dshotValue;
}

void sendDshotOverCAN(uint32_t id, uint16_t command) {
  // 构建DShot包: 11位命令 + 1位遥测请求 + 4位CRC
  uint16_t packet = (command << 1) | 0x1;  // 设置遥测请求位
  uint8_t crc = (packet ^ (packet >> 4) ^ (packet >> 8)) & 0x0F;
  uint16_t dshotPacket = (packet << 4) | crc;
  
  CAN.beginPacket(id, 2);  // 2字节数据
  CAN.write((uint8_t)(dshotPacket >> 8));
  CAN.write((uint8_t)(dshotPacket & 0xFF));
  CAN.endPacket();
}

void escArmSequence() {
  // ESC上电解锁序列
  Serial.println("ESC解锁中...");
  for(int i=0; i<3; i++) {
    sendDshotOverCAN(CAN_ID_ESC1, 0);
    sendDshotOverCAN(CAN_ID_ESC2, 0);
    delay(100);
  }
  sendDshotOverCAN(CAN_ID_ESC1, DSHOT_ESC_ARM);
  sendDshotOverCAN(CAN_ID_ESC2, DSHOT_ESC_ARM);
  delay(200);
  Serial.println("ESC解锁完成");
}

void IRAM_ATTR dshotISR() {
  // DShot时序生成 (在定时器中断中执行)
  static uint8_t bitCount = 0;
  // 实现DShot600时序 (600kbps, 1.67us/bit)
  // 实际代码需要处理位时序生成
}
复制代码

2、ESP32 + VESC 6.0 高性能FOC控制
场景：大功率机器人底盘，需要最高性能的FOC控制与能量回馈。
核心逻辑：ESP32通过UART与VESC通信，使用VESC Tool协议。

#include <SimpleFOC.h>
#include <VescUart.h>  // VESC UART协议库

// VESC对象
VescUart vescLeft;
VescUart vescRight;

// ESP32硬件串口
#define UART_LEFT_NUM UART_NUM_1
#define UART_RIGHT_NUM UART_NUM_2
#define UART_LEFT_TX 17
#define UART_LEFT_RX 16
#define UART_RIGHT_TX 5
#define UART_RIGHT_RX 4

// 遥测数据结构
struct VescTelemetry {
  float rpm;
  float current;
  float duty;
  float voltage;
  uint32_t tachometer;
};

VescTelemetry telemetryLeft, telemetryRight;

void setup() {
  Serial.begin(115200);
  
  // 1. 初始化VESC UART连接
  vescLeft.setSerialPort(&Serial1);
  vescRight.setSerialPort(&Serial2);
  
  Serial1.begin(115200, SERIAL_8N1, UART_LEFT_RX, UART_LEFT_TX);
  Serial2.begin(115200, SERIAL_8N1, UART_RIGHT_RX, UART_RIGHT_TX);
  
  // 2. 设置VESC工作模式
  delay(1000);
  setVescMode(VESC_MODE_CURRENT, 30.0);  // 电流控制模式, 30A限流
  
  // 3. 配置ESP32的PWM输出用于模拟油门信号 (备用)
  ledcSetup(0, 500, 8);  // 通道0, 500Hz, 8位分辨率
  ledcAttachPin(25, 0);  // 引脚25连接ESC油门线
  
  // 4. 启动安全检测
  startSafetyMonitor();
  
  Serial.println("VESC 6.0动力系统就绪");
}

void loop() {
  static uint32_t lastTelemetryTime = 0;
  static uint32_t lastControlTime = 0;
  uint32_t now = millis();
  
  // 1. 20Hz控制环
  if (now - lastControlTime >= 50) {
    float throttle = getThrottleCommand();  // 来自遥控/上位机
    float steering = getSteeringCommand();
    
    // 计算差速功率
    float leftCurrent = throttle + steering;
    float rightCurrent = throttle - steering;
    
    // 电流限制
    leftCurrent = constrain(leftCurrent, -30.0, 30.0);
    rightCurrent = constrain(rightCurrent, -30.0, 30.0);
    
    // 发送电流指令到VESC
    vescLeft.setCurrent(leftCurrent);
    vescRight.setCurrent(rightCurrent);
    
    lastControlTime = now;
  }
  
  // 2. 10Hz遥测读取
  if (now - lastTelemetryTime >= 100) {
    if (vescLeft.getVescValues()) {
      telemetryLeft.rpm = vescLeft.data.rpm;
      telemetryLeft.current = vescLeft.data.avgMotorCurrent;
      telemetryLeft.voltage = vescLeft.data.inpVoltage;
      telemetryLeft.tachometer = vescLeft.data.tachometerAbs;
    }
    
    if (vescRight.getVescValues()) {
      telemetryRight.rpm = vescRight.data.rpm;
      telemetryRight.current = vescRight.data.avgMotorCurrent;
      telemetryRight.voltage = vescRight.data.inpVoltage;
      telemetryRight.tachometer = vescRight.data.tachometerAbs;
    }
    
    // 监控和保护
    monitorSafety();
    
    lastTelemetryTime = now;
  }
  
  // 3. 能量回馈制动处理
  handleRegenerativeBraking();
  
  // 4. 串口调试输出
  if (now % 500 < 50) {  // 每500ms输出一次
    debugOutput();
  }
}

void setVescMode(uint8_t mode, float limit) {
  // 设置VESC工作模式
  switch(mode) {
    case VESC_MODE_CURRENT:
      // 通过VESC UART命令设置电流控制模式
      // vescLeft.setCurrentControl();
      break;
    case VESC_MODE_DUTY:
      // 占空比控制模式
      break;
    case VESC_MODE_RPM:
      // 转速控制模式
      break;
  }
}

void handleRegenerativeBraking() {
  // 能量回馈制动逻辑
  if (telemetryLeft.rpm > 100 && telemetryLeft.current < -2.0) {
    // 电机转速高且电流为负，处于发电状态
    float brakePower = abs(telemetryLeft.current) * telemetryLeft.voltage;
    if (brakePower > 50.0) {  // 回馈功率大于50W
      // 限制回馈电流，保护电池
      vescLeft.setCurrent(-5.0);  // 限制回馈电流为5A
    }
  }
}

void monitorSafety() {
  // 安全监控
  if (telemetryLeft.voltage < 20.0 || telemetryRight.voltage < 20.0) {
    emergencyShutdown("电池电压过低!");
  }
  if (abs(telemetryLeft.current) > 35.0 || abs(telemetryRight.current) > 35.0) {
    emergencyShutdown("电流过载!");
  }
  if (telemetryLeft.rpm > 10000 || telemetryRight.rpm > 10000) {
    emergencyShutdown("转速过高!");
  }
}
复制代码

3、ESP32 + 多ESC同步的SWD调试与OTA升级
场景：四轮全向移动机器人，需要精确同步和远程维护。
核心逻辑：ESP32通过SPI控制多个ESC，集成SWD调试和OTA功能。

#include <SimpleFOC.h>
#include <Update.h>  // OTA升级
#include <WiFi.h>
#include <WebServer.h>
#include <esp_spi.h>

// 四电机Mecanum轮底盘
BLDCMotor motorFL, motorFR, motorRL, motorRR;

// ESC SPI通信
#define ESC_SPI_HOST SPI2_HOST
#define ESC_SPI_MISO 19
#define ESC_SPI_MOSI 23
#define ESC_SPI_SCLK 18
#define ESC_CS1_PIN 15
#define ESC_CS2_PIN 2
#define ESC_CS3_PIN 4
#define ESC_CS4_PIN 5

spi_device_handle_t esc_spi;

// OTA和WiFi
WebServer server(80);
const char* ssid = "Robot_AP";
const char* password = "robot1234";

// 同步控制结构
struct SyncControl {
  float targetSpeed[4];
  float actualSpeed[4];
  uint32_t syncCounter;
  bool syncEnabled;
};
SyncControl syncCtrl;

void setup() {
  Serial.begin(115200);
  
  // 1. 初始化ESC SPI通信
  spi_bus_config_t buscfg = {
    .mosi_io_num = ESC_SPI_MOSI,
    .miso_io_num = ESC_SPI_MISO,
    .sclk_io_num = ESC_SPI_SCLK,
    .quadwp_io_num = -1,
    .quadhd_io_num = -1,
    .max_transfer_sz = 4096
  };
  spi_bus_initialize(ESC_SPI_HOST, &buscfg, SPI_DMA_CH_AUTO);
  
  // 2. 初始化各个ESC设备
  initESCDevice(ESC_CS1_PIN, 0);
  initESCDevice(ESC_CS2_PIN, 1);
  initESCDevice(ESC_CS3_PIN, 2);
  initESCDevice(ESC_CS4_PIN, 3);
  
  // 3. 初始化WiFi和OTA
  WiFi.softAP(ssid, password);
  IPAddress IP = WiFi.softAPIP();
  Serial.print("AP IP: "); Serial.println(IP);
  
  server.on("/", handleRoot);
  server.on("/update", HTTP_POST, handleUpdate, handleUpload);
  server.begin();
  
  // 4. 初始化同步控制
  syncCtrl.syncEnabled = true;
  syncCtrl.syncCounter = 0;
  
  // 5. 启动同步定时器
  startSyncTimer();
  
  Serial.println("多ESC同步系统就绪");
}

void loop() {
  // 1. 处理Web服务器请求
  server.handleClient();
  
  // 2. 读取控制指令
  if (readControlInput()) {
    // 3. 计算Mecanum运动学
    calculateMecanumKinematics();
    
    // 4. 同步控制所有ESC
    if (syncCtrl.syncEnabled) {
      synchronizeESCs();
    }
    
    // 5. 发送SPI指令
    sendSPICommands();
    
    // 6. 读取遥测
    readTelemetrySPI();
  }
  
  // 7. 监控系统状态
  monitorSystem();
}

void synchronizeESCs() {
  // 精确同步算法
  static uint32_t lastSync = 0;
  uint32_t now = micros();
  float dt = (now - lastSync) / 1e6;
  
  if (dt >= 0.01) {  // 100Hz同步
    // 计算同步误差
    float speedErrors[4];
    for (int i = 0; i < 4; i++) {
      speedErrors[i] = syncCtrl.targetSpeed[i] - syncCtrl.actualSpeed[i];
    }
    
    // 交叉耦合补偿
    float avgError = (speedErrors[0] + speedErrors[1] + 
                     speedErrors[2] + speedErrors[3]) / 4.0;
    
    // 应用补偿
    for (int i = 0; i < 4; i++) {
      syncCtrl.targetSpeed[i] += (avgError - speedErrors[i]) * 0.1;
    }
    
    lastSync = now;
    syncCtrl.syncCounter++;
  }
}

void sendSPICommands() {
  // 批量SPI传输
  uint8_t txData[4][8];
  uint8_t rxData[4][8];
  
  for (int esc = 0; esc < 4; esc++) {
    // 构建ESC命令包
    packESCCommand(txData[esc], syncCtrl.targetSpeed[esc]);
    
    spi_transaction_t t = {
      .tx_buffer = txData[esc],
      .rx_buffer = rxData[esc],
      .length = 8 * 8,
      .rxlength = 8 * 8
    };
    
    // 选择对应的ESC
    digitalWrite(getCSPin(esc), LOW);
    spi_device_polling_transmit(esc_spi, &t);
    digitalWrite(getCSPin(esc), HIGH);
    
    // 解析响应
    parseESCResponse(rxData[esc], esc);
  }
}

void handleUpdate() {
  // OTA固件更新处理
  HTTPUpload& upload = server.upload();
  if (upload.status == UPLOAD_FILE_START) {
    Serial.printf("更新开始: %s\n", upload.filename.c_str());
    if (!Update.begin(UPDATE_SIZE_UNKNOWN)) {
      Update.printError(Serial);
    }
  } else if (upload.status == UPLOAD_FILE_WRITE) {
    if (Update.write(upload.buf, upload.currentSize) != upload.currentSize) {
      Update.printError(Serial);
    }
  } else if (upload.status == UPLOAD_FILE_END) {
    if (Update.end(true)) {
      Serial.printf("更新成功: %u字节\n", upload.totalSize);
      server.send(200, "text/plain", "更新成功，系统将重启");
      delay(1000);
      ESP.restart();
    } else {
      Update.printError(Serial);
    }
  }
}
复制代码

要点解读
通信协议的选择决定系统性能上限
CAN总线（案例一）：工业级可靠性，支持多节点（ESC）同步，1Mbps速率满足实时控制。DShot over CAN是高端ESC的常见配置，支持双向遥测。
UART（案例二）：VESC标准协议，带宽足够，但线缆复杂。VESC Tool协议提供丰富的遥测和配置参数。
SPI（案例三）：最高速率（可达10Mbps），可实现微秒级同步，适合多ESC精确协同，但布线要求高，抗干扰能力弱于CAN。
ESC的配置模式与控制策略
DShot数字协议：替代传统PWM，抗干扰强，分辨率高（11位），支持遥测请求。案例一的powerToDshot()函数实现功率到DShot值的映射。
VESC的电流控制模式：最精确的扭矩控制，直接控制相电流。案例二中setCurrent()是VESC的高级API，需要精确的电机参数配置。
同步控制必要性：多ESC的毫秒级不同步会导致底盘“扭动”。案例三的synchronizeESCs()通过交叉耦合补偿算法，让4个ESC的速度误差相互补偿，实现真正的同步。
大功率系统的安全与保护
电流限制：必须硬件（保险丝、断路器）和软件双重保护。案例二的setVescMode(VESC_MODE_CURRENT, 30.0)设置软件限流。
能量回馈处理：双向ESC在减速时会将动能转化为电能回充电池。案例二的handleRegenerativeBraking()必须限制回馈电流，防止电池过充。
温度监控：大功率ESC的MOSFET温度需实时监控，通常通过ESC遥测获取，超过85°C应降额运行。
ESP32的双核优势利用
Core 0：运行控制循环（FOC算法、运动学计算），必须保证实时性。可使用FreeRTOS任务绑定到核心0。
Core 1：处理WiFi、OTA、HTTP服务器等非实时任务。案例三的Web服务器运行在Core 1，避免干扰控制任务。
定时器中断：案例一的dshotISR()在定时器中断中生成精确的DShot时序，不依赖主循环，保证了时序精度。
系统集成与远程维护
OTA升级：案例三的handleUpdate()实现完整的Web端固件更新，这对于现场部署的机器人至关重要。
SWD调试接口：通过ESP32的JTAG引脚可连接外部调试器，实现实时变量查看、断点调试。需在代码中保留调试符号。
配置持久化：ESC参数（PID、电流限制、电机极对数）应存储于ESP32的NVS或外部EEPROM，支持断电保存和远程配置。

4、基础双向ESC控制（PWM信号）
功能：通过ESP32的PWM控制大功率双向ESC，实现机器人底盘的正反转、加速/减速及停止。
硬件连接：

ESP32 GPIO23 → ESC PWM信号线（白色/橙色）
ESC电源线 → 独立锂电池（24V/36V）
电机 → 6.5寸无刷轮毂电机（带编码器）

#include <Arduino.h>
#include <driver/timer.h>

#define ESC_PIN 23
#define PWM_FREQ 50  // 50Hz PWM周期20ms

void setup() {
  Serial.begin(115200);
  ledcSetup(0, PWM_FREQ, 10);  // 10位分辨率（0-1023）
  ledcAttachPin(ESC_PIN, 0);
  
  // ESC校准（部分大功率ESC需要）
  Serial.println("ESC Calibration Start...");
  ledcWrite(0, 512);  // 最大油门（约2000μs）
  delay(2000);
  ledcWrite(0, 102);  // 最小油门（约1000μs）
  delay(2000);
  Serial.println("Calibration Done!");
}

void loop() {
  // 正转（油门1500μs-2000μs）
  for (int i = 102; i <= 512; i += 10) {  // 1000μs→2000μs
    ledcWrite(0, i);
    Serial.print("Throttle: "); Serial.println(i);
    delay(100);
  }
  
  // 停止（1500μs）
  ledcWrite(0, 306);  // 1500μs
  delay(1000);
  
  // 反转（油门1000μs-1500μs）
  for (int i = 306; i >= 102; i -= 10) {
    ledcWrite(0, i);
    Serial.print("Reverse Throttle: "); Serial.println(i);
    delay(100);
  }
}
复制代码

5、基于编码器的闭环速度控制（PID）
功能：通过编码器反馈实现电机速度闭环控制，解决大功率电机启动冲击问题。
硬件扩展：

电机编码器 → ESP32 GPIO16（CLK）、GPIO17（DATA）
使用Encoder库读取脉冲数

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

#define MOTOR_PWM_PIN 23
#define ENCODER_PIN_A 16
#define ENCODER_PIN_B 17

Encoder enc(ENCODER_PIN_A, ENCODER_PIN_B);
double setpoint = 1000;  // 目标转速（RPM）
double input, output;
PID pid(&input, &output, &setpoint, 2.0, 0.5, 0.1, DIRECT);  // P=2.0, I=0.5, D=0.1

void setup() {
  Serial.begin(115200);
  pinMode(MOTOR_PWM_PIN, OUTPUT);
  pid.SetMode(AUTOMATIC);
  pid.SetOutputLimits(-1023, 1023);  // 限制PWM输出范围
}

void loop() {
  long encValue = enc.read();  // 读取编码器脉冲数
  input = (encValue / 20.0) * 60.0;  // 转换为RPM（假设20脉冲/转）
  
  pid.Compute();
  int pwmValue = (int)output;
  
  // 双向控制：正转/反转
  if (pwmValue > 0) {
    ledcWrite(0, map(pwmValue, 0, 1023, 306, 512));  // 1500μs→2000μs
  } else {
    ledcWrite(0, map(abs(pwmValue), 0, 1023, 306, 102));  // 1500μs→1000μs
  }
  
  Serial.print("Target RPM: "); Serial.print(setpoint);
  Serial.print(" Actual RPM: "); Serial.println(input);
  delay(100);
}
复制代码

6、多电机差速转向控制（机器人底盘运动）
功能：通过双电机差速实现机器人底盘的前进、后退、转向及原地旋转。
硬件扩展：

电机1 → ESC1（GPIO23）
电机2 → ESC2（GPIO22）
编码器1 → GPIO16/17
编码器2 → GPIO4/5

#include <Encoder.h>

#define ESC1_PIN 23
#define ESC2_PIN 22
Encoder enc1(16, 17);
Encoder enc2(4, 5);

void setMotorSpeed(int motor, int speed) {
  // motor=1: ESC1, motor=2: ESC2
  // speed范围: -100（全反转）到100（全正转）
  int pwmValue = map(speed, -100, 100, 102, 512);  // 1000μs→2000μs
  if (motor == 1) {
    ledcWrite(0, pwmValue);  // ESC1
  } else {
    ledcWrite(1, pwmValue);  // ESC2
  }
}

void moveRobot(float linearVel, float angularVel) {
  // linearVel: 线速度（m/s），angularVel: 角速度（rad/s）
  // 假设轮距=0.5m，轮半径=0.1m
  float leftSpeed = (linearVel - (angularVel * 0.5)) / 0.1;  // 转换为RPM
  float rightSpeed = (linearVel + (angularVel * 0.5)) / 0.1;
  
  setMotorSpeed(1, leftSpeed);
  setMotorSpeed(2, rightSpeed);
}

void setup() {
  ledcSetup(0, 50, 10);  // ESC1
  ledcSetup(1, 50, 10);  // ESC2
  ledcAttachPin(ESC1_PIN, 0);
  ledcAttachPin(ESC2_PIN, 1);
}

void loop() {
  // 示例：前进1秒，右转0.5秒
  moveRobot(0.5, 0);  // 前进0.5m/s
  delay(1000);
  moveRobot(0, 1.0);  // 右转（角速度1.0rad/s）
  delay(500);
  moveRobot(0, 0);    // 停止
  delay(1000);
}
复制代码

要点解读
1、电源隔离与保护
大功率ESC和电机需独立供电（如24V锂电池），避免ESP32因电流过大损坏。
使用隔离DC-DC模块为ESP32供电，并确保电机电源线与信号线分开走线，加装磁环滤波。
2、ESC校准与通信协议
部分大功率ESC需校准（如发送最大/最小油门信号），否则可能无法启动。
双向ESC的PWM范围通常为1000μs（反转）至2000μs（正转），1500μs为停止。
3、闭环控制必要性
开环控制易因负载变化导致速度不稳定，需通过编码器实现PID闭环控制。
案例5中通过编码器反馈调整PWM输出，解决启动冲击和速度波动问题。
4、多电机同步与差速算法
机器人底盘需通过双电机差速实现转向（案例3），需精确计算左右轮速度。
需考虑轮距、轮半径等机械参数，避免转向半径过大或失控。
5、实时性与安全性设计
控制周期需稳定且低延迟（如<50ms），否则会导致轨迹震荡或响应迟缓。
必须设计硬件急停按钮，并在软件中设置超时检测（Watchdog），防止通信中断时电机失控。

注意，以上案例只是为了拓展思路，仅供参考。它们可能有错误、不适用或者无法编译。您的硬件平台、使用场景和Arduino版本可能影响使用方法的选择。实际编程时，您要根据自己的硬件配置、使用场景和具体需求进行调整，并多次实际测试。您还要正确连接硬件，了解所用传感器和设备的规范和特性。涉及硬件操作的代码，您要在使用前确认引脚和电平等参数的正确性和安全性。