Arduino BLDC六步换相PWM开环控制机器人，是以Arduino/ESP32等微控制器为核心、通过霍尔传感器获取转子位置、以六步换相状态机驱动三相全桥MOSFET、叠加PWM占空比调节实现速度控制的BLDC电机驱动方案，是BLDC电机驱动中最基础、最经典的方法，以极低的硬件成本和算法复杂度实现可靠的电机驱动，适用于对转矩平滑性和控制精度要求不高的机器人底盘、关节和执行器。 该方案具备算法极简计算开销极低、PWM线性调速响应快、霍尔传感低速启动可靠、转矩脉动与效率局限四大特点，主要应用于低成本移动机器人底盘、教育原型平台、服务执行器及工业传送与泵阀驱动等场景；实际部署时需重点关注换相顺序与霍尔接线、死区时间设置、PWM频率选择、电流限制与散热、开环特性补偿及EMC与电源隔离。
一、 技术原理与主要特点
基本原理
六步换相（Six-Step Commutation），也叫120°方波控制，是驱动BLDC电机最经典的方法。其核心思想是：将一个完整的360°电周期划分为6个60°的扇区，每个扇区对应一组固定的三相逆变器开关状态——每次仅给其中两相绕组通电，产生一个方向固定的定子磁场；控制器根据转子位置依次切换导通的两相，牵引转子持续旋转。
在Arduino平台上，程序核心是一个由霍尔传感器信号触发的6状态状态机。Arduino通过读取3路霍尔信号（HallA/HallB/HallC）判断当前转子所在扇区，查表输出对应的6路MOSFET驱动信号（3个上桥臂+3个下桥臂），同时对导通相施加PWM信号调节有效电压，从而控制平均电流与电磁转矩，实现转速调节。
主要特点
算法极简，计算开销极低：六步换相的控制逻辑本质上是一张"霍尔状态→开关组合"的查表映射，Arduino仅需条件判断或查表即可输出对应的高低电平组合，无需Clark/Park坐标变换、PID电流环等复杂运算。这使得即使是资源极其有限的8位微控制器（如ATmega328P，16MHz/2KB SRAM）也能轻松胜任，非常适合Arduino平台。
PWM线性调速，响应快：在每一步换相中，对导通相的MOSFET施加PWM信号（通常采用"高侧PWM+低侧常开"或"低侧PWM+高侧常开"方式），可线性调节施加到绕组的有效电压，从而控制平均电流与电磁转矩。这种调速方式在中高速段具有良好的线性度，且响应速度快，适合需要快速加减速的机器人场景。
霍尔传感，低速启动可靠：与无传感器方案（反电动势过零检测）不同，六步换相依赖内置或外置的霍尔效应传感器获取转子磁极位置（精度为每电周期60°电角度）。这使得系统在启动和低速运行时稳定可靠，避免了反电动势过零检测在静止或低速下信号微弱、存在检测盲区的问题。
转矩脉动较大，效率略低于FOC：这是六步换相最显著的局限性。由于电流波形为方波，且每次换相时存在电流中断与重建过程，导致电磁转矩存在明显脉动（典型值约13%），尤其在低速时会引起振动与噪声。同时，方波驱动无法实现最大转矩/电流比控制，整体效率低于正弦波驱动的FOC方案。
二、 典型应用场景
低成本移动机器人底盘：在教育科研、竞赛（如RoboCup Junior、智能车竞赛）等场景中，机器人底盘对成本控制严格，对转矩平滑性要求不高。六步换相方案以极低的硬件成本（Arduino + 三相全桥驱动板 + 霍尔BLDC电机）即可实现可靠的双轮差速或四轮驱动，满足基本的移动和转向需求。
机器人关节与执行器：用于机器人手臂的简单关节驱动、夹爪开合、云台俯仰等对体积和重量有要求、但不需要极低转速平稳性或极高精度的场合。六步换相方案的小型化驱动板可嵌入关节模组内部，提供足够的动力输出。
教育与原型开发平台：作为BLDC电机控制原理教学的理想平台。学生可在Arduino上直观理解三相全桥驱动、换相逻辑、PWM调速、霍尔传感器工作原理等核心概念，为后续学习FOC等高级控制算法奠定基础。
工业传送与泵阀驱动：在不需要FOC高性能的工业场合，如小型传送带驱动、水泵/油泵控制、风扇调速等，六步换相方案因其坚固耐用、控制简单、成本低廉而备受欢迎。
三、 关键注意事项
换相顺序与霍尔接线：
换相顺序必须与电机绕组的物理接线严格匹配。不同电机的霍尔传感器安装角度和绕组相序可能不同，错误的换相顺序会导致电机反转、抖动甚至无法启动。开发的第一步应使用示波器或逻辑分析仪采集电机的霍尔信号，确定正确的换向表。
霍尔传感器的3路信号线需使用上拉电阻（通常10kΩ），并确保信号线远离动力线布线，防止电磁干扰导致误触发换相。
死区时间设置：
在切换上下桥臂时，必须插入死区时间（Dead Time，通常1~5μs），防止同一相的上下桥臂同时导通造成"直通短路"（shoot-through），烧毁MOSFET。死区时间过短会导致短路风险，过长则会导致输出波形畸变、转矩损失。
若使用专用半桥驱动芯片（如IR2104），芯片内部通常已集成死区时间生成电路；若使用分立MOSFET搭建全桥，则需在Arduino代码中手动实现死区延时。
PWM频率选择：
PWM频率过低（<5kHz）会导致电机产生可闻噪声和明显抖动；频率过高（>30kHz）则会增加MOSFET的开关损耗，导致驱动板发热严重、效率下降。通常建议选择15~20kHz的PWM频率，既能避开人耳敏感频段，又能保持合理的开关损耗。
Arduino的analogWrite()默认PWM频率约490Hz（Timer1/2）或980Hz（Timer0），远低于推荐值。需通过直接操作定时器寄存器（如TCCR1B）将PWM频率提升至目标范围。
电流限制与散热管理：
开环控制下，电机堵转或重载时电流会急剧上升，可能烧毁MOSFET或电机绕组。必须在软件中设置电流限制——可通过串联采样电阻+ADC读取电流值，当检测到过流时自动降低PWM占空比或停机保护。
MOSFET在高负载下会产生较多热量，需确保驱动板有良好的散热措施（散热片、铜箔面积增大），避免过热导致MOSFET热击穿。
开环特性与速度波动：
开环控制的核心局限在于：给定一个固定的PWM占空比后，实际转速会随负载变化而波动。当机器人爬坡或遇到阻力时，转速会明显下降；卸载后转速又会回升。若应用对速度稳定性有要求，需在开环基础上增加编码器反馈，升级为闭环速度控制（PID调速）。
在机器人应用中，建议至少加入编码器实现速度闭环，否则在负载变化较大的场景下（如爬坡、推物），机器人的运动轨迹将难以预测。
EMC与电源隔离：
BLDC电机启停时电流冲击极大（堵转可达额定3_{5倍），严禁与Arduino共用电源。必须采用隔离DC-DC模块为控制电路独立供电，并在电机驱动端并联大容量低ESR电容（1000}4700μF）吸收反电动势。
霍尔传感器信号线需使用屏蔽线，远离动力线布线（间距≥5cm），防止高频PWM噪声干扰霍尔信号导致换相错乱。

