【花雕学编程】Arduino BLDC 之 ESP32 控制大功率 ESC 电调｜驱动 6.5 寸无刷轮毂电机机器人底盘

基于 Arduino 框架开发的 ESP32 + 大功率 ESC + 6.5 寸无刷轮毂电机 机器人底盘方案，是当前中小型移动机器人领域中极具竞争力的“黄金动力组合”。该方案将 ESP32 的高性能计算与无线连接能力、大功率电子调速器（ESC）的强劲驱动能力以及 6.5 寸无刷轮毂电机的一体化高扭矩输出完美结合，为机器人提供了强劲的“心脏”与“神经中枢”。

1、主要特点
强劲动力与一体化执行机构
6.5 寸无刷轮毂电机是该系统的核心执行单元，其一体化设计极大地简化了机械结构。
高扭矩与大负载：该尺寸轮毂电机通常内置行星减速机构（减速比常见为 1:15 至 1:30），配合大功率 ESC，能输出 8-25 N·m 的峰值扭矩。这种特性使其轻松驱动 30kg-80kg 级别的机器人底盘，具备出色的爬坡能力和越障性能。
无刷化与长寿命：采用无刷直流（BLDC）技术，消除了电刷磨损，寿命可达数千小时，且运行噪音低，适合室内外多种环境。
一体化集成：电机、减速箱、轮毂和轴承高度集成，安装时仅需固定轴或法兰，无需复杂的皮带或链条传动，结构紧凑，维护成本低。
高性能主控与实时闭环控制
ESP32 凭借其强大的硬件资源，成为处理复杂底盘控制算法的理想平台。
高精度 PWM 生成：ESP32 具备多路高分辨率 LEDC PWM 通道，可生成频率稳定、分辨率极高的 PWM 信号（分辨率可达 16 位甚至更高）。相比传统 8 位单片机，它能对电机转速进行更细腻、更平滑的控制，避免低速抖动。
实时闭环能力：ESP32 的双核 240MHz 主频足以运行复杂的 PID 控制算法。通过读取轮毂电机内置的霍尔传感器信号或外接编码器信号，系统可构建速度闭环和位置闭环，实现精准的定速巡航、里程计（Odometry）计算以及多电机同步控制。
多传感器融合：强大的算力支持融合 IMU（惯性测量单元）、电流传感器等数据。例如，利用 IMU 补偿坡度对电机负载的影响，或通过电流反馈实现堵转保护和电子差速。
无线通信与远程监控
这是 ESP32 相较于传统 Arduino 板卡的核心优势，赋予了机器人“联网”与“远程控制”的能力。
Wi-Fi 与蓝牙双模：内置的 Wi-Fi 可让机器人接入局域网或作为热点，实现远程遥控、实时视频回传（如搭配摄像头）或数据上报至云端服务器。蓝牙则可用于连接手持终端或作为备用通信链路。
OTA 在线升级：支持通过无线网络对 ESP32 进行固件更新（Over-The-Air），无需物理连接 USB 线，极大地方便了机器人的后期维护、功能迭代和批量部署。

2、 应用场景
重载工业 AGV/AMR
在仓储物流中心，该底盘方案可驱动承载数百公斤货物的自动导引车（AGV）或自主移动机器人（AMR）。6.5 寸轮毂电机提供的大扭矩确保了在满载情况下依然能稳定运行，而 ESP32 负责处理导航算法、避障逻辑及与上位机的调度通信。
特种作业与巡检机器人
针对消防、排爆等危险环境，机器人需要具备强大的越障能力和可靠的远程操控性。该方案提供的强劲动力和低延迟无线通信，能确保机器人在复杂废墟中稳定行进，并精准执行操作手的指令。
大型户外巡检机器人
适用于光伏电站、油田、农业大棚等非结构化地形。6.5 寸充气轮胎能有效过滤草地、沙地、碎石路的颠簸，BLDC 电机的高效率延长了续航时间，而 ESP32 的无线通信保障了巡检数据的实时回传。
高校科研与机器人竞赛
在大学生机器人大赛（如 RoboMaster、RoboCon）或科研项目中，该方案因其高性能、高开放性和低成本，成为验证先进控制算法（如全向移动控制、多机协同、强化学习）的理想硬件平台。

3、注意事项
电源管理与功率去耦
独立供电（至关重要）：大功率电机启动瞬间会产生巨大的电流冲击（浪涌），极易导致 ESP32 因电源电压跌落而复位。严禁直接使用驱动电机的电池直接给 ESP32 供电。必须使用独立的 DC-DC 降压模块（如 LM2596 或 XL4015）或带过流保护的稳压电路为 ESP32 提供稳定的 5V/3.3V 电源。
储能电容：在 ESC 的电源输入端必须并联大容量、低 ESR（等效串联电阻）的电解电容或钽电容（建议 1000μF – 4700μF），以吸收电机换向时产生的反向电动势和电流尖峰，稳定母线电压。
电磁兼容（EMC）与信号抗干扰
布线规范：强电（电机动力线、电池线）与弱电（ESP32 信号线、编码器线、IMU 连线）必须严格分开走线。严禁平行走线，最好呈 90° 垂直交叉。
信号滤波：对于编码器、IMU 等敏感的高频信号线，建议使用屏蔽线。在 ESP32 的 GPIO 输入引脚上，可串联小电阻（如 100Ω）并并联对地电容（如 1nF）构成硬件低通滤波器，滤除高频噪声。
共地处理：逻辑地（ESP32）与电机地（ESC）必须在电源端进行单点共地，避免地线环路引入噪声。
电机控制逻辑与安全
双向控制与刹车：若使用双向 ESC，需注意换向逻辑。在改变电机旋转方向前，建议先发送“刹车”或“停止”信号，并保持短暂延时（>0.5s），避免瞬间电流反接烧毁 MOS 管。
行程限制与保护：在软件中设置速度和电流的软限位。当检测到电流异常（如持续超过峰值）时，应触发保护机制，降低 PWM 输出或切断动力，防止电机过热或机械结构损坏。
固件选择：对于轮毂电机，建议使用支持 DShot 协议 或 CAN 总线 的高级 ESC（如基于 BLHeli_32 或 KISS 固件），以获得比传统 PWM 更低的延迟和更高的控制精度。

