机器人底盘双向旋转：DRV8323RS、L6234和自定义H桥方法

在 Arduino 驱动的无刷直流电机（BLDC）项目中，实现双向旋转是许多应用（如机器人底盘、电动工具）的核心需求。选择合适的驱动方案至关重要，它直接决定了系统的效率、功率和控制复杂度。DRV8323RS、L6234 和自定义 H 桥代表了三种不同层级的解决方案：分别是“集成化驱动器”、“单芯片三相驱动”和“从零搭建”。

1. DRV8323RS：集成化三相驱动器
DRV8323RS 是一款高度集成的栅极驱动器，通常配合外部 MOSFET 使用，专为三相电机设计。
🔧 主要特点
* 高集成度与保护功能：它集成了三个半桥驱动器、电流检测放大器、降压稳压器和多种保护机制（如过流保护、欠压锁定、过温保护）。这意味着你不需要设计复杂的逻辑电路，只需关注 MOSFET 的选型。
* 灵活的控制接口：支持 PWM 和 SPI 两种控制模式。通过 SPI 接口，你可以读取电流数据、配置保护阈值，实现精细的闭环控制。
* 大功率潜力：虽然芯片本身有功率限制，但因为它驱动外部 MOSFET，通过选用大电流 MOSFET，该方案可以支持高达 60V 电压和数十安培的电流，适合大功率双向应用。
🏗️ 应用场景
* 大功率电动工具：如电钻、电锯，需要高扭矩和正反转切换。
* 中型工业机器人关节：需要精确控制转矩和方向，且对散热有要求的场景。
* 电动滑板/代步车：需要高效能和可靠保护的轮毂电机驱动。
⚠️ 注意事项
* MOSFET 选型匹配：必须仔细匹配 MOSFET 的阈值电压（Vgs）和 DRV8323RS 的驱动能力，防止 MOSFET 发热或开关速度不够。
* PCB 布局（Layout）：由于涉及大电流和高频开关，PCB 布局非常关键。驱动芯片与 MOSFET 之间的走线应尽量短而粗，以减少寄生电感，防止电压尖峰。
* 散热设计：外部 MOSFET 在大电流下会产生大量热量，必须配备足够的散热片。

2. L6234：单芯片三相驱动
L6234 是一款将功率 MOSFET 和驱动逻辑集成在单一封装内的三相电机驱动器。
🔧 主要特点
* 高度集成（Driver + MOSFET）：它将三个半桥的驱动电路和功率开关都集成在一个芯片里，极大简化了电路设计，减少了外围元件数量。
* 易用性：它直接接受来自 Arduino 的 PWM 信号和方向逻辑信号。内置了续流二极管和保护电路（过流、过热），使用起来非常方便，类似于控制有刷电机的 L298N，但针对的是三相 BLDC。
* 双向控制：通过改变换向时序（即改变相序），可以轻松实现电机的正反转。
🏗️ 应用场景
* 中小型 BLDC 风扇/鼓风机：需要双向送风或排气的 HVAC 系统。
* 计算机散热与服务器冷却：需要精确控制风扇转速和方向（虽然风扇通常单向，但某些特殊散热逻辑可能需要反转除尘）。
* 教育与原型开发：由于其接口简单，非常适合用于验证 BLDC 控制算法（如六步换向）的原型板。
⚠️ 注意事项
* 功率限制：由于所有功率器件都在一个芯片内，其散热能力受限。通常最大持续电流在 3A-5A 左右（具体视封装和散热条件而定），不适合驱动大功率电机。
* 热管理：必须将芯片安装在散热片上，否则在中等负载下容易触发过热保护而关闭。
* 电压范围：需确保电源电压在 L6234 的额定范围内（通常最高 52V），避免击穿内部 MOSFET。