1、基础六步换相 + PWM速度调节（霍尔传感器驱动）
场景：小型风扇、水泵或玩具级机器人底盘等对成本敏感、控制精度要求不高的场合，需要实现电机启停和速度调节。

核心逻辑：通过三个霍尔传感器检测转子位置（每电周期60°精度），将电周期划分为六个扇区，每个扇区对应一组固定的三相逆变器开关状态。Arduino通过查表输出对应的高低电平组合。对高侧MOSFET施加PWM信号来调节有效电压，从而控制转速。

// ===== 引脚定义 =====
// 霍尔传感器输入（中断引脚）
#define HALL_A 2
#define HALL_B 3
#define HALL_C 21

// 三相桥MOSFET控制引脚
#define PWM_AH 9   // A相高侧
#define PWM_AL 8   // A相低侧
#define PWM_BH 10  // B相高侧
#define PWM_BL 11  // B相低侧
#define PWM_CH 5   // C相高侧
#define PWM_CL 6   // C相低侧

// ===== 六步换相真值表（根据霍尔信号组合）=====
// 霍尔组合: HA HB HC → A相 B相 C相
// 1: 1 0 0 → A+ (PWM), B-, C_off
// 2: 1 1 0 → A+, C-, B_off
// 3: 0 1 0 → B+, C-, A_off
// 4: 0 1 1 → B+, A-, C_off
// 5: 0 0 1 → C+, A-, B_off
// 6: 1 0 1 → C+, B-, A_off

const uint8_t stepTable[6][3] = {
    {PWM_AH, PWM_BL, 0},    // 步骤1: A高PWM, B低常开
    {PWM_AH, PWM_CL, 0},    // 步骤2: A高PWM, C低常开
    {PWM_BH, PWM_CL, 0},    // 步骤3: B高PWM, C低常开
    {PWM_BH, PWM_AL, 0},    // 步骤4: B高PWM, A低常开
    {PWM_CH, PWM_AL, 0},    // 步骤5: C高PWM, A低常开
    {PWM_CH, PWM_BL, 0}     // 步骤6: C高PWM, B低常开
};

volatile int hallState = 0;
volatile int currentStep = 0;
int targetSpeed = 128;  // PWM占空比 0-255

void setup() {
    // 霍尔引脚设为输入
    pinMode(HALL_A, INPUT_PULLUP);
    pinMode(HALL_B, INPUT_PULLUP);
    pinMode(HALL_C, INPUT_PULLUP);
    
    // PWM引脚设为输出
    pinMode(PWM_AH, OUTPUT);
    pinMode(PWM_AL, OUTPUT);
    // ... 其他引脚同理
    
    // 中断捕获霍尔信号变化
    attachInterrupt(digitalPinToInterrupt(HALL_A), hallISR, CHANGE);
    attachInterrupt(digitalPinToInterrupt(HALL_B), hallISR, CHANGE);
    attachInterrupt(digitalPinToInterrupt(HALL_C), hallISR, CHANGE);
}

void loop() {
    // 读取霍尔状态并更新换相
    hallState = (digitalRead(HALL_A) << 2) | 
                (digitalRead(HALL_B) << 1) | 
                digitalRead(HALL_C);
    
    // 霍尔状态 → 换相步骤映射
    switch(hallState) {
        case 0b100: currentStep = 0; break;
        case 0b110: currentStep = 1; break;
        case 0b010: currentStep = 2; break;
        case 0b011: currentStep = 3; break;
        case 0b001: currentStep = 4; break;
        case 0b101: currentStep = 5; break;
        default: currentStep = -1; break;  // 无效状态
    }
    
    // 执行换相
    if (currentStep >= 0) {
        applyCommutation(currentStep, targetSpeed);
    }
}