1、差速驱动机器人（速度与转向控制）
应用场景
通过ESP32控制两个6.5寸轮毂电机，实现差速转向（如AGV、巡逻机器人）。

#include <ESP32Servo.h> // 支持高PWM频率
#include <Wire.h>

// 定义电机引脚（PWM频率需匹配电调要求，如400Hz）
#define MOTOR_LEFT_PWM 12
#define MOTOR_RIGHT_PWM 13
#define MOTOR_LEFT_DIR 14
#define MOTOR_RIGHT_DIR 27

Servo escLeft, escRight; // 使用Servo库生成PWM
float targetSpeedLeft = 0.0, targetSpeedRight = 0.0;

void setup() {
Serial.begin(115200);

// 初始化PWM（大功率电调通常需要50Hz-1kHz）
ESP32PWM::allocateTimer(0);
escLeft.setPeriodHertz(500); // 500Hz PWM
escRight.setPeriodHertz(500);
escLeft.attach(MOTOR_LEFT_PWM, 1000, 2000); // 1000-2000us脉宽
escRight.attach(MOTOR_RIGHT_PWM, 1000, 2000);

pinMode(MOTOR_LEFT_DIR, OUTPUT);
pinMode(MOTOR_RIGHT_DIR, OUTPUT);
}

void loop() {
// 1. 接收控制指令（如串口或ROS）
if (Serial.available()) {
String cmd = Serial.readStringUntil('\\n');
if (cmd.startsWith("V:")) {
// 格式: "V:left_speed,right_speed" （范围：-100 ~ 100）
int commaIdx = cmd.indexOf(',');
targetSpeedLeft = cmd.substring(2, commaIdx).toFloat();
targetSpeedRight = cmd.substring(commaIdx + 1).toFloat();
}
}

// 2. 方向控制（大功率电调可能需要方向信号）
digitalWrite(MOTOR_LEFT_DIR, targetSpeedLeft >= 0 ? HIGH : LOW);
digitalWrite(MOTOR_RIGHT_DIR, targetSpeedRight >= 0 ? HIGH : LOW);

// 3. 速度映射（将-100~100映射到1000~2000us）
int pwmLeft = map(abs(targetSpeedLeft), 0, 100, 1000, 2000);
int pwmRight = map(abs(targetSpeedRight), 0, 100, 1000, 2000);

escLeft.writeMicroseconds(pwmLeft);
escRight.writeMicroseconds(pwmRight);

delay(50); // 控制频率
}

要点解读
PWM频率：大功率电调通常需要 50Hz~1kHz，需根据电调手册调整（如Hobbywing需500Hz）。
方向控制：部分电调需额外引脚控制方向（如高低电平切换正反转）。
安全限制：通过map()限制PWM范围，避免启动时瞬时大电流。
通信接口：可替换为WiFi/蓝牙（如ESP32的WiFiServer）实现远程控制。
电源管理：6.5寸轮毂电机功耗高，需单独电池供电，ESP32与电调共地。

2、全向移动机器人（麦克纳姆轮控制）
应用场景
通过四个BLDC电机（麦克纳姆轮）实现全向移动（平移、旋转）。

#include <ESP32Servo.h>

// 定义四个电机PWM和方向引脚
#define MOTOR_FL_PWM 12
#define MOTOR_FR_PWM 13
#define MOTOR_BL_PWM 14
#define MOTOR_BR_PWM 27
#define MOTOR_FL_DIR 32
#define MOTOR_FR_DIR 33
#define MOTOR_BL_DIR 25
#define MOTOR_BR_DIR 26

Servo escFL, escFR, escBL, escBR;
float vx = 0.0, vy = 0.0, vr = 0.0; // 线速度x/y和角速度

void setup() {
Serial.begin(115200);

// 初始化PWM
ESP32PWM::allocateTimer(0);
escFL.setPeriodHertz(500); escFL.attach(MOTOR_FL_PWM, 1000, 2000);
escFR.setPeriodHertz(500); escFR.attach(MOTOR_FR_PWM, 1000, 2000);
escBL.setPeriodHertz(500); escBL.attach(MOTOR_BL_PWM, 1000, 2000);
escBR.setPeriodHertz(500); escBR.attach(MOTOR_BR_PWM, 1000, 2000);

pinMode(MOTOR_FL_DIR, OUTPUT); pinMode(MOTOR_FR_DIR, OUTPUT);
pinMode(MOTOR_BL_DIR, OUTPUT); pinMode(MOTOR_BR_DIR, OUTPUT);
}

void loop() {
// 1. 接收全向控制指令（如ROS twist消息）
if (Serial.available()) {
String cmd = Serial.readStringUntil('\\n');
if (cmd.startsWith("TWIST:")) {
// 格式: "TWIST:vx,vy,vr"
int idx1 = cmd.indexOf(',');
int idx2 = cmd.indexOf(',', idx1 + 1);
vx = cmd.substring(6, idx1).toFloat();
vy = cmd.substring(idx1 + 1, idx2).toFloat();
vr = cmd.substring(idx2 + 1).toFloat();
}
}

// 2. 麦克纳姆轮运动学解算
float fl = vx – vy – vr;
float fr = vx + vy + vr;
float bl = vx + vy – vr;
float br = vx – vy + vr;

// 3. 归一化并输出PWM
float maxVal = max(max(abs(fl), abs(fr)), max(abs(bl), abs(br)));
if (maxVal > 100) {
fl /= maxVal; fr /= maxVal;
bl /= maxVal; br /= maxVal;
}

digitalWrite(MOTOR_FL_DIR, fl >= 0 ? HIGH : LOW);
digitalWrite(MOTOR_FR_DIR, fr >= 0 ? HIGH : LOW);
digitalWrite(MOTOR_BL_DIR, bl >= 0 ? HIGH : LOW);
digitalWrite(MOTOR_BR_DIR, br >= 0 ? HIGH : LOW);

escFL.writeMicroseconds(map(abs(fl), 0, 100, 1000, 2000));
escFR.writeMicroseconds(map(abs(fr), 0, 100, 1000, 2000));
escBL.writeMicroseconds(map(abs(bl), 0, 100, 1000, 2000));
escBR.writeMicroseconds(map(abs(br), 0, 100, 1000, 2000));

delay(50);
}

