ESP32 + 大功率双向 ESC 机器人底盘动力控制方案

电磁兼容（EMC）与信号抗干扰

• 布线规范：强电（电机线、电池线）与弱电（ESP32 信号线、传感器线）必须分开走线，严禁平行走线，最好呈 90°垂直交叉。
• 硬件滤波：在 ESP32 的 GPIO 输入引脚上串联小电阻并并联对地电容，构成硬件低通滤波器，滤除高频噪声干扰。
• 隔离措施：在极端干扰环境下，可考虑使用光耦或磁耦隔离器件对控制信号进行隔离传输。

散热设计与硬件保护

• ESC 与 MOSFET 散热：大功率 ESC 在持续大电流工作时发热量巨大。必须为其安装足够尺寸的散热片，必要时加装风扇进行强制风冷。
• 软件保护机制：在 ESP32 程序中设置完善的保护逻辑，包括软件看门狗、电流异常检测、电压监测及紧急停止功能。

双向控制与死区处理

• 信号映射与死区消除：双向 ESC 通常接受 1000μs-2000μs 的 PWM 信号，其中 1500μs 为中心点。在程序中需精确映射正反转的占空比范围，并设置合理的死区，防止在零速附近因信号微小抖动导致电机频繁启停。
• 换向延时：在正反转切换瞬间，为防止 ESC 内部上下桥臂直通或电机产生巨大电流冲击，软件中应加入微小的延时，先将速度归零，再施加反向指令。

代码示例

1、ESP32 + 标准双向 ESC 的 CAN 总线控制

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

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

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

// ESC 参数
#define ESC_MIN_PULSE 1000
#define ESC_MAX_PULSE 2000
#define ESC_NEUTRAL 1500

// CAN ID
#define CAN_ID_ESC1 0x101
#define CAN_ID_ESC2 0x102

// DShot 协议参数
#define DSHOT_CMD_MOTOR_STOP 0
#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)) {
    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);
  timerAttachInterrupt(dshotTimer, &dshotISR, true);
  timerAlarmWrite(dshotTimer, 5, true);
  timerAlarmEnable(dshotTimer);
  
  // 4. ESC 上电自检
  escArmSequence();
  Serial.println("系统初始化完成");
}

void loop() {
  float throttle = getThrottleInput();
  float steering = getSteeringInput();
  
  // 差速计算
  float leftPower = throttle + steering;
  float rightPower = throttle - steering;
  
  // 限制和死区处理
  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;
  
  // 转换为 ESC 指令
  uint16_t escCmd1 = powerToDshot(leftPower);
  uint16_t escCmd2 = powerToDshot(rightPower);
  
  // 发送 CAN 帧
  sendDshotOverCAN(CAN_ID_ESC1, escCmd1);
  sendDshotOverCAN(CAN_ID_ESC2, escCmd2);
  
  // 更新 FOC 内部状态
  motor1.move(leftPower);
  motor2.move(rightPower);
  
  // 读取 ESC 遥测数据
  if (CAN.parsePacket()) {
    processESCTelemetry(CAN.read());
  }
  delay(5); // 200Hz 控制频率
}

uint16_t powerToDshot(float power) {
  if (power == 0) return 0;
  uint16_t pulse = ESC_NEUTRAL + (int16_t)(power * 500);
  pulse = constrain(pulse, ESC_MIN_PULSE, ESC_MAX_PULSE);
  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) {
  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);
  CAN.write((uint8_t)(dshotPacket >> 8));
  CAN.write((uint8_t)(dshotPacket & 0xFF));
  CAN.endPacket();
}

void escArmSequence() {
  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 时序
}

2、ESP32 + VESC 6.0 高性能 FOC 控制

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

#include <SimpleFOC.h>
#include <VescUart.h>

VescUart vescLeft;
VescUart vescRight;

#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);
  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);
  
  delay(1000);
  setVescMode(VESC_MODE_CURRENT, 30.0);
  ledcSetup(0, 500, 8);
  ledcAttachPin(25, 0);
  startSafetyMonitor();
  Serial.println("VESC 6.0 动力系统就绪");
}

void loop() {
  static uint32_t lastControlTime = 0;
  uint32_t now = millis();
  
  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);
    
    vescLeft.setCurrent(leftCurrent);
    vescRight.setCurrent(rightCurrent);
    lastControlTime = now;
  }
  
  handleRegenerativeBraking();
  monitorSafety();
}

void setVescMode(uint8_t mode, float limit) {
  switch(mode) {
    case VESC_MODE_CURRENT:
      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) {
      vescLeft.setCurrent(-5.0);
    }
  }
}

void monitorSafety() {
  if (telemetryLeft.voltage < 20.0 || telemetryRight.voltage < 20.0) {
    emergencyShutdown("电池电压过低!");
  }
  if (abs(telemetryLeft.current) > 35.0 || abs(telemetryRight.current) > 35.0) {
    emergencyShutdown("电流过载!");
  }
}

3、ESP32 + 多 ESC 同步的 SWD 调试与 OTA 升级

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

#include <SimpleFOC.h>
#include <Update.h>
#include <WiFi.h>
#include <WebServer.h>

BLDCMotor motorFL, motorFR, motorRL, motorRR;