// 应用换相（高侧PWM + 低侧常开）
void applyCommutation(int step, int pwmVal) {
    // 先关闭所有MOSFET
    digitalWrite(PWM_AL, LOW);
    digitalWrite(PWM_BL, LOW);
    digitalWrite(PWM_CL, LOW);
    analogWrite(PWM_AH, 0);
    analogWrite(PWM_BH, 0);
    analogWrite(PWM_CH, 0);
    
    // 根据换相表驱动对应相
    // stepTable[step][0]: 高侧PWM引脚
    // stepTable[step][1]: 低侧常开引脚
    // stepTable[step][2]: 未使用
    analogWrite(stepTable[step][0], pwmVal);
    digitalWrite(stepTable[step][1], HIGH);
}

2、带加速度斜坡的平滑调速（电动自行车控制器）
场景：电动自行车、电动滑板车等需要平稳启动和加速的应用，霍尔传感器+六步换相+PWM调速是最经典的方案。

核心逻辑：在基础六步换相基础上，加入加速度斜坡（S曲线加速）算法，避免PWM占空比突变导致的机械冲击和电流尖峰。同时增加硬件保护——死区时间防止上下管直通，电流检测实现过流保护。

// ===== 硬件定义 =====
#define THROTTLE_PIN A0  // 油门输入（电位器/霍尔手柄）
#define CURRENT_PIN A1   // 电流检测（分流器+运放）

// ===== 六步换相真值表（同案例一）=====
const uint8_t stepTable[6][3] = { ... };

// ===== 调速参数 =====
unsigned long lastRampTime = 0;
const int RAMP_INTERVAL = 20;    // 20ms步进一次
const float ACCEL_RATE = 1.5;    // 每步最大增加量
int currentPWM = 0;              // 当前PWM输出值
int targetPWM = 0;               // 目标PWM值

void loop() {
    // 1. 读取油门信号（映射到0-255）
    int rawThrottle = analogRead(THROTTLE_PIN);
    targetPWM = map(rawThrottle, 0, 1023, 0, 255);
    
    // 2. 【核心】加速度斜坡：逐步逼近目标值
    unsigned long now = millis();
    if (now - lastRampTime >= RAMP_INTERVAL) {
        if (currentPWM < targetPWM) {
            currentPWM = min(currentPWM + ACCEL_RATE, targetPWM);
        } else if (currentPWM > targetPWM) {
            currentPWM = max(currentPWM - ACCEL_RATE * 0.8, targetPWM);
        }
        lastRampTime = now;
    }
    
    // 3. 电流检测过流保护
    int current = analogRead(CURRENT_PIN);
    if (current > OVERCURRENT_THRESHOLD) {
        currentPWM = min(currentPWM, MAX_SAFE_PWM);  // 限流
    }
    
    // 4. 霍尔信号读取 + 换相执行（同案例一）
    updateHallState();
    if (currentStep >= 0) {
        applyCommutation(currentStep, currentPWM);
    }
    
    delay(5);  // 200Hz控制循环
}

硬件的死区时间设置：在使用IR2104等栅极驱动器时，芯片内部已内置死区时间（通常约520ns），防止上下管直通短路。若使用分立元件搭建，需在软件中确保高侧关断后延时再开启低侧。

3、SimpleFOC库的开环速度控制示例
场景：快速原型开发或对控制精度要求不高的DIY项目，使用SimpleFOC库的velocity_openloop模式快速驱动BLDC电机。

核心逻辑：SimpleFOC库底层实现了六步换相逻辑，用户仅需配置电机参数（极对数）和驱动器类型（6PWM），调用motor.move(target_velocity)即可实现开环速度控制。这种模式不依赖传感器反馈，适合快速测试和教学演示。

#include <SimpleFOC.h>

// ===== BLDC电机实例 =====
// 参数：极对数（Pole Pairs）
BLDCMotor motor = BLDCMotor(7);  // 7对极

// ===== 6PWM驱动实例 =====
// 引脚顺序：AH, AL, BH, BL, CH, CL
BLDCDriver6PWM driver = BLDCDriver6PWM(9, 8, 10, 11, 5, 6);

// ===== 目标速度（弧度/秒）=====
float target_velocity = 70;  // 约668 RPM

void setup() {
    // 1. 配置驱动器
    driver.voltage_power_supply = 12;   // 电源电压
    driver.voltage_limit = 12;          // 电压限幅
    driver.pwm_frequency = 32000;       // PWM频率32kHz
    driver.init();
    
    // 2. 链接电机与驱动器
    motor.linkDriver(&driver);
    
    // 3. 配置电机
    motor.voltage_limit = 12;   // 电压限幅
    motor.controller = MotionControlType::velocity_openloop;  // 开环速度控制
    
    // 4. 初始化电机
    motor.init();
    
    Serial.begin(115200);
    Serial.println("Motor ready!");
}

void loop() {
    // 开环速度控制
    motor.move(target_velocity);
    
    // 可通过串口动态调整目标速度
    if (Serial.available()) {
        target_velocity = Serial.parseFloat();
    }
    
    delay(20);  // 50Hz控制循环
}