要点解读
运动学解算：麦克纳姆轮需将(vx, vy, vr)分解为四个轮子的速度。
归一化处理：避免单个电机速度超过100%导致失控。
独立控制：每个电机需单独PWM和方向引脚。
扩展性：可接入ROS或WiFi实现高阶控制（如SLAM导航）。
机械安装：确保轮子角度正确（通常45°倾斜）。

3、自平衡机器人（双轮+IMU）
应用场景
通过ESP32和IMU（如MPU6050）控制双轮自平衡，动态调整电机角度。

#include <MPU6050_tockn.h>
#include <Wire.h>
#include <ESP32Servo.h>

MPU6050 mpu6050(Wire);
Servo escLeft, escRight;
float targetAngle = 0.0; // 目标平衡角度
float currentAngle = 0.0;
float lastError = 0.0;

void setup() {
Serial.begin(115200);
Wire.begin();
mpu6050.begin();
mpu6050.calcGyroOffsets(true);

// 初始化电机
ESP32PWM::allocateTimer(0);
escLeft.setPeriodHertz(500); escLeft.attach(12, 1000, 2000);
escRight.setPeriodHertz(500); escRight.attach(13, 1000, 2000);
}

void loop() {
// 1. 读取IMU角度（互补滤波）
mpu6050.update();
float accelAngle = atan2(mpu6050.getAccY(), mpu6050.getAccZ()) * 180 / PI;
float gyroAngle = currentAngle + mpu6050.getGyroX() * 0.01;
currentAngle = 0.98 * gyroAngle + 0.02 * accelAngle;

// 2. 动态目标角度（如响应外部推力）
if (abs(currentAngle) > 10) {
targetAngle = currentAngle * 0.7; // 轻微抵抗倾斜
} else {
targetAngle = 0.0;
}

// 3. PID控制
float error = targetAngle – currentAngle;
static float integral = 0.0;
integral += error * 0.01;
integral = constrain(integral, –100, 100); // 抗积分饱和
float derivative = (error – lastError) / 0.01;
float output = 2.0 error + 0.1 * integral + 0.5 * derivative;
lastError = error;

// 4. 驱动电机（对称控制）
int motorSpeed = constrain(output, –100, 100);
digitalWrite(MOTOR_LEFT_DIR, motorSpeed >= 0 ? HIGH : LOW);
digitalWrite(MOTOR_RIGHT_DIR, motorSpeed >= 0 ? HIGH : LOW);
escLeft.writeMicroseconds(map(abs(motorSpeed), 0, 100, 1000, 2000));
escRight.writeMicroseconds(map(abs(motorSpeed), 0, 100, 1000, 2000));

delay(10);
}

要点解读
传感器融合：使用互补滤波结合加速度计和陀螺仪数据。
抗积分饱和：限制积分项避免风车效应（机器人持续旋转）。
实时性：固定delay(10)确保控制频率稳定（100Hz）。
调试技巧：通过串口打印currentAngle和output调参。
机械设计：轮距和重心高度需匹配PID参数。

要点总结
电调兼容性：
大功率电调（如Hobbywing、Kelly）需确认PWM频率和信号范围（通常1000-2000μs）。
部分电调需初始化校准（如全油门启动后断电）。
电源与散热：
6.5寸轮毂电机电流可能达50A，需独立电池和电源开关。
ESP32和电调共地，避免干扰。
安全机制：
软件限流（如PWM限制在30%以下测试）。
急停按钮（通过GPIO切断电调信号）。
通信优化：
高频控制（如100Hz）建议用硬件PWM（ledcWrite）替代Servo库。
远程控制可用WiFi（AsyncTCP库）或CAN总线（多电机同步）。
调试工具：
使用Serial Plotter可视化角度/速度曲线。
逻辑分析仪抓取PWM信号验证时序。

4、CAN总线分布式驱动控制
场景：工业AGV底盘，6.5寸无刷轮毂电机，需要高可靠性和实时同步。
核心逻辑：ESP32作为主控制器，通过CAN总线控制多个大功率ESC。

#include <SimpleFOC.h>
#include <ACAN_ESP32.h> // ESP32 CAN库
#include <driver/mcpwm.h>
#include <driver/timer.h>

// 6.5寸轮毂电机参数
#define WHEEL_DIAMETER 0.165 // 6.5英寸 = 0.165米
#define WHEEL_RADIUS 0.0825
#define MAX_SPEED 3.0 // 最大速度3m/s
#define MAX_CURRENT 30.0 // 最大电流30A
#define MOTOR_POLE_PAIRS 5 // 5对极

// CAN总线设置
#define CAN_TX_PIN GPIO_NUM_5
#define CAN_RX_PIN GPIO_NUM_4
#define CAN_BAUDRATE 1000E3 // 1Mbps CAN FD
#define CAN_FRAME_SIZE 8

// ESC节点地址
#define ESC_FRONT_LEFT_ID 0x101
#define ESC_FRONT_RIGHT_ID 0x102
#define ESC_REAR_LEFT_ID 0x103
#define ESC_REAR_RIGHT_ID 0x104

// 大功率ESC协议
struct ESCCommand {
uint16_t throttle; // 油门值
uint8_t temperature; // 温度
uint8_t errorCode; // 错误代码
uint16_t current; // 电流
uint16_t voltage; // 电压
uint16_t rpm; // RPM
};

ESCCommand escCommands[4];
ESCCommand escTelemetry[4];

// BLDC电机对象
BLDCMotor motorFL, motorFR, motorRL, motorRR;

// 运动学参数
float wheelbase = 0.52; // 轴距0.52m
float trackWidth = 0.48; // 轮距0.48m
float maxAcceleration = 2.0; // 最大加速度2m/s²
float maxDeceleration = 3.0; // 最大减速度3m/s²

// CAN接收处理
QueueHandle_t canRxQueue;
TaskHandle_t canTaskHandle = NULL;

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("===== 6.5寸轮毂电机底盘控制系统 =====");
Serial.println("ESP32 + CAN总线 + 大功率ESC");

// 1. 初始化CAN总线
initCANBus();

// 2. 初始化PWM输出 (备用接口)
initPWMModules();

// 3. 初始化电机
initWheelMotors();

