【花雕学编程】Arduino BLDC 之驱动器模块L6234、DRV8302和TB6605 简单

// L6234 控制引脚定义
// 假设使用 Arduino 的 PWM 引脚直接驱动 L6234 的输入
const int IN1_A = 9;  // A 相高侧输入 (PWM)
const int IN2_A = 10; // A 相低侧输入 (PWM) - 也可用数字引脚
const int IN1_B = 5;  // B 相高侧
const int IN2_B = 6;  // B 相低侧
const int IN1_C = 3;  // C 相高侧
const int IN2_C = 11; // C 相低侧

// 使能引脚 (可选，如果使用需接高电平使能)
const int EN = 8;

void setup() {
 // 初始化所有引脚为输出
 pinMode(IN1_A, OUTPUT); pinMode(IN2_A, OUTPUT);
 pinMode(IN1_B, OUTPUT); pinMode(IN2_B, OUTPUT);
 pinMode(IN1_C, OUTPUT); pinMode(IN2_C, OUTPUT);
 pinMode(EN, OUTPUT);
 
 // 使能驱动器
 digitalWrite(EN, HIGH);
 
 Serial.begin(9600);
 Serial.println("L6234 Full-Bridge Driver Control Ready.");
 
 // 初始停止所有相
 stopAllPhases();
 delay(1000);
}

void loop() {
 // 示例：简单的六步换相演示 (开环控制)
 // 步序 1: 激励 A+ B-
 Serial.println("Step 1: A+ B-");
 setPhaseA(HIGH, 200);  // A 相高侧 PWM=200, 低侧关断
 setPhaseB(LOW, 200);   // B 相低侧 PWM=200, 高侧关断
 setPhaseC(OFF, 0);     // C 相关断
 delay(2000);
 
 // 步序 2: 激励 A+ C-
 Serial.println("Step 2: A+ C-");
 setPhaseA(HIGH, 200);
 setPhaseC(LOW, 200);
 setPhaseB(OFF, 0);
 delay(2000);
 
 // 以此类推... 循环 6 步
}

// --- 封装好的相位控制函数 ---
// 设置 A 相状态
void setPhaseA(bool highSide, int pwmValue) {
 if (highSide) {
   analogWrite(IN1_A, pwmValue);
   digitalWrite(IN2_A, LOW); // 必须确保高低侧不同时导通
 } else {
   digitalWrite(IN1_A, LOW);
   analogWrite(IN2_A, pwmValue);
 }
}

void setPhaseB(bool highSide, int pwmValue) {
 if (highSide) {
   analogWrite(IN1_B, pwmValue);
   digitalWrite(IN2_B, LOW);
 } else {
   digitalWrite(IN1_B, LOW);
   analogWrite(IN2_B, pwmValue);
 }
}

void setPhaseC(bool highSide, int pwmValue) {
 if (highSide) {
   analogWrite(IN1_C, pwmValue);
   digitalWrite(IN2_C, LOW);
 } else {
   digitalWrite(IN1_C, LOW);
   analogWrite(IN2_C, pwmValue);
 }
}

// 关闭一相
void setPhaseOff(int phase) {
 // 将所有输入置低，MOSFET 全部关断
 digitalWrite(IN1_A, LOW); digitalWrite(IN2_A, LOW);
 digitalWrite(IN1_B, LOW); digitalWrite(IN2_B, LOW);
 digitalWrite(IN1_C, LOW); digitalWrite(IN2_C, LOW);
}

void stopAllPhases() {
 setPhaseOff(0);
}

// 定义 DRV8302 SPI 引脚
#include <SPI.h>

const int csPin = 10; // 片选引脚
const int enablePin = 9; // 使能引脚

// DRV8302 寄存器地址
#define DRV8302_CTRL1 0x00
#define DRV8302_CTRL2 0x01