3. 自定义 H 桥方法（基于 MOSFET + 驱动电路）
这是一种“从零开始”的方法，使用分立元件（如 IR2101 驱动芯片 + 6 个 MOSFET）搭建三相全桥逆变电路。
🔧 主要特点
* 极致的定制化：你可以根据需求选择任意规格的 MOSFET 和二极管，构建一个能承受数百伏电压和上百安培电流的驱动系统。
* 低成本（大批量）：在批量生产时，使用分立元件通常比购买集成驱动芯片成本更低。
* 学习价值高：这种方法迫使你深入理解 BLDC 的换向原理、死区时间设置、米勒效应和续流回路，是理解电机驱动底层逻辑的最佳途径。
🏗️ 应用场景
* DIY 电子调速器（ESC）：无人机爱好者或模型玩家自制高性能 ESC。
* 高压工业设备：如你提到的 310V-380V 高压 BLDC 电机控制，市面上很难买到现成的低压驱动芯片能满足此电压，必须使用分立元件搭建。
* 低成本大规模产品：对成本极度敏感且有足够研发能力的消费电子产品。
⚠️ 注意事项
* 直通风险（Shoot-through）：这是最大的风险。如果同一相的上下两个 MOSFET 同时导通，会造成电源短路，瞬间烧毁 MOSFET。必须通过硬件逻辑电路或软件延时精确设置死区时间（Dead Time）。
* 复杂的 PCB 设计：需要极高的 PCB 布局技巧。驱动信号线要短，功率回路要粗，地线要单点接地，否则极易产生电磁干扰（EMI）或振荡。
* 缺乏保护：分立方案通常需要额外设计复杂的保护电路（如电流采样、电压检测），否则系统非常脆弱。

1、DRV8323RS三相全桥驱动方案
场景：高功率、高集成度的专业应用，需要完备的保护功能。
核心逻辑：SPI配置DRV8323 + 六步换相 + 故障保护。

代码

#include <SimpleFOC.h>
#include <SPI.h>

// DRV8323引脚定义
#define DRV_nSLEEP 8
#define DRV_nFAULT 9
#define DRV_EN_GATE 10
#define DRV_MOSI 11
#define DRV_MISO 12
#define DRV_SCLK 13
#define DRV_nCS 7

// PWM输出引脚
#define DRV_GH_A 5
#define DRV_GL_A 4
#define DRV_GH_B 3
#define DRV_GL_B 2
#define DRV_GH_C 1
#define DRV_GL_C 0

// 电流检测
#define DRV_SO_A A0
#define DRV_SO_B A1
#define DRV_SO_C A2

// 电机状态
bool motorEnabled = false;
float targetCurrent = 0.0;
int motorDirection = 1;  // 1: 正向, -1: 反向

// DRV8323寄存器定义
#define DRV8323_CTRL_REG1 0x00
#define DRV8323_CTRL_REG2 0x01
#define DRV8323_CTRL_REG3 0x02
#define DRV8323_CTRL_REG4 0x03
#define DRV8323_CTRL_REG5 0x04
#define DRV8323_CTRL_REG6 0x05
#define DRV8323_CTRL_REG7 0x06
#define DRV8323_FAULT_REG1 0x07
#define DRV8323_FAULT_REG2 0x08

void setup() {
  Serial.begin(115200);
  
  // 1. 初始化GPIO
  pinMode(DRV_nSLEEP, OUTPUT);
  pinMode(DRV_nFAULT, INPUT);
  pinMode(DRV_EN_GATE, OUTPUT);
  pinMode(DRV_nCS, OUTPUT);
  digitalWrite(DRV_nCS, HIGH);
  digitalWrite(DRV_nSLEEP, LOW);
  digitalWrite(DRV_EN_GATE, LOW);
  
  // 2. 初始化SPI
  SPI.begin();
  SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE1));
  
  // 3. 启动DRV8323
  delay(10);
  digitalWrite(DRV_nSLEEP, HIGH);
  delay(1);
  digitalWrite(DRV_EN_GATE, HIGH);
  delay(1);
  
  // 4. 配置DRV8323寄存器
  configureDRV8323();
  
  // 5. 初始化PWM引脚
  initPWMpins();
  
  // 6. 清除故障
  clearFaults();
  
  Serial.println("DRV8323初始化完成");
}