#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;

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);
  spi_bus_config_t buscfg = {
    .mosi_io_num = ESC_SPI_MOSI,
    .miso_io_num = ESC_SPI_MISO,
    .sclk_io_num = ESC_SPI_SCLK,
    .max_transfer_sz = 4096
  };
  spi_bus_initialize(ESC_SPI_HOST, &buscfg, SPI_DMA_CH_AUTO);
  
  initESCDevice(ESC_CS1_PIN, 0);
  initESCDevice(ESC_CS2_PIN, 1);
  initESCDevice(ESC_CS3_PIN, 2);
  initESCDevice(ESC_CS4_PIN, 3);
  
  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();
  
  syncCtrl.syncEnabled = true;
  startSyncTimer();
  Serial.println("多 ESC 同步系统就绪");
}

void loop() {
  server.handleClient();
  if (readControlInput()) {
    calculateMecanumKinematics();
    if (syncCtrl.syncEnabled) synchronizeESCs();
    sendSPICommands();
    readTelemetrySPI();
  }
  monitorSystem();
}

void synchronizeESCs() {
  static uint32_t lastSync = 0;
  uint32_t now = micros();
  float dt = (now - lastSync) / 1e6;
  if (dt >= 0.01) {
    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 handleUpdate() {
  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);
    }
  }
}

4、基础双向 ESC 控制（PWM 信号）

功能：通过 ESP32 的 PWM 控制大功率双向 ESC，实现机器人底盘的正反转、加速/减速及停止。

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

#define ESC_PIN 23
#define PWM_FREQ 50

void setup() {
  Serial.begin(115200);
  ledcSetup(0, PWM_FREQ, 10);
  ledcAttachPin(ESC_PIN, 0);
  
  Serial.println("ESC Calibration Start...");
  ledcWrite(0, 512); // 最大油门
  delay(2000);
  ledcWrite(0, 102); // 最小油门
  delay(2000);
  Serial.println("Calibration Done!");
}

void loop() {
  // 正转
  for (int i = 102; i <= 512; i += 10) {
    ledcWrite(0, i);
    delay(100);
  }
  // 停止
  ledcWrite(0, 306);
  delay(1000);
  // 反转
  for (int i = 306; i >= 102; i -= 10) {
    ledcWrite(0, i);
    delay(100);
  }
}

5、基于编码器的闭环速度控制（PID）

功能：通过编码器反馈实现电机速度闭环控制，解决大功率电机启动冲击问题。

#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;
double input, output;
PID pid(&input, &output, &setpoint, 2.0, 0.5, 0.1, DIRECT);

void setup() {
  Serial.begin(115200);
  pinMode(MOTOR_PWM_PIN, OUTPUT);
  pid.SetMode(AUTOMATIC);
  pid.SetOutputLimits(-1023, 1023);
}

void loop() {
  long encValue = enc.read();
  input = (encValue / 20.0) * 60.0;
  pid.Compute();
  int pwmValue = (int)output;
  
  if (pwmValue > 0) {
    ledcWrite(0, map(pwmValue, 0, 1023, 306, 512));
  } else {
    ledcWrite(0, map(abs(pwmValue), 0, 1023, 306, 102));
  }
  delay(100);
}

6、多电机差速转向控制（机器人底盘运动）

功能：通过双电机差速实现机器人底盘的前进、后退、转向及原地旋转。

#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) {
  int pwmValue = map(speed, -100, 100, 102, 512);
  if (motor == 1) {
    ledcWrite(0, pwmValue);
  } else {
    ledcWrite(1, pwmValue);
  }
}

void moveRobot(float linearVel, float angularVel) {
  float leftSpeed = (linearVel - (angularVel * 0.5)) / 0.1;
  float rightSpeed = (linearVel + (angularVel * 0.5)) / 0.1;
  setMotorSpeed(1, leftSpeed);
  setMotorSpeed(2, rightSpeed);
}

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

void loop() {
  moveRobot(0.5, 0);
  delay(1000);
  moveRobot(0, 1.0);
  delay(500);
  moveRobot(0, 0);
  delay(1000);
}

要点解读

1. 通信协议的选择决定系统性能上限

   • CAN 总线：工业级可靠性，支持多节点同步，1Mbps 速率满足实时控制。DShot over CAN 是高端 ESC 的常见配置。
   • UART：VESC 标准协议，带宽足够，提供丰富的遥测和配置参数。
   • SPI：最高速率，可实现微秒级同步，适合多 ESC 精确协同，但布线要求高。

2. ESC 的配置模式与控制策略

   • DShot 数字协议：替代传统 PWM，抗干扰强，分辨率高，支持遥测请求。
   • VESC 的电流控制模式：最精确的扭矩控制，直接控制相电流。
   • 同步控制必要性：多 ESC 的毫秒级不同步会导致底盘'扭动'。通过交叉耦合补偿算法，让多个 ESC 的速度误差相互补偿。

3. 大功率系统的安全与保护

   • 电流限制：必须硬件（保险丝、断路器）和软件双重保护。
   • 能量回馈处理：双向 ESC 在减速时会将动能转化为电能回充电池，必须限制回馈电流，防止电池过充。
   • 温度监控：大功率 ESC 的 MOSFET 温度需实时监控，超过 85°C 应降额运行。

4. ESP32 的双核优势利用

   • Core 0：运行控制循环（FOC 算法、运动学计算），必须保证实时性。
   • Core 1：处理 WiFi、OTA、HTTP 服务器等非实时任务。

5. 系统集成与远程维护

   • OTA 升级：实现完整的 Web 端固件更新，这对于现场部署的机器人至关重要。
   • SWD 调试接口：通过 ESP32 的 JTAG 引脚可连接外部调试器，实现实时变量查看。