// 4. 创建CAN接收任务
xTaskCreatePinnedToCore(
canReceiveTask, // 任务函数
"CAN_RX_Task", // 任务名
4096, // 堆栈大小
NULL, // 参数
3, // 优先级
&canTaskHandle, // 任务句柄
1 // 核心1
);

// 5. ESC启动序列
escStartupSequence();

// 6. 安全系统初始化
initSafetySystem();

Serial.println("系统初始化完成");
Serial.print("轮直径: "); Serial.print(WHEEL_DIAMETER*1000); Serial.println("mm");
Serial.print("最大速度: "); Serial.print(MAX_SPEED*3.6); Serial.println("km/h");
Serial.print("最大电流: "); Serial.print(MAX_CURRENT); Serial.println("A");
}

void loop() {
static unsigned long lastControlTime = 0;
unsigned long now = micros();
float dt = (now – lastControlTime) / 1000000.0;

if (dt >= 0.01) { // 100Hz控制频率
// 1. 读取控制指令
ControlCommand cmd = readControlCommand();

// 2. 运动学计算
WheelSpeeds speeds = calculateWheelSpeeds(cmd);

// 3. 应用加速度限制
speeds = applyAccelerationLimit(speeds, dt);

// 4. 转换为ESC命令
ESCCommand escCmds[4];
for (int i = 0; i < 4; i++) {
escCmds[i] = convertToESCCommand(speeds.wheel[i], i);
}

// 5. 通过CAN发送
sendESCCommandsCAN(escCmds);

// 6. 读取ESC遥测
requestESCTelemetry();

// 7. 安全监控
monitorSafety();

// 8. 状态显示
static unsigned long lastDisplay = 0;
if (millis() – lastDisplay >= 100) {
displaySystemStatus();
lastDisplay = millis();
}

lastControlTime = now;
}

// 处理电机FOC控制
motorFL.loopFOC();
motorFR.loopFOC();
motorRL.loopFOC();
motorRR.loopFOC();

// 看门狗喂狗
feedWatchdog();
}

void initCANBus() {
Serial.println("初始化CAN总线…");

// CAN GPIO设置
ACAN_ESP32_Settings settings(CAN_BAUDRATE);
settings.mRxPin = CAN_RX_PIN;
settings.mTxPin = CAN_TX_PIN;
settings.mRxQueueSize = 20;
settings.mTxQueueSize = 20;

const uint32_t errorCode = ACAN_ESP32::can.begin(settings);
if (errorCode == 0) {
Serial.println("CAN总线初始化成功");
} else {
Serial.print("CAN初始化失败，错误代码: 0x");
Serial.println(errorCode, HEX);
}

// 创建CAN接收队列
canRxQueue = xQueueCreate(20, sizeof(CANMessage));
}

void initPWMModules() {
// 初始化ESP32的PWM模块，用于备用控制

Serial.println("初始化PWM模块…");

// 配置PWM定时器
mcpwm_config_t pwm_config = {
.frequency = 20000, // 20kHz PWM
.cmpr_a = 0, // 占空比0%
.cmpr_b = 0,
.duty_mode = MCPWM_DUTY_MODE_0,
.counter_mode = MCPWM_UP_COUNTER
};

// 初始化4个PWM单元
for (int i = 0; i < 4; i++) {
mcpwm_init(MCPWM_UNIT_0, (mcpwm_timer_t)i, &pwm_config);
}

// 配置PWM引脚
uint8_t pwmPins[4][2] = {
{GPIO_NUM_12, GPIO_NUM_13}, // FL: 高侧, 低侧
{GPIO_NUM_14, GPIO_NUM_15}, // FR
{GPIO_NUM_16, GPIO_NUM_17}, // RL
{GPIO_NUM_18, GPIO_NUM_19} // RR
};

for (int i = 0; i < 4; i++) {
mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0A, pwmPins[i][0]);
mcpwm_gpio_init(MCPWM_UNIT_0, MCPWM0B, pwmPins[i][1]);
}
}

WheelSpeeds calculateWheelSpeeds(ControlCommand cmd) {
// 计算四轮差速

WheelSpeeds speeds;

// 线速度分量
float vx = cmd.linearX;
float vy = cmd.linearY;
float omega = cmd.angularZ;

// 四轮运动学逆解
speeds.wheel[0] = (vx – vy – (wheelbase + trackWidth) * omega / 2.0) / WHEEL_RADIUS; // FL
speeds.wheel[1] = (vx + vy + (wheelbase + trackWidth) * omega / 2.0) / WHEEL_RADIUS; // FR
speeds.wheel[2] = (vx + vy – (wheelbase + trackWidth) * omega / 2.0) / WHEEL_RADIUS; // RL
speeds.wheel[3] = (vx – vy + (wheelbase + trackWidth) * omega / 2.0) / WHEEL_RADIUS; // RR

// 转换为RPM
for (int i = 0; i < 4; i++) {
speeds.wheel[i] = speeds.wheel[i] * 60.0 / (2 * PI);
}

return speeds;
}

ESCCommand convertToESCCommand(float speedRPM, int wheelIndex) {
// 转换为ESC命令

ESCCommand cmd;

// 限制速度
speedRPM = constrain(speedRPM, –MAX_SPEED/WHEEL_RADIUS*60.0/(2*PI),
MAX_SPEED/WHEEL_RADIUS*60.0/(2*PI));

// 油门映射
if (speedRPM >= 0) {
cmd.throttle = map(speedRPM, 0, 2000, 1000, 2000); // 正向
} else {
cmd.throttle = map(–speedRPM, 0, 2000, 1000, 0); // 反向
}

// 限制范围
cmd.throttle = constrain(cmd.throttle, 0, 2000);

return cmd;
}

void sendESCCommandsCAN(ESCCommand cmds[4]) {
// 通过CAN发送ESC命令

uint32_t ids[4] = {ESC_FRONT_LEFT_ID, ESC_FRONT_RIGHT_ID,
ESC_REAR_LEFT_ID, ESC_REAR_RIGHT_ID};

for (int i = 0; i < 4; i++) {
CANMessage message;
message.id = ids[i];
message.ext = false;
message.len = 8;

// 填充数据
message.data[0] = (cmds[i].throttle >> 8) & 0xFF; // 油门高字节
message.data[1] = cmds[i].throttle & 0xFF; // 油门低字节
message.data[2] = 0x00; // 保留
message.data[3] = 0x00; // 保留

// 发送
ACAN_ESP32::can.tryToSend(message);
}
}