void loop() {
  // 1. 检查故障
  if (digitalRead(DRV_nFAULT) == LOW) {
    handleFault();
    return;
  }
  
  // 2. 读取指令
  if (Serial.available()) {
    char cmd = Serial.read();
    switch(cmd) {
      case 'F':  // 正向
        motorDirection = 1;
        targetCurrent = 1.0;
        break;
      case 'R':  // 反向
        motorDirection = -1;
        targetCurrent = 1.0;
        break;
      case 'S':  // 停止
        targetCurrent = 0.0;
        break;
      case '+':  // 加速
        targetCurrent = min(targetCurrent + 0.1, 2.0);
        break;
      case '-':  // 减速
        targetCurrent = max(targetCurrent - 0.1, 0.0);
        break;
    }
  }
  
  // 3. 读取相电流
  float currentA = readCurrent(DRV_SO_A);
  float currentB = readCurrent(DRV_SO_B);
  float currentC = readCurrent(DRV_SO_C);
  
  // 4. 简单的电流PI控制
  static float errorIntegral = 0;
  float currentSetpoint = targetCurrent * motorDirection;
  float currentMeasured = (currentA + currentB + currentC) / 3.0;
  float error = currentSetpoint - currentMeasured;
  errorIntegral += error * 0.001;  // 积分项
  
  // 抗饱和
  if (errorIntegral > 1.0) errorIntegral = 1.0;
  if (errorIntegral < -1.0) errorIntegral = -1.0;
  
  float dutyCycle = error * 0.5 + errorIntegral * 0.1;
  dutyCycle = constrain(dutyCycle, -0.9, 0.9);
  
  // 5. 六步换相
  static int step = 0;
  static unsigned long lastStepTime = 0;
  int stepDelay = 10000;  // 根据目标速度调整
  
  if (micros() - lastStepTime > stepDelay) {
    if (targetCurrent != 0) {
      step = (step + motorDirection + 6) % 6;  // 方向影响换相顺序
      applyCommutationStep(step, dutyCycle);
    } else {
      // 停止状态，关闭所有PWM
      stopPWM();
    }
    lastStepTime = micros();
  }
  
  // 6. 监控输出
  static unsigned long lastPrint = 0;
  if (millis() - lastPrint > 100) {
    Serial.print("Setpoint:");
    Serial.print(currentSetpoint, 2);
    Serial.print("A Measured:");
    Serial.print(currentMeasured, 2);
    Serial.print("A Duty:");
    Serial.print(dutyCycle, 2);
    Serial.print(" Step:");
    Serial.println(step);
    lastPrint = millis();
  }
}

void configureDRV8323() {
  // 配置DRV8323寄存器
  writeRegister(DRV8323_CTRL_REG1, 0b00111100);  // PWM模式，1x PWM，死区时间400ns
  writeRegister(DRV8323_CTRL_REG2, 0b01001010);  // 电流检测增益20V/V，过流保护5.6A
  writeRegister(DRV8323_CTRL_REG3, 0b00000000);  // 正常模式，无压摆率控制
  writeRegister(DRV8323_CTRL_REG4, 0b01001001);  // 过流保护5.6A，VDS保护1.2V
  writeRegister(DRV8323_CTRL_REG5, 0b00000000);  // 正常报告
  writeRegister(DRV8323_CTRL_REG6, 0b00000000);  // 无特殊功能
  writeRegister(DRV8323_CTRL_REG7, 0b00000000);  // 默认设置
}

void writeRegister(uint8_t reg, uint8_t data) {
  digitalWrite(DRV_nCS, LOW);
  SPI.transfer((reg << 1) | 0x01);  // 写操作
  SPI.transfer(data);
  digitalWrite(DRV_nCS, HIGH);
  delayMicroseconds(10);
}

uint16_t readRegister(uint8_t reg) {
  digitalWrite(DRV_nCS, LOW);
  SPI.transfer(reg << 1);  // 读操作
  uint16_t response = SPI.transfer(0x00);
  digitalWrite(DRV_nCS, HIGH);
  return response;
}

void applyCommutationStep(int step, float duty) {
  // 六步换相表
  // 步骤: A_H A_L B_H B_L C_H C_L
  static const bool stepTable[6][6] = {
    {1,0,0,1,0,0},  // 步骤0: A+ B-
    {0,1,0,0,0,1},  // 步骤1: C- B+
    {0,0,1,0,1,0},  // 步骤2: B+ C-
    {0,0,0,1,1,0},  // 步骤3: B- C+
    {1,0,0,0,0,1},  // 步骤4: C+ A-
    {0,1,1,0,0,0}   // 步骤5: A- B+
  };
  
  int pwmValue = (int)(abs(duty) * 255);
  
  // 控制A相
  if (stepTable[step][0]) {
    analogWrite(DRV_GH_A, pwmValue);
    digitalWrite(DRV_GL_A, LOW);
  } else if (stepTable[step][1]) {
    digitalWrite(DRV_GH_A, LOW);
    analogWrite(DRV_GL_A, pwmValue);
  } else {
    digitalWrite(DRV_GH_A, LOW);
    digitalWrite(DRV_GL_A, LOW);
  }
  
  // 控制B相
  if (stepTable[step][2]) {
    analogWrite(DRV_GH_B, pwmValue);
    digitalWrite(DRV_GL_B, LOW);
  } else if (stepTable[step][3]) {
    digitalWrite(DRV_GH_B, LOW);
    analogWrite(DRV_GL_B, pwmValue);
  } else {
    digitalWrite(DRV_GH_B, LOW);
    digitalWrite(DRV_GL_B, LOW);
  }
  
  // 控制C相
  if (stepTable[step][4]) {
    analogWrite(DRV_GH_C, pwmValue);
    digitalWrite(DRV_GL_C, LOW);
  } else if (stepTable[step][5]) {
    digitalWrite(DRV_GH_C, LOW);
    analogWrite(DRV_GL_C, pwmValue);
  } else {
    digitalWrite(DRV_GH_C, LOW);
    digitalWrite(DRV_GL_C, LOW);
  }
}

