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

6、多电机差速转向控制（机器人底盘运动）
功能：通过双电机差速实现机器人底盘的前进、后退、转向及原地旋转。
硬件扩展：
电机1 → ESC1（GPIO23）
电机2 → ESC2（GPIO22）
编码器1 → GPIO16/17
编码器2 → GPIO4/5
[code]#include
#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);
}[/code]
要点解读
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版本可能影响使用方法的选择。实际编程时，您要根据自己的硬件配置、使用场景和具体需求进行调整，并多次实际测试。您还要正确连接硬件，了解所用传感器和设备的规范和特性。涉及硬件操作的代码，您要在使用前确认引脚和电平等参数的正确性和安全性。

5、基于编码器的闭环速度控制（PID）
功能：通过编码器反馈实现电机速度闭环控制，解决大功率电机启动冲击问题。
硬件扩展：
电机编码器 → ESP32 GPIO16（CLK）、GPIO17（DATA）
使用Encoder库读取脉冲数
[code]#include
#include
#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);
}[/code]

4、基础双向ESC控制（PWM信号）
功能：通过ESP32的PWM控制大功率双向ESC，实现机器人底盘的正反转、加速/减速及停止。
硬件连接：
ESP32 GPIO23 → ESC PWM信号线（白色/橙色）
ESC电源线 → 独立锂电池（24V/36V）
电机 → 6.5寸无刷轮毂电机（带编码器）
[code]#include
#include
#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);
}
}[/code]

3、ESP32 + 多ESC同步的SWD调试与OTA升级
场景：四轮全向移动机器人，需要精确同步和远程维护。
核心逻辑：ESP32通过SPI控制多个ESC，集成SWD调试和OTA功能。
[code]#include
#include // OTA升级
#include
#include
#include
// 四电机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);
}
}
}[/code]
要点解读
通信协议的选择决定系统性能上限
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，支持断电保存和远程配置。

2、ESP32 + VESC 6.0 高性能FOC控制
场景：大功率机器人底盘，需要最高性能的FOC控制与能量回馈。
核心逻辑：ESP32通过UART与VESC通信，使用VESC Tool协议。
[code]#include
#include // 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("转速过高!");
}
}[/code]

1、ESP32 + 标准双向ESC的CAN总线控制
场景：中型机器人底盘，需要高功率和精确速度控制。
核心逻辑：ESP32通过CAN总线发送DShot协议指令，控制多个ESC同步。
[code]#include
#include // ESP32 CAN库
#include
// 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)
// 实际代码需要处理位时序生成
}[/code]