void canReceiveTask(void *parameter) {
// CAN接收任务

CANMessage rxMessage;

while (1) {
if (xQueueReceive(canRxQueue, &rxMessage, portMAX_DELAY)) {
processCANMessage(rxMessage);
}
}
}

void processCANMessage(CANMessage &msg) {
// 处理CAN消息

int escIndex = –1;

// 识别ESC
switch(msg.id) {
case ESC_FRONT_LEFT_ID: escIndex = 0; break;
case ESC_FRONT_RIGHT_ID: escIndex = 1; break;
case ESC_REAR_LEFT_ID: escIndex = 2; break;
case ESC_REAR_RIGHT_ID: escIndex = 3; break;
}

if (escIndex >= 0) {
// 解析遥测数据
escTelemetry[escIndex].rpm = (msg.data[0] << 8) | msg.data[1];
escTelemetry[escIndex].current = (msg.data[2] << 8) | msg.data[3];
escTelemetry[escIndex].voltage = (msg.data[4] << 8) | msg.data[5];
escTelemetry[escIndex].temperature = msg.data[6];
escTelemetry[escIndex].errorCode = msg.data[7];
}
}

5、：FOC + 电流环精确控制
场景：需要精密扭矩控制的高性能底盘，如科研平台、手术机器人。
核心逻辑：ESP32实现FOC算法 + 电流环控制 + 扭矩矢量分配。

#include <SimpleFOC.h>
#include <driver/temp_sensor.h> // ESP32温度传感器
#include <driver/adc.h>
#include <soc/adc_channel.h>

// 6.5寸大功率轮毂电机FOC参数
#define POLE_PAIRS 5
#define PHASE_RESISTANCE 0.05 // 相电阻0.05Ω
#define MOTOR_KV 100 // KV值
#define MAX_TORQUE 5.0 // 最大扭矩5Nm
#define CURRENT_LIMIT 30.0 // 电流限制30A

// 电流采样
#define SHUNT_RESISTANCE 0.001 // 1mΩ采样电阻
#define OPAMP_GAIN 20 // 运放增益20倍
#define ADC_BITS 12 // ESP32 ADC 12位
#define ADC_VREF 3.3 // 参考电压3.3V

// BLDC电机FOC对象
BLDCMotor motorFL = BLDCMotor(POLE_PAIRS);
BLDCMotor motorFR = BLDCMotor(POLE_PAIRS);
BLDCMotor motorRL = BLDCMotor(POLE_PAIRS);
BLDCMotor motorRR = BLDCMotor(POLE_PAIRS);

// 电流传感器
InlineCurrentSense currentSenseFL = InlineCurrentSense(SHUNT_RESISTANCE, OPAMP_GAIN, A0, A1, A2);
InlineCurrentSense currentSenseFR = InlineCurrentSense(SHUNT_RESISTANCE, OPAMP_GAIN, A3, A4, A5);
InlineCurrentSense currentSenseRL = InlineCurrentSense(SHUNT_RESISTANCE, OPAMP_GAIN, A6, A7, A8);
InlineCurrentSense currentSenseRR = InlineCurrentSense(SHUNT_RESISTANCE, OPAMP_GAIN, A9, A10, A11);

// 扭矩矢量控制
struct TorqueVector {
float longitudinal; // 纵向扭矩
float lateral; // 横向扭矩
float yaw; // 偏航扭矩
};
TorqueVector targetTorque = {0, 0, 0};
TorqueVector actualTorque = {0, 0, 0};

// 温度监控
float motorTemperatures[4] = {25, 25, 25, 25};
float escTemperatures[4] = {25, 25, 25, 25};
float controllerTemp = 25.0;

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("===== 6.5寸轮毂电机FOC控制系统 =====");
Serial.println("ESP32 + FOC + 扭矩矢量控制");

// 1. 初始化温度传感器
temp_sensor_config_t temp_sensor = TSENS_CONFIG_DEFAULT();
temp_sensor.dac_offset = TSENS_DAC_L2; // L2偏移
temp_sensor_set_config(temp_sensor);
temp_sensor_start();

// 2. 初始化ADC
initHighSpeedADC();

// 3. 初始化电流传感器
initCurrentSensors();

// 4. 初始化FOC电机
initFOCMotors();

// 5. 电机参数识别
identifyMotorParameters();

// 6. 校准电流传感器
calibrateCurrentSensors();

// 7. 启动FOC控制
startFOCControl();

Serial.println("FOC系统初始化完成");
Serial.print("最大扭矩: "); Serial.print(MAX_TORQUE); Serial.println(" Nm");
Serial.print("电流限制: "); Serial.print(CURRENT_LIMIT); Serial.println(" A");
}

void loop() {
static unsigned long lastControlTime = 0;
unsigned long now = micros();
float dt = (now – lastControlTime) / 1000000.0;

if (dt >= 0.001) { // 1kHz电流环
// 1. 读取扭矩指令
TorqueVector torqueCmd = readTorqueCommand();

// 2. 扭矩限制
torqueCmd = limitTorque(torqueCmd);

// 3. 扭矩矢量分配
float wheelTorques[4];
distributeTorqueVector(torqueCmd, wheelTorques);

// 4. 转换为dq轴电流
float id_ref[4], iq_ref[4];
for (int i = 0; i < 4; i++) {
torqueToCurrent(wheelTorques[i], i, &id_ref[i], &iq_ref[i]);
}

// 5. 设置电流参考值
setCurrentReferences(id_ref, iq_ref);

// 6. 执行FOC控制
runFOCIteration();

// 7. 监控系统状态
monitorFOCSystem();

lastControlTime = now;
}

// 低速任务
static unsigned long lastSlowTask = 0;
if (millis() – lastSlowTask >= 10) { // 100Hz
// 温度监控
monitorTemperatures();

// 故障检测
checkFaults();

// 状态显示
static int displayCount = 0;
if (displayCount++ % 10 == 0) { // 1Hz显示
displayFOCStatus();
}

lastSlowTask = millis();
}
}