2、L6234三相半桥驱动方案
场景：中等功率，需要简单的三相BLDC控制。
核心逻辑：使能控制 + PWM占空比调节 + 方向控制。

代码

#include <SimpleFOC.h>

// L6234引脚定义
#define L6234_EN 8      // 使能引脚
#define L6234_A_IN1 9   // A相输入1
#define L6234_A_IN2 10  // A相输入2
#define L6234_B_IN1 5   // B相输入1
#define L6234_B_IN2 6   // B相输入2
#define L6234_C_IN1 3   // C相输入1
#define L6234_C_IN2 11  // C相输入2

// 霍尔传感器
#define HALL_U 2
#define HALL_V 3
#define HALL_W 4

// 过流检测
#define L6234_SENSE A0

// 状态变量
int hallState = 0;
int lastHallState = 0;
int speedPWM = 128;  // 0-255
int direction = 1;   // 1: 正向, -1: 反向
bool brakeMode = false;

void setup() {
  Serial.begin(115200);
  
  // 1. 初始化L6234引脚
  pinMode(L6234_EN, OUTPUT);
  pinMode(L6234_A_IN1, OUTPUT);
  pinMode(L6234_A_IN2, OUTPUT);
  pinMode(L6234_B_IN1, OUTPUT);
  pinMode(L6234_B_IN2, OUTPUT);
  pinMode(L6234_C_IN1, OUTPUT);
  pinMode(L6234_C_IN2, OUTPUT);
  
  // 2. 初始化霍尔输入
  pinMode(HALL_U, INPUT_PULLUP);
  pinMode(HALL_V, INPUT_PULLUP);
  pinMode(HALL_W, INPUT_PULLUP);
  
  // 3. 设置PWM频率
  // 提高Timer1频率到31.25kHz
  TCCR1B = TCCR1B & 0b11111000 | 0x01;
  // Timer2频率到31.25kHz
  TCCR2B = TCCR2B & 0b11111000 | 0x01;
  
  // 4. 启用L6234
  digitalWrite(L6234_EN, HIGH);
  delay(10);
  
  Serial.println("L6234初始化完成");
}

void loop() {
  // 1. 读取霍尔传感器
  hallState = readHallSensors();
  
  // 2. 检测换相点
  if (hallState != lastHallState) {
    // 根据转向和霍尔状态决定换相
    int commutationStep = getCommutationStep(hallState, direction);
    applyL6234Commutation(commutationStep);
    lastHallState = hallState;
  }
  
  // 3. 读取速度指令
  if (Serial.available()) {
    char cmd = Serial.read();
    switch(cmd) {
      case '0'...'9':
        speedPWM = map(cmd - '0', 0, 9, 0, 255);
        break;
      case 'F':
        direction = 1;
        brakeMode = false;
        break;
      case 'R':
        direction = -1;
        brakeMode = false;
        break;
      case 'B':
        brakeMode = true;
        break;
    }
  }
  
  // 4. 电流检测和保护
  float currentSense = analogRead(L6234_SENSE) * (5.0 / 1023.0);
  if (currentSense > 1.0) {  // 假设1V对应过流
    speedPWM = max(speedPWM - 20, 0);
    Serial.println("过流保护，降低速度");
  }
  
  // 5. 制动处理
  if (brakeMode) {
    applyBrake();
  }
  
  delay(1);
}

int readHallSensors() {
  int u = digitalRead(HALL_U);
  int v = digitalRead(HALL_V);
  int w = digitalRead(HALL_W);
  return (u << 2) | (v << 1) | w;
}