说明：此代码使用了SimpleFOC库的velocity_openloop控制模式，适用于快速原型验证。若需更精确的闭环控制，可切换至velocity模式并接入编码器或霍尔传感器反馈。

要点解读
六步换相是BLDC控制的基础入门方案：控制逻辑简洁，计算开销极低。Arduino仅需查表即可输出对应的高低电平组合，无需复杂坐标变换或实时解算，非常适合ATmega328P等8位微控制器。六步换相将电周期划分为六个60°扇区，每个扇区对应一组固定的三相逆变器开关状态。

PWM调速的核心是调节占空比以改变有效电压：在每一步换相中，对高侧或低侧MOSFET施加PWM信号（通常采用“高侧PWM+低侧常开”方式），可调节施加到绕组的有效电压，从而控制平均电流与电磁转矩，最终实现转速调节。这种调速方式响应较快，在中高速段具有良好的线性度。

霍尔传感器的安装相位直接影响换相时序：霍尔元件的机械安装角度必须准确。若相位偏移，会导致换相提前或滞后，引起转矩下降、发热甚至失步。调试时应通过示波器对比霍尔跳变沿与反电动势过零点，必要时在软件中加入相位补偿偏移量。

死区时间与电流检测是硬件保护的关键：同一桥臂的上下管若同时导通会导致短路。IR2104等栅极驱动器内置了死区时间保护。电流检测通过分流电阻+运放实现过流保护，防止电机堵转或异常工况下烧毁MOSFET。

六步换相的局限：转矩脉动较大，效率低于FOC：由于电流波形为方波，且每次换相时存在电流中断与重建过程，导致电磁转矩存在明显脉动（尤其在低速时），可能引发振动与噪声。方波驱动无法实现最大转矩/电流比控制，整体效率低于正弦波驱动的FOC。

4、六步换相PWM开环循迹机器人——物流分拣/园区导引
适用场景：物流分拣线、园区导引线等场景，机器人沿预设黑色导引线行驶，无需位置闭环，通过六步换相PWM开环控制BLDC电机，实现高响应、低成本的循迹行驶，适配负载较轻的分拣小车。

核心逻辑：
六步换相PWM控制：按BLDC电机霍尔信号触发固定换相序列，无需编码器反馈，直接输出PWM占空比控制转速；
开环循迹决策：通过红外对管检测导引线，基于偏差信号直接输出左右轮PWM差，实现快速转向纠偏；
速度分级控制：根据循迹稳定性需求，通过PWM占空比分级调整转速，兼顾循迹精度与行驶效率。
参考代码（简化版，聚焦六步换相与循迹核心）：

/* ===== 六步换相PWM开环循迹机器人（物流分拣/园区导引） =====
 * 核心：霍尔信号触发六步换相+开环PWM控制，红外循迹
 * 适配：24V BLDC电机（含3路霍尔）、红外对管模块、2路BLDC驱动（如BTS7960）
 * 原理：霍尔信号触发换相，占空比直接调转速，无需位置/速度闭环
 */

// 硬件引脚定义
#define HALL_A 2  // 霍尔信号A
#define HALL_B 3  // 霍尔信号B
#define HALL_C 4  // 霍尔信号C
#define MOTOR_L_PWM 5  // 左电机PWM（开环）
#define MOTOR_L_IN1 6  // 左电机方向控制1
#define MOTOR_L_IN2 7  // 左电机方向控制2
#define MOTOR_R_PWM 9  // 右电机PWM（开环）
#define MOTOR_R_IN1 10 // 右电机方向控制1
#define MOTOR_R_IN2 11 // 右电机方向控制2
#define IR_LEFT A0     // 左红外循迹传感器
#define IR_RIGHT A1    // 右红外循迹传感器

// 六步换相序列（根据霍尔信号组合输出对应驱动信号）
// 序列索引：0-5对应霍尔信号组合 001→011→010→110→100→101（常见顺序，需匹配电机接线）
const int phase_sequence[6][3] = {
  {LOW, HIGH, LOW},   // 步0：A-→B+
  {LOW, HIGH, HIGH},  // 步1：A-→B+C+
  {LOW, LOW, HIGH},   // 步2：C+→B+
  {HIGH, LOW, HIGH},  // 步3：A+→B+
  {HIGH, LOW, LOW},   // 步4：A+→C-
  {HIGH, HIGH, LOW}   // 步5：A+B+→C-
};

// 变量定义
int hall_state = 0;    // 当前霍尔状态（0-5对应六步换相索引）
int current_step = 0;  // 当前换相步序
unsigned long last_hall_time = 0;
int left_pwm = 80;     // 左轮开环PWM（0-100）
int right_pwm = 80;    // 右轮开环PWM
int ir_left_val = 0;   // 左红外检测值
int ir_right_val = 0;  // 右红外检测值
const int BLACK_TH = 300; // 红外检测黑线阈值（低于为黑线）