void initHighSpeedADC() {
Serial.println("配置高速ADC…");

// 配置ADC精度
analogReadResolution(ADC_BITS);

// 配置ADC衰减
for (int i = 0; i < 12; i++) {
analogSetPinAttenuation(getADCPin(i), ADC_11db);
}

// 设置ADC时钟分频
analogSetClockDiv(1);

// 配置ADC DMA
adc_digi_configuration_t adc_digi_config = {
.conv_limit_en = 0,
.conv_limit_num = 250,
.sample_freq_hz = 20000 * 6, // 20kHz * 6通道
};
adc_digi_controller_configure(&adc_digi_config);
}

void initFOCMotors() {
Serial.println("初始化FOC电机…");

BLDCMotor* motors[4] = {&motorFL, &motorFR, &motorRL, &motorRR};
InlineCurrentSense* sensors[4] = {&currentSenseFL, &currentSenseFR,
&currentSenseRL, &currentSenseRR};

for (int i = 0; i < 4; i++) {
// 链接电流传感器
motors[i]->linkCurrentSense(sensors[i]);

// 配置电机参数
motors[i]->phase_resistance = PHASE_RESISTANCE;
motors[i]->pole_pairs = POLE_PAIRS;
motors[i]->KV_rating = MOTOR_KV;

// 配置电流控制器
motors[i]->PID_current_q.P = 3.0;
motors[i]->PID_current_q.I = 300.0;
motors[i]->PID_current_q.D = 0.0;
motors[i]->PID_current_q.output_ramp = 10000.0;
motors[i]->PID_current_q.limit = CURRENT_LIMIT;

motors[i]->PID_current_d.P = 1.0;
motors[i]->PID_current_d.I = 100.0;
motors[i]->PID_current_d.D = 0.0;

// 配置速度控制器
motors[i]->PID_velocity.P = 0.2;
motors[i]->PID_velocity.I = 5.0;
motors[i]->PID_velocity.D = 0.0;
motors[i]->PID_velocity.output_ramp = 1000.0;

// 初始化FOC
motors[i]->init();
motors[i]->initFOC();

// 对齐电机
motors[i]->initFOC(0, Direction::CW);
}
}

void distributeTorqueVector(TorqueVector torque, float wheelTorques[4]) {
// 扭矩矢量分配算法

// 纵向扭矩分配
float longTorque = torque.longitudinal;

// 横向扭矩分配
float latTorque = torque.lateral;

// 偏航扭矩分配
float yawTorque = torque.yaw;

// 计算各轮扭矩
// 前轴承担更多纵向，后轴承担更多横向
float frontBias = 0.6; // 前轴纵向偏置
float rearBias = 0.4; // 后轴纵向偏置

// FL
wheelTorques[0] = frontBias * longTorque * 0.5
– latTorque * 0.5
– yawTorque * 0.25;

// FR
wheelTorques[1] = frontBias * longTorque * 0.5
+ latTorque * 0.5
+ yawTorque * 0.25;

// RL
wheelTorques[2] = rearBias * longTorque * 0.5
– latTorque * 0.5
+ yawTorque * 0.25;

// RR
wheelTorques[3] = rearBias * longTorque * 0.5
+ latTorque * 0.5
– yawTorque * 0.25;

// 扭矩限制
for (int i = 0; i < 4; i++) {
wheelTorques[i] = constrain(wheelTorques[i], –MAX_TORQUE, MAX_TORQUE);
}
}

void torqueToCurrent(float torque, int motorIndex, float* id_ref, float* iq_ref) {
// 扭矩转换为dq轴电流

BLDCMotor* motors[4] = {&motorFL, &motorFR, &motorRL, &motorRR};
BLDCMotor* motor = motors[motorIndex];

// 计算q轴电流参考 (产生扭矩)
float kt = 8.27 / motor->KV_rating; // 估算扭矩常数
*iq_ref = torque / kt;

// 限制q轴电流
*iq_ref = constrain(*iq_ref, –CURRENT_LIMIT, CURRENT_LIMIT);

// d轴电流参考 (弱磁控制)
float speed = motor->shaft_velocity;
float baseSpeed = 100.0; // 基速

if (abs(speed) > baseSpeed) {
// 弱磁区
*id_ref = –0.1 * (*iq_ref) * (abs(speed) – baseSpeed) / baseSpeed;
} else {
*id_ref = 0; // MTPA区域
}
}

void setCurrentReferences(float id_ref[4], float iq_ref[4]) {
// 设置电流参考值

BLDCMotor* motors[4] = {&motorFL, &motorFR, &motorRL, &motorRR};

for (int i = 0; i < 4; i++) {
// 设置dq轴电流
motors[i]->current.q = iq_ref[i];
motors[i]->current.d = id_ref[i];

// 电流前馈
motors[i]->voltage.q = iq_ref[i] * motors[i]->phase_resistance;
motors[i]->voltage.d = id_ref[i] * motors[i]->phase_resistance;
}
}

void runFOCIteration() {
// 执行FOC迭代

motorFL.loopFOC();
motorFR.loopFOC();
motorRL.loopFOC();
motorRR.loopFOC();
}

void monitorTemperatures() {
// 监控温度

// 读取ESP32内部温度
temp_sensor_read_celsius(&controllerTemp);

// 读取电机温度 (通过模拟NTC)
for (int i = 0; i < 4; i++) {
int ntcPin = getNTCPin(i);
float voltage = analogRead(ntcPin) * (ADC_VREF / (1 << ADC_BITS));
motorTemperatures[i] = ntcToTemperature(voltage);
}

// 温度保护
for (int i = 0; i < 4; i++) {
if (motorTemperatures[i] > 80.0 || controllerTemp > 70.0) {
reducePower(0.5); // 功率降额50%
}
if (motorTemperatures[i] > 100.0 || controllerTemp > 85.0) {
emergencyShutdown("过热保护");
}
}
}

6、：工业级冗余安全系统
场景：重型AGV、特种机器人，需要高可靠性和安全冗余。
核心逻辑：双核任务分离 + 硬件看门狗 + 多级故障处理。

#include <SimpleFOC.h>
#include <esp_task_wdt.h> // ESP32任务看门狗
#include <driver/pcnt.h> // 脉冲计数器
#include <driver/ledc.h> // LEDC PWM
#include <soc/rtc.h>