void setup() {
  pinMode(csPin, OUTPUT);
  pinMode(enablePin, OUTPUT);
  digitalWrite(csPin, HIGH);
  digitalWrite(enablePin, LOW); // 先禁用
  
  SPI.begin();
  SPI.setDataMode(SPI_MODE1); // DRV8302 使用模式1
  SPI.setBitOrder(MSBFIRST);
  
  Serial.begin(9600);
  
  // 初始化 DRV8302
  initDRV8302();
  
  // 使能驱动器
  digitalWrite(enablePin, HIGH);
  delay(10);
}

void loop() {
  // DRV8302 通常与 FOC 算法配合使用
  // 这里仅演示 SPI 读写
  readFaultStatus(); // 读取故障状态
  
  delay(1000);
}

// 初始化 DRV8302 寄存器
void initDRV8302() {
  // 配置控制寄存器 1
  // 设置 PWM 模式、死区时间等
  writeRegister(DRV8302_CTRL1, 0b0001000000000000); 
  
  // 配置控制寄存器 2
  // 设置过流保护阈值等
  writeRegister(DRV8302_CTRL2, 0b0010000000000000);
}

// 写入寄存器
void writeRegister(byte addr, unsigned int data) {
  digitalWrite(csPin, LOW);
  SPI.transfer((addr << 2) | 0x01); // 写入命令：地址左移2位 + 读写位(1)
  SPI.transfer((data >> 8) & 0xFF);  // 高字节
  SPI.transfer(data & 0xFF);        // 低字节
  digitalWrite(csPin, HIGH);
  delayMicroseconds(10);
}

// 读取寄存器
unsigned int readRegister(byte addr) {
  digitalWrite(csPin, LOW);
  SPI.transfer(addr << 2); // 读取命令：地址左移2位 + 读写位(0)
  byte highByte = SPI.transfer(0x00);
  byte lowByte = SPI.transfer(0x00);
  digitalWrite(csPin, HIGH);
  return (highByte << 8) | lowByte;
}

// 读取故障状态
void readFaultStatus() {
  unsigned int status = readRegister(0x02); // 状态寄存器地址
  if (status & 0x0001) Serial.println("Overcurrent Fault!");
  if (status & 0x0002) Serial.println("Overvoltage Fault!");
  if (status & 0x0004) Serial.println("Overtemperature Fault!");
}

// TB6605 控制引脚（模拟 BLDC 三相输出）
const int phaseA = 9;  // A 相 PWM
const int phaseB = 10; // B 相 PWM
const int phaseC = 11; // C 相 PWM

// 换相表（120度导通模式）
int pwmValues[6][3] = {
  {255, 0, 0},   // 步0: A+ B- C off
  {255, 0, 0},   // 步1: A+ C- B off
  {0, 255, 0},   // 步2: B+ C- A off
  {0, 255, 0},   // 步3: B+ A- C off
  {0, 0, 255},   // 步4: C+ A- B off
  {0, 0, 255}    // 步5: C+ B- A off
};

int currentStep = 0;
unsigned long lastStepTime = 0;
int stepDelay = 5; // 速度控制

void setup() {
  pinMode(phaseA, OUTPUT);
  pinMode(phaseB, OUTPUT);
  pinMode(phaseC, OUTPUT);
  
  Serial.begin(9600);
  Serial.println("TB6605 BLDC Simulation Ready.");
}

void loop() {
  if (millis() - lastStepTime > stepDelay) {
    lastStepTime = millis();
    
    // 输出当前步的 PWM 值
    analogWrite(phaseA, pwmValues[currentStep][0]);
    analogWrite(phaseB, pwmValues[currentStep][1]);
    analogWrite(phaseC, pwmValues[currentStep][2]);
    
    currentStep = (currentStep + 1) % 6;
  }
  
  // 调整速度
  if (Serial.available()) {
    int newSpeed = Serial.parseInt();
    if (newSpeed > 0) stepDelay = 20 - newSpeed; // 简单映射
    Serial.print("Speed adjusted, delay: "); Serial.println(stepDelay);
  }
}