void setup() {
  Serial.begin(115200);
  pinMode(HALL_A, INPUT_PULLUP);
  pinMode(HALL_B, INPUT_PULLUP);
  pinMode(HALL_C, INPUT_PULLUP);
  // 电机控制引脚初始化
  pinMode(MOTOR_L_PWM, OUTPUT);
  pinMode(MOTOR_L_IN1, OUTPUT);
  pinMode(MOTOR_L_IN2, OUTPUT);
  pinMode(MOTOR_R_PWM, OUTPUT);
  pinMode(MOTOR_R_IN1, OUTPUT);
  pinMode(MOTOR_R_IN2, OUTPUT);
  // 初始化电机停止
  analogWrite(MOTOR_L_PWM, 0);
  analogWrite(MOTOR_R_PWM, 0);
  digitalWrite(MOTOR_L_IN1, LOW);
  digitalWrite(MOTOR_L_IN2, LOW);
  digitalWrite(MOTOR_R_IN1, LOW);
  digitalWrite(MOTOR_R_IN2, LOW);
  // 启动霍尔信号中断（每次霍尔跳变触发换相）
  attachInterrupt(digitalPinToInterrupt(HALL_A), update_step, CHANGE);
  attachInterrupt(digitalPinToInterrupt(HALL_B), update_step, CHANGE);
  attachInterrupt(digitalPinToInterrupt(HALL_C), update_step, CHANGE);
}

// 霍尔信号变化时更新换相步序（核心函数）
void update_step() {
  // 读取霍尔信号组合，转换为0-5的步序
  int hall_a = digitalRead(HALL_A);
  int hall_b = digitalRead(HALL_B);
  int hall_c = digitalRead(HALL_C);
  hall_state = (hall_a << 2) | (hall_b << 1) | hall_c; // 编码为3位二进制
  // 映射到六步换相索引（根据电机实际接线调整映射关系）
  switch(hall_state) {
    case 1: current_step = 0; break; // 001→步0
    case 3: current_step = 1; break; // 011→步1
    case 2: current_step = 2; break; // 010→步2
    case 6: current_step = 3; break; // 110→步3
    case 4: current_step = 4; break; // 100→步4
    case 5: current_step = 5; break; // 101→步5
    default: current_step = current_step; // 异常状态保持当前步
  }
  // 输出当前步的驱动信号
  digitalWrite(MOTOR_L_IN1, phase_sequence[current_step][0]);
  digitalWrite(MOTOR_L_IN2, phase_sequence[current_step][1]);
  digitalWrite(MOTOR_R_IN1, phase_sequence[current_step][2]); // 简化：假设左右电机驱动信号同步
  // 注：实际需根据左右电机独立输出驱动信号，此处简化逻辑
}

// 循迹决策（开环：根据红外偏差直接调整PWM）
void track_decision() {
  ir_left_val = analogRead(IR_LEFT);
  ir_right_val = analogRead(IR_RIGHT);
  
  // 基础：两轮PWM相同
  left_pwm = 80;
  right_pwm = 80;
  
  // 左轮检测到黑线（偏离右偏）→左轮减速，右轮加速
  if (ir_left_val < BLACK_TH && ir_right_val >= BLACK_TH) {
    left_pwm = 60;  // 左轮减速
    right_pwm = 90; // 右轮加速
  }
  // 右轮检测到黑线（偏离左偏）→右轮减速，左轮加速
  else if (ir_right_val < BLACK_TH && ir_left_val >= BLACK_TH) {
    left_pwm = 90;
    right_pwm = 60;
  }
  // 双轮都检测到黑线（弯道）→两轮差速转向
  else if (ir_left_val < BLACK_TH && ir_right_val < BLACK_TH) {
    left_pwm = 70;
    right_pwm = 90;
  }
  // 未检测到黑线（直行或无轨）→全速
  else {
    left_pwm = 80;
    right_pwm = 80;
  }
}

// 开环PWM输出控制
void open_loop_motor_control() {
  analogWrite(MOTOR_L_PWM, map(left_pwm, 0, 100, 0, 255)); // Arduino PWM 0-255
  analogWrite(MOTOR_R_PWM, map(right_pwm, 0, 100, 0, 255));
}

void loop() {
  track_decision(); // 循迹决策
  open_loop_motor_control(); // 开环PWM输出
  // 串口输出调试
  Serial.print("Step:"); Serial.print(current_step);
  Serial.print(" | LeftPWM:"); Serial.print(left_pwm);
  Serial.print(" | RightPWM:"); Serial.print(right_pwm);
  Serial.print(" | IR_L:"); Serial.print(ir_left_val);
  Serial.print(" | IR_R:"); Serial.println(ir_right_val);
  delay(10);
}

5、六步换相PWM开环搬运机器人——工厂物料搬运/仓库转运
适用场景：工厂车间、仓库等场景的物料搬运，机器人需平稳承载中载物料，通过六步换相PWM开环控制实现恒定转速行驶，结合物料检测实现启停控制，核心诉求是低成本、高可靠性、负载稳定性。

核心逻辑：
恒定开环转速控制：固定PWM占空比，结合六步换相实现稳定转速，无需速度反馈，适配中载负载下电机转速波动可控的场景；
物料检测启停：通过光电传感器检测物料到位，触发电机启停，通过PWM渐变升速/降速，避免急启急停导致物料掉落；
换相防抖设计：通过短延时消除霍尔信号抖动，确保六步换相稳定，避免电机异常震动。

/* ===== 六步换相PWM开环搬运机器人（工厂物料/仓库转运） =====
 * 核心：恒定开环转速+物料检测启停，PWM渐变调速
 * 适配：中载BLDC电机（霍尔信号稳定）、光电物料检测传感器、两路BLDC驱动
 */

// 硬件引脚定义
#define HALL_A 2
#define HALL_B 3
#define HALL_C 4
#define MOTOR_PWM_L 5
#define MOTOR_DIR_L1 6
#define MOTOR_DIR_L2 7
#define MOTOR_PWM_R 9
#define MOTOR_DIR_R1 10
#define MOTOR_DIR_R2 11
#define PHOTO_SENSOR A2 // 物料检测光电传感器