// 冗余控制系统
#define CORE_0_CONTROL_TASK 1
#define CORE_1_SAFETY_TASK 1
#define HARDWARE_WDT_TIMEOUT 3 // 硬件看门狗3秒

// 安全状态
enum SafetyState {
SAFE_NORMAL, // 正常
SAFE_DEGRADED, // 降级
SAFE_LIMITED, // 有限
SAFE_FAULT, // 故障
SAFE_EMERGENCY // 紧急
};
SafetyState systemState = SAFE_NORMAL;

// 冗余传感器
struct RedundantSensor {
float value[3]; // 三个独立传感器
float average; // 平均值
float variance; // 方差
bool valid[3]; // 有效性
int faultCount; // 故障计数
};
RedundantSensor speedSensors[4];
RedundantSensor currentSensors[4];
RedundantSensor tempSensors[4];

// 硬件看门狗
hw_timer_t* hwWatchdog = NULL;
bool wdtFed = false;

// 任务句柄
TaskHandle_t controlTaskHandle = NULL;
TaskHandle_t safetyTaskHandle = NULL;
TaskHandle_t commTaskHandle = NULL;

void setup() {
Serial.begin(115200);
delay(1000);

Serial.println("===== 工业级冗余安全控制系统 =====");
Serial.println("ESP32 双核 + 硬件看门狗 + 三冗余");

// 1. 配置硬件看门狗
initHardwareWatchdog();

// 2. 初始化任务看门狗
initTaskWatchdog();

// 3. 初始化冗余传感器
initRedundantSensors();

// 4. 创建安全任务 (核心1)
xTaskCreatePinnedToCore(
safetyMonitorTask, // 任务函数
"Safety_Task", // 任务名
4096, // 堆栈
NULL, // 参数
5, // 最高优先级
&safetyTaskHandle, // 句柄
1 // 核心1
);

// 5. 创建控制任务 (核心0)
xTaskCreatePinnedToCore(
controlTask, // 任务函数
"Control_Task", // 任务名
8192, // 堆栈
NULL, // 参数
4, // 高优先级
&controlTaskHandle, // 句柄
0 // 核心0
);

// 6. 创建通信任务
xTaskCreatePinnedToCore(
communicationTask, // 任务函数
"Comm_Task", // 任务名
4096, // 堆栈
NULL, // 参数
3, // 中优先级
&commTaskHandle, // 句柄
0 // 核心0
);

// 7. 启动任务看门狗
esp_task_wdt_add(controlTaskHandle);
esp_task_wdt_add(safetyTaskHandle);
esp_task_wdt_add(commTaskHandle);

Serial.println("冗余系统初始化完成");
Serial.println("安全状态: 正常");
}

void loop() {
// 主循环不执行实际工作，仅喂硬件看门狗
delay(100);
feedHardwareWatchdog();
}

void safetyMonitorTask(void* parameter) {
// 安全监控任务 (核心1)

Serial.println("安全监控任务启动");

// 配置任务看门狗
esp_task_wdt_init(5, true); // 5秒超时
esp_task_wdt_add(NULL);

unsigned long lastSafetyCheck = 0;

while (1) {
unsigned long now = millis();

if (now – lastSafetyCheck >= 10) { // 100Hz安全监控
// 1. 传感器一致性检查
checkSensorConsistency();

// 2. 系统健康检查
checkSystemHealth();

// 3. 故障处理
handleFaults();

// 4. 安全状态机
safetyStateMachine();

// 5. 喂任务看门狗
esp_task_wdt_reset();

lastSafetyCheck = now;
}

vTaskDelay(1); // 让出CPU
}
}

void controlTask(void* parameter) {
// 控制任务 (核心0)

Serial.println("控制任务启动");
esp_task_wdt_add(NULL);

// 初始化控制系统
initControlSystem();

unsigned long lastControlTime = 0;

while (1) {
unsigned long now = micros();
float dt = (now – lastControlTime) / 1000000.0;

if (dt >= 0.005 && systemState <= SAFE_LIMITED) { // 200Hz, 仅在安全状态运行
// 1. 读取传感器
readRedundantSensors();

// 2. 计算控制输出
calculateControlOutput(dt);

// 3. 应用输出限制
applyOutputLimits();

// 4. 发送到执行器
sendToActuators();

// 5. 喂任务看门狗
esp_task_wdt_reset();

lastControlTime = now;
}

vTaskDelay(1);
}
}

void initHardwareWatchdog() {
// 初始化硬件看门狗

Serial.println("配置硬件看门狗…");

hwWatchdog = timerBegin(0, 80, true); // 80MHz/80 = 1MHz
timerAttachInterrupt(hwWatchdog, &hardwareWatchdogISR, true);
timerAlarmWrite(hwWatchdog, HARDWARE_WDT_TIMEOUT * 1000000, true);
timerAlarmEnable(hwWatchdog);

Serial.println("硬件看门狗就绪");
}

void IRAM_ATTR hardwareWatchdogISR() {
// 硬件看门狗中断

if (!wdtFed) {
Serial.println("硬件看门狗超时！系统复位…");

// 执行安全关闭
emergencyShutdown();

// 延迟后复位
delay(100);
esp_restart();
}

wdtFed = false;
timerWrite(hwWatchdog, 0); // 重置定时器
}

void feedHardwareWatchdog() {
wdtFed = true;
}

void checkSensorConsistency() {
// 检查传感器一致性

for (int i = 0; i < 4; i++) {
// 检查速度传感器
checkSensorGroup(speedSensors[i], 0.5, "速度传感器");

// 检查电流传感器
checkSensorGroup(currentSensors[i], 1.0, "电流传感器");

// 检查温度传感器
checkSensorGroup(tempSensors[i], 2.0, "温度传感器");
}
}