int getCommutationStep(int hall, int dir) {
  // 霍尔状态到换相步骤的映射
  static const int hallToStep_forward[8] = {-1, 5, 3, 4, 1, 0, 2, -1};
  static const int hallToStep_reverse[8] = {-1, 2, 4, 3, 0, 1, 5, -1};
  
  if (dir > 0) {
    return hallToStep_forward[hall];
  } else {
    return hallToStep_reverse[hall];
  }
}

void applyL6234Commutation(int step) {
  // L6234换相表
  // 步骤: A_IN1 A_IN2 B_IN1 B_IN2 C_IN1 C_IN2
  static const int stepTable[6][6] = {
    {1,0,0,1,0,0},  // 步骤0: A+ B-
    {0,0,1,0,0,1},  // 步骤1: B+ C-
    {0,1,0,0,1,0},  // 步骤2: C+ A-
    {0,1,1,0,0,0},  // 步骤3: A- B+
    {0,0,0,1,1,0},  // 步骤4: B- C+
    {1,0,0,0,0,1}   // 步骤5: C- A+
  };
  
  if (step < 0 || step > 5) return;
  
  // 控制A相
  if (stepTable[step][0] == 1) {
    analogWrite(L6234_A_IN1, speedPWM);
    digitalWrite(L6234_A_IN2, LOW);
  } else if (stepTable[step][1] == 1) {
    digitalWrite(L6234_A_IN1, LOW);
    analogWrite(L6234_A_IN2, speedPWM);
  } else {
    digitalWrite(L6234_A_IN1, LOW);
    digitalWrite(L6234_A_IN2, LOW);
  }
  
  // 控制B相
  if (stepTable[step][2] == 1) {
    analogWrite(L6234_B_IN1, speedPWM);
    digitalWrite(L6234_B_IN2, LOW);
  } else if (stepTable[step][3] == 1) {
    digitalWrite(L6234_B_IN1, LOW);
    analogWrite(L6234_B_IN2, speedPWM);
  } else {
    digitalWrite(L6234_B_IN1, LOW);
    digitalWrite(L6234_B_IN2, LOW);
  }
  
  // 控制C相
  if (stepTable[step][4] == 1) {
    analogWrite(L6234_C_IN1, speedPWM);
    digitalWrite(L6234_C_IN2, LOW);
  } else if (stepTable[step][5] == 1) {
    digitalWrite(L6234_C_IN1, LOW);
    analogWrite(L6234_C_IN2, speedPWM);
  } else {
    digitalWrite(L6234_C_IN1, LOW);
    digitalWrite(L6234_C_IN2, LOW);
  }
}

void applyBrake() {
  // 短路制动
  digitalWrite(L6234_A_IN1, HIGH);
  digitalWrite(L6234_A_IN2, HIGH);
  digitalWrite(L6234_B_IN1, HIGH);
  digitalWrite(L6234_B_IN2, HIGH);
  digitalWrite(L6234_C_IN1, HIGH);
  digitalWrite(L6234_C_IN2, HIGH);
}

3、MOSFET H桥自制驱动方案
场景：低成本、定制化需求，或大功率特殊应用。
核心逻辑：IR2104半桥驱动 + 软件死区控制 + 电流采样。

代码

#include <SimpleFOC.h>

// 半桥驱动引脚
#define HBRIDGE_EN 8     // 总使能
#define HA_HI 9          // A相高侧驱动
#define HA_LO 10
#define HB_HI 5
#define HB_LO 6
#define HC_HI 3
#define HC_LO 11

// 电流采样
#define CURRENT_A A0
#define CURRENT_B A1
#define CURRENT_C A2

// 死区时间
#define DEAD_TIME 1000  // 1000ns死区

// 状态机
enum MotorState { STOP, STARTING, RUNNING, FAULT };
MotorState state = STOP;

// PWM参数
float pwmDuty = 0.0;
int pwmFrequency = 20000;  // 20kHz
int pwmResolution = 8;     // 8位分辨率
float busVoltage = 24.0;   // 母线电压

// 电流PID
float targetCurrent = 0.0;
float kp = 0.5, ki = 0.1, kd = 0.01;
float errorIntegral = 0, lastError = 0;