// 六步换相序列（同案例1，适配搬运电机接线）
const int phase_sequence[6][2] = {
  {LOW, HIGH},  // 步0
  {LOW, HIGH},  // 步1
  {LOW, HIGH},  // 步2
  {HIGH, LOW},  // 步3
  {HIGH, LOW},  // 步4
  {HIGH, LOW}   // 步5
};
// 注：简化为方向控制，实际需按电机接线定义完整3路输出，此处聚焦逻辑

// 变量定义
int current_step = 0;
int target_pwm = 100; // 目标PWM（恒定转速）
int current_pwm_l = 0; // 当前左轮PWM（渐变用）
int current_pwm_r = 0;
int photo_val = 0;
bool material_detected = false;
bool motor_running = false;
const int PHOTO_TH = 200; // 光电传感器阈值
const int PWM_STEP = 5;  // PWM渐变步长

void setup() {
  Serial.begin(115200);
  pinMode(HALL_A, INPUT_PULLUP);
  pinMode(HALL_B, INPUT_PULLUP);
  pinMode(HALL_C, INPUT_PULLUP);
  pinMode(MOTOR_PWM_L, OUTPUT);
  pinMode(MOTOR_DIR_L1, OUTPUT);
  pinMode(MOTOR_DIR_L2, OUTPUT);
  pinMode(MOTOR_PWM_R, OUTPUT);
  pinMode(MOTOR_DIR_R1, OUTPUT);
  pinMode(MOTOR_DIR_R2, OUTPUT);
  pinMode(PHOTO_SENSOR, INPUT);
  
  // 霍尔信号中断配置
  attachInterrupt(digitalPinToInterrupt(HALL_A), update_step_stable, CHANGE);
  attachInterrupt(digitalPinToInterrupt(HALL_B), update_step_stable, CHANGE);
  attachInterrupt(digitalPinToInterrupt(HALL_C), update_step_stable, CHANGE);
  
  // 电机初始停止
  analogWrite(MOTOR_PWM_L, 0);
  analogWrite(MOTOR_PWM_R, 0);
}

// 带防抖的换相函数（短延时消除霍尔抖动）
void update_step_stable() {
  delayMicroseconds(100); // 防抖延时
  int hall_a = digitalRead(HALL_A);
  int hall_b = digitalRead(HALL_B);
  int hall_c = digitalRead(HALL_C);
  int hall_state = (hall_a << 2) | (hall_b << 1) | hall_c;
  
  switch(hall_state) {
    case 1: current_step = 0; break;
    case 3: current_step = 1; break;
    case 2: current_step = 2; break;
    case 6: current_step = 3; break;
    case 4: current_step = 4; break;
    case 5: current_step = 5; break;
  }
  
  // 输出换相驱动信号
  digitalWrite(MOTOR_DIR_L1, phase_sequence[current_step][0]);
  digitalWrite(MOTOR_DIR_L2, phase_sequence[current_step][1]);
  digitalWrite(MOTOR_DIR_R1, phase_sequence[current_step][0]);
  digitalWrite(MOTOR_DIR_R2, phase_sequence[current_step][1]);
}

// 物料检测与启停控制
void material_control() {
  photo_val = analogRead(PHOTO_SENSOR);
  if (photo_val < PHOTO_TH) {
    material_detected = true; // 物料到位
  } else {
    material_detected = false;
  }
  
  // 物料到位→启动电机，否则停止（渐变）
  if (material_detected && !motor_running) {
    motor_running = true;
  } else if (!material_detected && motor_running) {
    motor_running = false;
  }
}

// PWM渐变调速（避免急启急停）
void pwm_ramp_control() {
  if (motor_running) {
    // 升速：逐步增加到目标PWM
    if (current_pwm_l < target_pwm) {
      current_pwm_l += PWM_STEP;
      if (current_pwm_l > target_pwm) current_pwm_l = target_pwm;
    }
    if (current_pwm_r < target_pwm) {
      current_pwm_r += PWM_STEP;
      if (current_pwm_r > target_pwm) current_pwm_r = target_pwm;
    }
  } else {
    // 降速：逐步降到0
    if (current_pwm_l > 0) {
      current_pwm_l -= PWM_STEP;
      if (current_pwm_l < 0) current_pwm_l = 0;
    }
    if (current_pwm_r > 0) {
      current_pwm_r -= PWM_STEP;
      if (current_pwm_r < 0) current_pwm_r = 0;
    }
  }
  
  // 输出PWM
  analogWrite(MOTOR_PWM_L, map(current_pwm_l, 0, 100, 0, 255));
  analogWrite(MOTOR_PWM_R, map(current_pwm_r, 0, 100, 0, 255));
}

void loop() {
  material_control(); // 物料检测与启停触发
  pwm_ramp_control(); // 渐变调速
  update_step_stable(); // 确保换相同步（开环无反馈，强制同步换相）
  
  Serial.print("Material:"); Serial.print(material_detected);
  Serial.print(" | Run:"); Serial.print(motor_running);
  Serial.print(" | PWML:"); Serial.print(current_pwm_l);
  Serial.print(" | PWMR:"); Serial.println(current_pwm_r);
  delay(50);
}