void checkSensorGroup(RedundantSensor& sensor, float maxVariance, const char* name) {
// 检查一组传感器

// 计算平均值
float sum = 0;
int validCount = 0;

for (int j = 0; j < 3; j++) {
if (sensor.valid[j]) {
sum += sensor.value[j];
validCount++;
}
}

sensor.average = (validCount > 0) ? sum / validCount : 0;

// 计算方差
float varSum = 0;
for (int j = 0; j < 3; j++) {
if (sensor.valid[j]) {
float diff = sensor.value[j] – sensor.average;
varSum += diff * diff;
}
}
sensor.variance = (validCount > 1) ? varSum / (validCount – 1) : 0;

// 检查故障
if (sensor.variance > maxVariance) {
sensor.faultCount++;

if (sensor.faultCount > 10) { // 连续10次不一致
Serial.print(name);
Serial.println(" 不一致故障");

// 标记故障传感器
identifyFaultySensor(sensor);

// 进入降级模式
if (systemState == SAFE_NORMAL) {
systemState = SAFE_DEGRADED;
}
}
} else {
sensor.faultCount = 0;
}
}

void identifyFaultySensor(RedundantSensor& sensor) {
// 识别故障传感器

// 寻找与其他两个差异最大的传感器
float maxDiff = 0;
int faultyIndex = –1;

for (int i = 0; i < 3; i++) {
if (!sensor.valid[i]) continue;

float diffSum = 0;
for (int j = 0; j < 3; j++) {
if (i != j && sensor.valid[j]) {
diffSum += abs(sensor.value[i] – sensor.value[j]);
}
}

if (diffSum > maxDiff) {
maxDiff = diffSum;
faultyIndex = i;
}
}

if (faultyIndex >= 0) {
sensor.valid[faultyIndex] = false;
Serial.print("标记传感器 ");
Serial.print(faultyIndex);
Serial.println(" 为故障");
}
}

void safetyStateMachine() {
// 安全状态机

static SafetyState lastState = SAFE_NORMAL;

if (systemState != lastState) {
Serial.print("安全状态变更: ");
Serial.print(stateToString(lastState));
Serial.print(" -> ");
Serial.println(stateToString(systemState));

// 执行状态转换动作
switch(systemState) {
case SAFE_NORMAL:
enableFullPerformance();
break;
case SAFE_DEGRADED:
reducePerformance(0.7);
break;
case SAFE_LIMITED:
reducePerformance(0.3);
break;
case SAFE_FAULT:
stopMotion();
break;
case SAFE_EMERGENCY:
emergencyStop();
break;
}

lastState = systemState;
}
}

void checkSystemHealth() {
// 系统健康检查

bool faultDetected = false;

// 检查电压
float busVoltage = readBusVoltage();
if (busVoltage < 20.0 || busVoltage > 30.0) {
Serial.print("母线电压异常: ");
Serial.println(busVoltage);
faultDetected = true;
}

// 检查温度
float maxTemp = 0;
for (int i = 0; i < 4; i++) {
if (tempSensors[i].average > maxTemp) {
maxTemp = tempSensors[i].average;
}
}

if (maxTemp > 80.0) {
Serial.print("温度过高: ");
Serial.println(maxTemp);
faultDetected = true;
}

// 检查通信
static unsigned long lastCommTime = 0;
if (millis() – lastCommTime > 1000) { // 1秒无通信
Serial.println("通信超时");
faultDetected = true;
}

// 更新状态
if (faultDetected) {
if (systemState == SAFE_NORMAL) {
systemState = SAFE_DEGRADED;
} else if (systemState == SAFE_DEGRADED) {
systemState = SAFE_LIMITED;
}
}
}

要点解读
6.5寸轮毂电机的特性与控制挑战
大惯量：直径165mm，转动惯量大，启停需要更大扭矩。案例4的maxAcceleration=2.0m/s²是合理上限，急加速需电流>20A。
高功率：按3m/s速度、2kg质量计算，持续功率约60W，峰值可达200W。ESC需支持30A持续，60A峰值。
低速抖动：轮毂电机在低速时易出现转矩脉动。案例5的FOC算法配合PID_current_q精确控制dq轴电流，是解决此问题的唯一方法。
散热挑战：轮毂封闭，散热差。案例6的温度监控>80°C降额，>100°C停机是必须的。
ESP32在电机控制中的核心优势利用
双核架构：案例6将控制任务（Core 0）与安全监控（Core 1）分离，避免相互阻塞。这是工业级可靠性的基础。
丰富外设：
CAN总线：案例4用1Mbps CAN FD，比UART更可靠，适合分布式控制。
硬件PWM：mcpwm模块支持20kHz PWM，死区时间可硬件配置。
脉冲计数：pcnt模块可硬件计数编码器脉冲，不占用CPU。
高主频：240MHz，可实现1kHz电流环（案例5）。传统Arduino的16MHz难以实现。
大功率ESC的选型与控制协议
协议选择：
PWM：最简单，但分辨率低，抗干扰差。6.5寸电机建议用高分辨率PWM（如32kHz）。
DShot：数字协议，推荐用于高性能应用。但大功率工业ESC可能不支持。
CAN：工业标准，案例4采用。支持同步命令和丰富遥测。
电流能力：必须匹配电机。6.5寸轮毂通常需要30-50A持续。ESC的MOSFET需有余量（至少1.5倍）。
制动能力：大惯量需要强制动。ESC需支持主动短路制动或能量回馈。
冗余安全系统的层级设计
传感器冗余：案例6的RedundantSensor实现三取二表决。方差>maxVariance时触发故障检测。
看门狗多层：
任务看门狗：esp_task_wdt监控每个任务（5秒）。
硬件看门狗：独立定时器（3秒），最可靠。
安全状态机：5级状态（正常→降级→有限→故障→紧急），每级对应不同的性能限制。
故障处理策略：
传感器故障：标记故障传感器，使用剩余传感器。
通信故障：超时1秒进入降级模式。
过热故障：分级降额，避免突然停机。
工程实施的硬件关键点
电源设计：
电机电源与逻辑电源隔离。6.5寸电机启动瞬间电流可能超过50A。
大容量电容靠近ESC，抑制电压跌落。建议每10A电流配1000μF电容。
TVS管保护电源输入，防止电压尖峰。
散热设计：
ESC：需安装散热片，必要时加风扇。温度传感器必须贴MOSFET。
电机：轮毂电机外壳温度应<70°C。可添加热敏电阻监控。
布线规范：
功率线与信号线分开走线，避免干扰。
CAN总线终端加120Ω电阻，双绞线布线。
编码器线屏蔽，长度<1m。
机械安装：
6.5寸轮毂需法兰安装，不能仅靠轴固定。
轴对齐至关重要，偏差会导致轴承快速损坏。

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