void setup() {
  Serial.begin(115200);
  
  // 1. 初始化PWM引脚
  pinMode(HA_HI, OUTPUT);
  pinMode(HA_LO, OUTPUT);
  pinMode(HB_HI, OUTPUT);
  pinMode(HB_LO, OUTPUT);
  pinMode(HC_HI, OUTPUT);
  pinMode(HC_LO, OUTPUT);
  pinMode(HBRIDGE_EN, OUTPUT);
  
  // 2. 初始化ADC
  analogReference(EXTERNAL);
  
  // 3. 设置PWM频率
  setupPWMFrequency(pwmFrequency);
  
  // 4. 初始化状态
  digitalWrite(HBRIDGE_EN, LOW);
  state = STOP;
  
  Serial.println("H桥驱动器初始化完成");
}

void loop() {
  static unsigned long lastControlTime = 0;
  unsigned long now = micros();
  
  // 1. 状态机处理
  switch(state) {
    case STOP:
      handleStopState();
      break;
    case STARTING:
      handleStartState();
      break;
    case RUNNING:
      handleRunningState();
      break;
    case FAULT:
      handleFaultState();
      break;
  }
  
  // 2. 1kHz控制循环
  if (now - lastControlTime >= 1000) {
    // 读取电流
    float iA = readPhaseCurrent(CURRENT_A);
    float iB = readPhaseCurrent(CURRENT_B);
    float iC = readPhaseCurrent(CURRENT_C);
    
    // 电流保护
    if (abs(iA) > 10.0 || abs(iB) > 10.0 || abs(iC) > 10.0) {
      state = FAULT;
      Serial.println("过流故障!");
    }
    
    // 电流PI控制
    float error = targetCurrent - (iA + iB + iC) / 3.0;
    errorIntegral += error;
    errorIntegral = constrain(errorIntegral, -100.0, 100.0);
    
    float errorDerivative = (error - lastError) / 0.001;
    lastError = error;
    
    pwmDuty = kp * error + ki * errorIntegral + kd * errorDerivative;
    pwmDuty = constrain(pwmDuty, -0.9, 0.9);
    
    // 生成PWM
    if (state == RUNNING) {
      generateSVPWM(pwmDuty);
    }
    
    lastControlTime = now;
  }
  
  // 3. 串口命令处理
  if (Serial.available()) {
    char cmd = Serial.read();
    switch(cmd) {
      case 'S':  // 启动
        if (state == STOP) {
          state = STARTING;
          Serial.println("启动电机...");
        }
        break;
      case 'T':  // 停止
        state = STOP;
        break;
      case '0'...'9':
        targetCurrent = (cmd - '0') * 0.2;
        Serial.print("目标电流:");
        Serial.print(targetCurrent, 1);
        Serial.println("A");
        break;
    }
  }
}

void handleStopState() {
  // 关闭所有MOSFET
  analogWrite(HA_HI, 0);
  analogWrite(HA_LO, 0);
  analogWrite(HB_HI, 0);
  analogWrite(HB_LO, 0);
  analogWrite(HC_HI, 0);
  analogWrite(HC_LO, 0);
  digitalWrite(HBRIDGE_EN, LOW);
}

void handleStartState() {
  static unsigned long startTime = 0;
  static int startStep = 0;
  
  if (startTime == 0) {
    startTime = millis();
    digitalWrite(HBRIDGE_EN, HIGH);
  }
  
  // 启动序列
  if (millis() - startTime < 100) {
    // 对齐阶段
    applyAlignment(startStep);
    startStep = (startStep + 1) % 6;
  } else if (millis() - startTime < 500) {
    // 开环加速
    pwmDuty = 0.1;
    generateSVPWM(pwmDuty);
  } else {
    // 启动完成
    state = RUNNING;
    startTime = 0;
    Serial.println("启动完成，进入运行状态");
  }
}

void generateSVPWM(float duty) {
  // 空间矢量PWM生成
  // 简化版SVPWM，实际需要更复杂的计算
  
  int pwmValue = (int)(abs(duty) * 255);
  pwmValue = constrain(pwmValue, 0, 250);  // 保留死区余量
  
  // 简单的三相正弦PWM
  static float angle = 0;
  angle += duty * 0.1;
  if (angle > 2 * PI) angle -= 2 * PI;
  
  float u = sin(angle) * duty;
  float v = sin(angle + 2*PI/3) * duty;
  float w = sin(angle + 4*PI/3) * duty;
  
  // 添加死区控制
  writePWMwithDeadTime(HA_HI, HA_LO, u);
  writePWMwithDeadTime(HB_HI, HB_LO, v);
  writePWMwithDeadTime(HC_HI, HC_LO, w);
}