#include <Arduino.h>

// L6234引脚定义
#define IN1 5   // PWM相位1
#define IN2 6   // PWM相位2
#define IN3 7   // PWM相位3
#define EN 8    // 使能引脚
#define FAULT 9 // 故障检测（低电平有效）

void setup() {
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(IN3, OUTPUT);
  pinMode(EN, OUTPUT);
  pinMode(FAULT, INPUT_PULLUP);

  digitalWrite(EN, HIGH); // 使能驱动器
  Serial.begin(9600);
}

void loop() {
  // 检测故障
  if (digitalRead(FAULT) == LOW) {
    Serial.println("故障：过流或过热！");
    digitalWrite(EN, LOW); // 关闭驱动器
    while (1); // 停机
  }

  // 生成PWM信号（简化：实际需换相逻辑）
  analogWrite(IN1, 100); // 相位1 PWM占空比
  analogWrite(IN2, 0);   // 相位2关闭
  analogWrite(IN3, 0);   // 相位3关闭
  delay(1000);

  // 切换相位（模拟换相）
  analogWrite(IN1, 0);
  analogWrite(IN2, 150);
  delay(1000);
}

#include <SPI.h>

// DRV8302引脚定义
#define PWM_A 5
#define PWM_B 6
#define PWM_C 7
#define ENABLE 8
#define FAULT 9
#define CS 10    // SPI片选
#define OCTW 4   // 过流/过温警告

// SPI配置
SPISettings spiSettings(1000000, MSBFIRST, SPI_MODE1);

void setup() {
  pinMode(PWM_A, OUTPUT);
  pinMode(PWM_B, OUTPUT);
  pinMode(PWM_C, OUTPUT);
  pinMode(ENABLE, OUTPUT);
  pinMode(FAULT, INPUT);
  pinMode(OCTW, INPUT);
  pinMode(CS, OUTPUT);

  digitalWrite(ENABLE, HIGH);
  SPI.begin();
  Serial.begin(9600);
}

void loop() {
  // 读取故障状态（通过SPI）
  uint16_t faultStatus = readDRV8302Register(0x01); // 假设0x01是故障寄存器
  if (faultStatus & 0x0001) {
    Serial.println("故障：过流！");
    digitalWrite(ENABLE, LOW);
    while (1);
  }

  // 生成PWM（简化：实际需FOC或换相逻辑）
  analogWrite(PWM_A, 120);
  analogWrite(PWM_B, 0);
  analogWrite(PWM_C, 0);
  delay(500);

  // 切换相位
  analogWrite(PWM_A, 0);
  analogWrite(PWM_B, 180);
  delay(500);
}

uint16_t readDRV8302Register(uint8_t addr) {
  digitalWrite(CS, LOW);
  SPI.beginTransaction(spiSettings);
  SPI.transfer(addr | 0x80); // 读命令
  uint16_t data = SPI.transfer16(0x0000);
  SPI.endTransaction();
  digitalWrite(CS, HIGH);
  return data;
}

// TB6605引脚定义
#define PWM 5
#define DIR 6
#define ENABLE 7
#define LOCK 8  // 锁转检测（低电平有效）

void setup() {
  pinMode(PWM, OUTPUT);
  pinMode(DIR, OUTPUT);
  pinMode(ENABLE, OUTPUT);
  pinMode(LOCK, INPUT_PULLUP);

  digitalWrite(ENABLE, HIGH);
  Serial.begin(9600);
}

void loop() {
  // 检测锁转
  if (digitalRead(LOCK) == LOW) {
    Serial.println("故障：电机锁转！");
    digitalWrite(ENABLE, LOW);
    while (1);
  }

  // 正转
  digitalWrite(DIR, HIGH);
  analogWrite(PWM, 150); // 50%占空比
  delay(2000);

  // 反转
  digitalWrite(DIR, LOW);
  delay(2000);
}