6、六步换相PWM开环避障机器人——园区巡逻/自主避障
适用场景：园区巡逻、室内自主避障等场景，机器人需在复杂环境中自主规避障碍物，通过六步换相PWM开环控制实现快速转向与行驶，结合超声波检测实现避障决策，核心诉求是快速响应、低成本避障。

核心逻辑：
超声波避障决策：通过超声波检测障碍物距离，输出转向/减速指令；
开环转向控制：通过左右轮PWM差速实现转向，无需位置闭环，转向响应快；
换相同步与转速匹配：通过六步换相保证电机同步运转，结合障碍物距离调整PWM，实现动态避障。

/* ===== 六步换相PWM开环避障机器人（园区巡逻/自主避障） =====
 * 核心：超声波避障+开环差速转向，六步换相同步
 * 适配：BLDC电机（霍尔）、超声波模块（HC-SR04）、两路BLDC驱动
 */

// 硬件引脚定义
#define HALL_A 2
#define HALL_B 3
#define HALL_C 4
#define MOTOR_PWM_L 5
#define MOTOR_DIR_L1 6
#define MOTOR_DIR_L2 7
#define MOTOR_PWM_R 9
#define MOTOR_DIR_R1 10
#define MOTOR_DIR_R2 11
#define TRIG_PIN 12  // 超声波触发
#define ECHO_PIN 13  // 超声波接收

// 六步换相序列
const int phase_sequence[6][2] = {
  {LOW, HIGH}, {LOW, HIGH}, {LOW, HIGH},
  {HIGH, LOW}, {HIGH, LOW}, {HIGH, LOW}
};

// 变量定义
int current_step = 0;
int left_pwm = 80;
int right_pwm = 80;
int obstacle_dist = 0; // 障碍物距离（cm）
const int SAFE_DIST = 30; // 安全距离阈值
bool obstacle_detected = false;

void setup() {
  Serial.begin(115200);
  pinMode(HALL_A, INPUT_PULLUP);
  pinMode(HALL_B, INPUT_PULLUP);
  pinMode(HALL_C, INPUT_PULLUP);
  pinMode(MOTOR_PWM_L, OUTPUT);
  pinMode(MOTOR_DIR_L1, OUTPUT);
  pinMode(MOTOR_DIR_L2, OUTPUT);
  pinMode(MOTOR_PWM_R, OUTPUT);
  pinMode(MOTOR_DIR_R1, OUTPUT);
  pinMode(MOTOR_DIR_R2, OUTPUT);
  pinMode(TRIG_PIN, OUTPUT);
  pinMode(ECHO_PIN, INPUT);
  
  // 霍尔中断
  attachInterrupt(digitalPinToInterrupt(HALL_A), update_step_避障, CHANGE);
  attachInterrupt(digitalPinToInterrupt(HALL_B), update_step_避障, CHANGE);
  attachInterrupt(digitalPinToInterrupt(HALL_C), update_step_避障, CHANGE);
  
  // 电机初始停止
  analogWrite(MOTOR_PWM_L, 0);
  analogWrite(MOTOR_PWM_R, 0);
}

// 超声波测距
int measure_obstacle_distance() {
  digitalWrite(TRIG_PIN, LOW);
  delayMicroseconds(2);
  digitalWrite(TRIG_PIN, HIGH);
  delayMicroseconds(10);
  digitalWrite(TRIG_PIN, LOW);
  long duration = pulseIn(ECHO_PIN, HIGH);
  return duration * 0.034 / 2; // 距离（cm）
}

// 避障决策（开环差速转向）
void obstacle_avoidance_decision() {
  obstacle_dist = measure_obstacle_distance();
  if (obstacle_dist < SAFE_DIST) {
    obstacle_detected = true;
    // 正前方障碍：右转优先
    if (obstacle_dist < 20) {
      left_pwm = 40;  // 左转减速
      right_pwm = 100; // 右转加速
    } else {
      left_pwm = 30;
      right_pwm = 90;
    }
  } else {
    obstacle_detected = false;
    // 无障碍：直行
    left_pwm = 80;
    right_pwm = 80;
  }
  // 边界限制PWM
  left_pwm = constrain(left_pwm, 0, 100);
  right_pwm = constrain(right_pwm, 0, 100);
}

// 避障用换相函数
void update_step_避障() {
  delayMicroseconds(100);
  int hall_a = digitalRead(HALL_A);
  int hall_b = digitalRead(HALL_B);
  int hall_c = digitalRead(HALL_C);
  int hall_state = (hall_a << 2) | (hall_b << 1) | hall_c;
  
  switch(hall_state) {
    case 1: current_step = 0; break;
    case 3: current_step = 1; break;
    case 2: current_step = 2; break;
    case 6: current_step = 3; break;
    case 4: current_step = 4; break;
    case 5: current_step = 5; break;
  }
  
  digitalWrite(MOTOR_DIR_L1, phase_sequence[current_step][0]);
  digitalWrite(MOTOR_DIR_L2, phase_sequence[current_step][1]);
  digitalWrite(MOTOR_DIR_R1, phase_sequence[current_step][0]);
  digitalWrite(MOTOR_DIR_R2, phase_sequence[current_step][1]);
}

// 开环PWM输出
void open_loop_pwm_output() {
  analogWrite(MOTOR_PWM_L, map(left_pwm, 0, 100, 0, 255));
  analogWrite(MOTOR_PWM_R, map(right_pwm, 0, 100, 0, 255));
}