void writePWMwithDeadTime(int hiPin, int loPin, float duty) {
  int pwmVal = (int)((duty + 1.0) * 127.5);  // 转换为0-255
  
  // 软件死区控制
  if (pwmVal > 127) {
    // 高侧开启
    analogWrite(hiPin, pwmVal);
    delayMicroseconds(DEAD_TIME);
    analogWrite(loPin, 0);
  } else {
    // 低侧开启
    analogWrite(loPin, 255 - pwmVal);
    delayMicroseconds(DEAD_TIME);
    analogWrite(hiPin, 0);
  }
}

float readPhaseCurrent(int pin) {
  // 读取电流采样
  float adcValue = analogRead(pin);
  // 假设采样电阻0.01欧，放大倍数20倍
  float voltage = adcValue * (5.0 / 1023.0);
  float current = voltage / 20.0 / 0.01;
  return current;
}

要点解读
1、驱动IC选择的功率与集成度权衡
DRV8323RS：全集成解决方案，内置MOSFET、驱动器、电流检测、保护电路。案例一通过SPI接口可配置死区时间、电流限制、保护阈值。适合50V/30A以下应用，BOM简单但成本高。
L6234：三相半桥驱动器，需外接MOSFET。案例二通过6路PWM直接控制，结构简单。适合中等功率（40V/5A），但需外部电流检测和保护电路。
自定义H桥：案例三采用分立MOSFET + IR2104驱动器，成本最低，可扩展性最强，但设计最复杂。需自行处理死区时间、电流采样、保护电路。
2、死区时间（Dead Time）是硬件安全的核心
硬件死区：DRV8323内置可编程死区（400ns-2μs），通过SPI配置。案例一配置为400ns。
软件死区：自定义方案必须实现软件死区。案例三的writePWMwithDeadTime()函数中，先关闭一侧，delayMicroseconds(DEAD_TIME)后再开启另一侧，防止直通短路。1000ns是保守起点，实际需根据MOSFET开关速度调整。
3、电流采样方案决定控制精度
低侧采样：最简单，案例三在每相低侧MOSFET源极接采样电阻。但只能在下管导通时采样，有盲区。
高侧采样：需专用高侧电流传感器（如INA240），成本高。
集成采样：DRV8323内置三个差分电流放大器，案例一通过DRV_SO_x读取。可实时采样任意两相电流，计算第三相，实现真正的FOC。
4、保护电路的完备性
DRV8323：案例一读取DRV_nFAULT引脚，可检测过流、过温、欠压、短路。故障寄存器可定位具体故障类型。
L6234：只有过温关断，案例二需在L6234_SENSE引脚外接采样电阻实现过流保护。
自定义方案：需实现所有保护：案例三的电流保护、欠压保护、过温保护（需NTC）。硬件比较器应作为最后防线，软件保护有延迟。
5、PWM频率与MOSFET选型
频率选择：BLDC常用8-20kHz。案例一默认使用Arduino的490Hz/980Hz，必须提高频率以减少电机噪音。案例二通过修改TCCR1B寄存器提高到31.25kHz。
MOSFET选型：自定义方案的关键参数：
Vds：至少2倍母线电压（24V系统选60V以上）
Rds(on)：决定导通损耗，<10mΩ
Qg：栅极电荷，影响开关速度，决定驱动电流需求
SOA：安全工作区，防止二次击穿
栅极驱动：IR2104是经济选择，但驱动能力有限。大功率MOSFET需专用驱动器（如IRS21864）。

4、DRV8323RS SPI配置双向旋转代码（基于STM32F407移植）

代码

#include <SPI.h>
#define DRV_CS_PIN 10

// 驱动控制寄存器（0x02）配置
void DRV8323_SetControl(uint8_t pwmMode, uint8_t brake, uint8_t coast) {
  uint16_t regValue = 0;
  regValue |= (pwmMode & 0x03) << 5;  // PWM模式选择（6x PWM）
  regValue |= (brake & 0x01) << 1;    // 制动控制
  regValue |= (coast & 0x01) << 2;    // 滑行控制
  digitalWrite(DRV_CS_PIN, LOW);
  SPI.transfer16(0x8000 | (0x02 << 11) | regValue); // 写命令+地址+数据
  digitalWrite(DRV_CS_PIN, HIGH);
}

// 双向旋转控制函数
void Motor_Rotate(bool direction, uint8_t speed) {
  // 方向控制通过PWM相位差实现（需配合高级定时器生成6路PWM）
  if (direction) {
    // 正转：HA/HB/HC与LA/LB/LC互补导通
    TIM1->CCR1 = speed;  // 假设使用TIM1通道1-6生成PWM
    TIM1->CCR2 = speed;
    TIM1->CCR3 = speed;
  } else {
    // 反转：交换高侧/低侧导通顺序
    TIM1->CCR1 = 255 - speed;
    TIM1->CCR2 = 255 - speed;
    TIM1->CCR3 = 255 - speed;
  }
}

void setup() {
  SPI.begin();
  SPI.setClockDivider(SPI_CLOCK_DIV2);
  pinMode(DRV_CS_PIN, OUTPUT);
  DRV8323_SetControl(0x00, 0, 0); // 6x PWM模式，禁用制动/滑行
}

void loop() {
  Motor_Rotate(true, 128);  // 正转50%占空比
  delay(2000);
  Motor_Rotate(false, 128); // 反转50%占空比
  delay(2000);
}

5、L6234库实现双向旋转代码（基于Arduino Mega）

代码

#include <L6234.h>
#define EN_PIN 9
#define PHASE_U 2
#define PHASE_V 3
#define PHASE_W 4

L6234 motor(PHASE_U, PHASE_V, PHASE_W, EN_PIN);

void setup() {
  motor.begin(); // 初始化L6234（内部包含PWM频率设置）
  motor.enable(); // 使能驱动器
}

void loop() {
  // 正转（三相六步换相序列）
  motor.setPhaseSequence({1, 0, 0}); // 示例简化换相逻辑
  analogWrite(EN_PIN, 128); // 50%速度
  delay(2000);
  
  // 反转（反向换相序列）
  motor.setPhaseSequence({0, 0, 1}); // 需根据实际相序调整
  analogWrite(EN_PIN, 128);
  delay(2000);
  
  // 更精确的实现需使用霍尔传感器或编码器反馈
}

6、自定义H桥双向旋转代码（基于L298N模块）

代码

#define IN1 8
#define IN2 9
#define ENA 10

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(ENA, OUTPUT);
}

void loop() {
  // 正转
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, LOW);
  analogWrite(ENA, 128); // 50%速度
  delay(2000);
  
  // 反转
  digitalWrite(IN1, LOW);
  digitalWrite(IN2, HIGH);
  analogWrite(ENA, 128);
  delay(2000);
  
  // 刹车（需L298N支持同时导通对角MOS管）
  digitalWrite(IN1, HIGH);
  digitalWrite(IN2, HIGH);
  delay(500);
}

要点解读
1、驱动拓扑选择
DRV8323RS：集成栅极驱动+电流检测，适合高性能场景（如无人机云台），需SPI配置寄存器实现灵活控制。
L6234：全集成三相驱动，简化硬件设计，但需配合外部PWM生成器（如Arduino的Timer库）。
自定义H桥：成本最低，但需自行处理死区时间、直通保护等问题，仅适用于低功率电机。
2、双向旋转实现机制
换相序列：BLDC需通过改变三相导通顺序实现转向（如正转顺序：U→V→W，反转顺序：U→W→V）。
PWM相位控制：高级方案（如DRV8323RS）通过调整高侧/低侧PWM相位差实现正反转，需配合硬件定时器生成6路PWM。
简易方案：如L298N通过交换H桥输入极性实现反转，但效率低于三相换相。
3、保护机制实现
DRV8323RS：内置过流、过温、欠压保护，需通过寄存器配置阈值（如IDRIVE参数设置栅极驱动电流）。
L6234：依赖外部电路实现保护（如串联保险丝、并联TVS二极管）。
自定义H桥：需软件实现过流检测（如采样电阻+ADC）和硬件互锁电路防止直通。
4、反馈控制优化
闭环控制：需集成编码器（如ABZ相）或霍尔传感器，通过PID算法实现速度/位置控制（示例代码中未体现，实际需结合Encoder.h库）。
开环控制：如L298N方案依赖固定PWM占空比，易受负载变化影响。
5、硬件设计要点
电源隔离：电机驱动部分与Arduino逻辑部分需独立供电（如DRV8323RS的DVDD与AVDD分离）。
散热设计：高功率场景（如L6234驱动2A以上电流）需加散热片或风扇。
电磁兼容：电机线与信号线分开布线，长距离传输时使用屏蔽线。

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

【花雕学编程】机器人底盘实现双向旋转的DRV8323RS、L6234和自定义H桥方法