void loop() {
  obstacle_avoidance_decision(); // 避障决策
  open_loop_pwm_output();        // 开环PWM输出
  update_step_避障();            // 换相同步
  
  Serial.print("Dist:"); Serial.print(obstacle_dist);
  Serial.print(" | LeftPWM:"); Serial.print(left_pwm);
  Serial.print(" | RightPWM:"); Serial.print(right_pwm);
  Serial.print(" | Obstacle:"); Serial.println(obstacle_detected);
  delay(100);
}

要点解读

1. 六步换相的底层逻辑：霍尔信号与相序的精准匹配是核心前提
   六步换相的本质是根据霍尔信号组合触发固定电机相序，实现BLDC电机的连续转动，这是开环控制的基础，核心要点在于霍尔信号与相序的匹配校准：
   霍尔信号编码：3路霍尔信号（A/B/C）产生6种有效组合（001、011、010、110、100、101），对应六步换相的6个步骤，编码方式需与电机接线严格一致；
   相序与电机转向匹配：换相序列的输出需对应电机定子绕组的通电顺序，若转向相反，只需调整换相序列的顺序或反转某一路电机的驱动信号；
   校准流程：实际调试中，需先手动转动电机，观察霍尔信号变化，记录对应的换相步骤，再通过试运转调整相序，确保电机转动平稳无卡顿，这是代码调试的关键前提。
2. 开环控制的本质：无反馈的直接PWM控制，核心诉求是快速响应与低成本
   开环控制无需编码器、电流传感器等反馈元件，直接通过PWM占空比控制转速，核心价值在于低成本、高响应、电路简化，但需接受转速波动：
   响应速度优势：无反馈延迟，PWM指令直接输出，适用于对响应速度要求高的场景（如避障、循迹的快速转向）；
   成本与复杂度优势：无需额外的传感器（编码器、电流采样电路），降低硬件成本与电路复杂度，适合低成本机器人开发；
   局限性管控：开环控制无法补偿负载变化导致的转速波动（如搬运重物时转速下降），需通过负载匹配（选用功率匹配的电机）、固定场景适配（负载变化小的场景），确保转速波动在可接受范围，案例2通过PWM渐变适配负载变化就是典型优化手段。
3. PWM调速的核心：占空比与转速的非线性映射，需结合实际调试标定
   BLDC电机转速与PWM占空比并非严格线性关系，受电机特性、负载影响较大，开环控制中需通过占空比标定实现稳定转速控制：
   占空比标定流程：空载时，逐步提高PWM占空比，记录电机转速与占空比的对应关系，绘制转速-占空比曲线，确定目标转速对应的占空比；
   负载影响补偿：负载增加时，相同占空比下转速会下降，需通过实验确定不同负载下的占空比补偿值，案例2中恒定PWM控制就需提前标定中载下的对应占空比；
   PWM频率选择：Arduino的PWM频率（默认490Hz/980Hz）需适配电机驱动的响应速度，过低会导致电机震动，过高则可能驱动电路无法响应，可通过调整Timer寄存器修改PWM频率，优化电机运行平稳性。
4. 换相稳定性的关键：霍尔信号防抖与同步机制，避免电机异常震动
   霍尔信号易受干扰产生抖动，导致换相频繁触发，引发电机异常震动甚至停转，这是开环控制中最常见的问题，解决核心是防抖与同步机制：
   硬件防抖：霍尔信号采用上拉电阻，必要时在信号引脚并联滤波电容，减少电磁干扰导致的信号抖动；
   软件防抖：在霍尔中断函数中加入短延时（如100μs），待信号稳定后再读取霍尔状态，避免误触发，如案例2、3中的delayMicroseconds(100)；
   换相同步：开环控制无反馈，需确保换相频率与电机转速匹配，可通过定时器触发换相（替代中断），或通过霍尔信号的自然频率触发，确保换相时机与电机转动同步，避免相序错乱。
5. 场景适配的核心：开环控制的边界与优化，按需平衡响应与精度
   六步换相开环控制并非通用，需根据场景需求平衡响应速度、成本、精度，核心是明确开环控制的适用边界，并针对性优化：
   适用场景：适用于负载稳定、转速精度要求不高、响应速度优先的场景，如物流循迹、轻中载搬运、园区避障，这些场景对转速精度要求低，开环控制的快速响应能提升体验；
   不适用场景：高精度位置控制（如机械臂）、负载剧烈变化（如重物搬运）、高速高精度调速场景，这些场景需引入闭环控制（位置/速度/电流闭环）；
   场景化优化：
   循迹场景：优化PWM差速控制参数，实现快速纠偏，避免过冲；
   搬运场景：引入PWM渐变升速/降速，避免急启急停导致物料掉落；
   避障场景：结合超声波距离动态调整PWM，实现精准减速与转向，提升避障稳定性。

请注意：以上案例仅作为思路拓展的参考示例，不保证完全正确、适配所有场景或可直接编译运行。由于硬件平台、实际使用场景、Arduino 版本的差异，均可能影响代码的适配性与使用方法的选择。在实际编程开发时，请务必根据自身硬件配置、使用场景及具体功能需求进行针对性调整，并通过多次实测验证效果；同时需确保硬件接线正确，充分了解所用传感器、执行器等设备的技术规范与核心特性。对于涉及硬件操作的代码，使用前务必核对引脚定义、电平参数等关键信息的准确性与安全性，避免因参数错误导致硬件损坏或运行异常。