面向3相无感BLDC电机控制程序
一、系统架构设计
1.1 整体架构
┌─────────────────────────────────────────┐
│ 应用层 (Application) │
├─────────────────────────────────────────┤
│ 控制算法层 (Control Logic) │
│ ┌────────┬─────────┬──────────┐ │
│ │速度环 │ 电流环 │ 位置估算 │ │
│ └────────┴─────────┴──────────┘ │
├─────────────────────────────────────────┤
│ 换向控制层 (Commutation) │
│ ┌──────────────────────────────┐ │
│ │ 六步换向 │ FOC控制 │ 过零检测│ │
│ └──────────────────────────────┘ │
├─────────────────────────────────────────┤
│ 驱动层 (Driver) │
│ ┌────────┬────────┬──────────┐ │
│ │ PWM │ ADC │ 比较器 │ │
│ └────────┴────────┴──────────┘ │
├─────────────────────────────────────────┤
│ 硬件层 (Hardware) │
│ ┌────────┬────────┬──────────┐ │
│ │MOSFET │ 电流 │ 电源 │ │
│ │驱动 │ 采样 │ 管理 │ │
│ └────────┴────────┴──────────┘ │
└─────────────────────────────────────────┘
1.2 特性支持
- 无位置传感器控制
- 六步换向 (Trapezoidal)
- 磁场定向控制 (FOC)
- 软启动/软停止
- 过流/过压保护
- 堵转检测
- 转速/转矩控制
- 能量回收
二、硬件定义
2.1 引脚定义
// bldc_hw.h
#ifndef __BLDC_HW_H
#define __BLDC_HW_H
#include <stdint.h>
#include <stdbool.h>
// MCU平台定义
#ifdef STM32F1
#include "stm32f1xx_hal.h"
#elif STM32F4
#include "stm32f4xx_hal.h"
#elif ESP32
#include "driver/mcpwm.h"
#include "driver/gpio.h"
#endif
// 电机参数
typedef struct {
uint16_t pole_pairs; // 极对数
float phase_resistance; // 相电阻 (Ω)
float phase_inductance; // 相电感 (H)
float kv_rating; // KV值 (RPM/V)
float max_current; // 最大电流 (A)
float max_voltage; // 最大电压 (V)
} Motor_Params;
// PWM引脚定义
typedef struct {
// 高侧MOSFET PWM引脚
uint16_t uh_pin; // U相高侧
uint16_t vh_pin; // V相高侧
uint16_t wh_pin; // W相高侧
// 低侧MOSFET使能引脚
uint16_t ul_pin; // U相低侧
uint16_t vl_pin; // V相低侧
uint16_t wl_pin; // W相低侧
} PWM_Pins;
// ADC通道定义
typedef struct {
uint16_t phase_u_adc; // U相电流采样
uint16_t phase_v_adc; // V相电流采样
uint16_t phase_w_adc; // W相电流采样
uint16_t bus_voltage; // 母线电压
uint16_t temp_adc; // 温度检测
} ADC_Channels;
// 比较器引脚
typedef struct {
uint16_t comp_u_pin; // U相反电动势比较
uint16_t comp_v_pin; // V相反电动势比较
uint16_t comp_w_pin; // W相反电动势比较
} Comparator_Pins;
// 保护阈值
typedef struct {
float overcurrent_threshold; // 过流阈值 (A)
float undervoltage_threshold; // 欠压阈值 (V)
float overvoltage_threshold; // 过压阈值 (V)
float overtemperature_threshold; // 过温阈值 (°C)
uint16_t stall_timeout_ms; // 堵转超时 (ms)
} Protection_Thresholds;
// 硬件配置结构
typedef struct {
PWM_Pins pwm_pins;
ADC_Channels adc_channels;
Comparator_Pins comp_pins;
Motor_Params motor_params;
Protection_Thresholds protection;
// PWM频率
uint32_t pwm_frequency_hz;
// ADC分辨率
uint16_t adc_resolution;
float adc_reference_voltage;
// 电流采样参数
float current_scale; // 电流采样系数 (A/V)
float shunt_resistance; // 采样电阻 (Ω)
} BLDC_HW_Config;
#endif
三、核心控制算法
3.1 无感BLDC控制主程序
// bldc_core.h
#ifndef __BLDC_CORE_H
#define __BLDC_CORE_H
#include "bldc_hw.h"
// 控制模式
typedef enum {
CONTROL_MODE_SPEED = 0, // 速度控制
CONTROL_MODE_TORQUE = 1, // 转矩控制
CONTROL_MODE_OPEN_LOOP = 2, // 开环控制
CONTROL_MODE_STOP = 3 // 停止
} Control_Mode;
// 运行状态
typedef enum {
STATE_INIT = 0, // 初始化
STATE_ALIGN = 1, // 定位
STATE_OPENLOOP_START = 2, // 开环启动
STATE_CLOSEDLOOP = 3, // 闭环运行
STATE_STOP = 4, // 停止
STATE_FAULT = 5 // 故障
} Motor_State;
// 换相状态
typedef enum {
COMM_STATE_0 = 0, // A+ B- C off
COMM_STATE_1 = 1, // A+ B off C-
COMM_STATE_2 = 2, // A off B+ C-
COMM_STATE_3 = 3, // A- B+ C off
COMM_STATE_4 = 4, // A- B off C+
COMM_STATE_5 = 5, // A off B- C+
COMM_STATE_COAST = 6 // 所有关断
} Commutation_State;
// PI控制器结构
typedef struct {
float kp; // 比例系数
float ki; // 积分系数
float integral; // 积分项
float integral_max; // 积分限幅
float output_max; // 输出限幅
float output_min; // 输出下限
float error; // 当前误差
float output; // 当前输出
} PI_Controller;
// 电机控制结构
typedef struct {
// 控制模式
Control_Mode control_mode;
Motor_State state;
// 目标值
float target_speed_rpm; // 目标转速 (RPM)
float target_torque_nm; // 目标转矩 (N·m)
float target_current_a; // 目标电流 (A)
// 实际值
float actual_speed_rpm; // 实际转速
float actual_speed_radps; // 实际角速度 (rad/s)
float electrical_angle; // 电角度 (rad)
float mechanical_angle; // 机械角度 (rad)
float phase_current_u; // U相电流
float phase_current_v; // V相电流
float phase_current_w; // W相电流
float bus_voltage; // 母线电压
float temperature; // 温度
// 控制器
PI_Controller speed_pi; // 速度环PI
PI_Controller current_pi; // 电流环PI
// 换向参数
Commutation_State comm_state;
uint32_t commutation_period_us; // 换相周期
uint32_t last_commutation_time; // 上次换相时间
uint8_t sector; // 扇区 (0-5)
// PWM占空比
float pwm_duty_u;
float pwm_duty_v;
float pwm_duty_w;
// 保护参数
uint32_t overcurrent_count;
uint32_t stall_start_time;
bool fault_overcurrent;
bool fault_undervoltage;
bool fault_overtemperature;
bool fault_stall;
// 启动参数
uint8_t start_stage;
uint32_t start_timer;
float openloop_speed;
float openloop_angle;
float align_current;
} BLDC_Controller;
// 函数声明
void BLDC_Init(BLDC_Controller* ctrl, const BLDC_HW_Config* hw_config);
void BLDC_Start(BLDC_Controller* ctrl);
void BLDC_Stop(BLDC_Controller* ctrl);
void BLDC_SetSpeed(BLDC_Controller* ctrl, float rpm);
void BLDC_SetTorque(BLDC_Controller* ctrl, float torque);
void BLDC_ControlLoop(BLDC_Controller* ctrl);
void BLDC_FaultHandler(BLDC_Controller* ctrl, uint8_t fault_code);
float BLDC_EstimateSpeed(BLDC_Controller* ctrl);
float BLDC_EstimateAngle(BLDC_Controller* ctrl);
void BLDC_ProtectionCheck(BLDC_Controller* ctrl);
#endif
3.2 核心控制实现
// bldc_core.c
#include "bldc_core.h"
#include "math.h"
#include <string.h>
// 全局变量
static BLDC_HW_Config hw_config;
static uint32_t system_tick = 0;
// PI控制器更新
static float PI_Update(PI_Controller* pi, float setpoint, float feedback, float dt) {
pi->error = setpoint - feedback;
// 积分项
pi->integral += pi->error * pi->ki * dt;
// 积分限幅
if (pi->integral > pi->integral_max) {
pi->integral = pi->integral_max;
} else if (pi->integral < -pi->integral_max) {
pi->integral = -pi->integral_max;
}
// 计算输出
pi->output = pi->error * pi->kp + pi->integral;
// 输出限幅
if (pi->output > pi->output_max) {
pi->output = pi->output_max;
} else if (pi->output < pi->output_min) {
pi->output = pi->output_min;
}
return pi->output;
}
// 初始化BLDC控制器
void BLDC_Init(BLDC_Controller* ctrl, const BLDC_HW_Config* config) {
if (!ctrl || !config) return;
// 复制硬件配置
memcpy(&hw_config, config, sizeof(BLDC_HW_Config));
// 初始化控制器
memset(ctrl, 0, sizeof(BLDC_Controller));
ctrl->control_mode = CONTROL_MODE_SPEED;
ctrl->state = STATE_INIT;
ctrl->comm_state = COMM_STATE_COAST;
// 初始化PI控制器参数
// 速度环PI
ctrl->speed_pi.kp = 0.1f;
ctrl->speed_pi.ki = 0.01f;
ctrl->speed_pi.integral_max = 100.0f;
ctrl->speed_pi.output_max = 1.0f; // 最大占空比
ctrl->speed_pi.output_min = 0.0f;
// 电流环PI
ctrl->current_pi.kp = 0.5f;
ctrl->current_pi.ki = 0.1f;
ctrl->current_pi.integral_max = 5.0f;
ctrl->current_pi.output_max = 1.0f;
ctrl->current_pi.output_min = 0.0f;
// 初始化PWM
PWM_Init(config->pwm_frequency_hz);
// 初始化ADC
ADC_Init();
// 初始化比较器
Comparator_Init();
// 初始化GPIO
GPIO_Init();
}
// 启动电机
void BLDC_Start(BLDC_Controller* ctrl) {
if (ctrl->state == STATE_STOP || ctrl->state == STATE_INIT) {
ctrl->state = STATE_ALIGN;
ctrl->start_stage = 0;
ctrl->start_timer = system_tick;
ctrl->openloop_speed = 0;
ctrl->openloop_angle = 0;
printf("Motor starting...\n");
}
}
// 停止电机
void BLDC_Stop(BLDC_Controller* ctrl) {
ctrl->state = STATE_STOP;
ctrl->control_mode = CONTROL_MODE_STOP;
// 关闭所有PWM输出
PWM_SetDuty(0, 0, 0);
PWM_Disable();
// 复位控制器
ctrl->speed_pi.integral = 0;
ctrl->current_pi.integral = 0;
printf("Motor stopped.\n");
}
// 设置目标转速
void BLDC_SetSpeed(BLDC_Controller* ctrl, float rpm) {
if (ctrl->control_mode != CONTROL_MODE_SPEED) {
ctrl->control_mode = CONTROL_MODE_SPEED;
}
// 速度限幅
float max_rpm = hw_config.motor_params.kv_rating * hw_config.motor_params.max_voltage;
if (rpm > max_rpm) rpm = max_rpm;
if (rpm < -max_rpm) rpm = -max_rpm;
ctrl->target_speed_rpm = rpm;
}
// 设置目标转矩
void BLDC_SetTorque(BLDC_Controller* ctrl, float torque) {
if (ctrl->control_mode != CONTROL_MODE_TORQUE) {
ctrl->control_mode = CONTROL_MODE_TORQUE;
}
// 转矩限幅
float max_torque = hw_config.motor_params.max_current * 1.5f; // 简单估算
if (torque > max_torque) torque = max_torque;
if (torque < -max_torque) torque = -max_torque;
ctrl->target_torque_nm = torque;
}
// 主控制循环 (1kHz执行)
void BLDC_ControlLoop(BLDC_Controller* ctrl) {
static uint32_t last_control_time = 0;
uint32_t current_time = system_tick;
float dt = (current_time - last_control_time) / 1000.0f; // 转换为秒
if (dt < 0.001f) return; // 至少1ms执行一次
// 保护检查
BLDC_ProtectionCheck(ctrl);
if (ctrl->state == STATE_FAULT) {
return;
}
// 状态机处理
switch (ctrl->state) {
case STATE_ALIGN:
State_Align(ctrl, dt);
break;
case STATE_OPENLOOP_START:
State_OpenLoopStart(ctrl, dt);
break;
case STATE_CLOSEDLOOP:
State_ClosedLoop(ctrl, dt);
break;
case STATE_STOP:
// 停止状态，关闭PWM
PWM_SetDuty(0, 0, 0);
break;
default:
break;
}
last_control_time = current_time;
}
// 定位状态
static void State_Align(BLDC_Controller* ctrl, float dt) {
static float align_angle = 0;
const uint32_t align_time_ms = 1000; // 定位1秒
if (ctrl->start_stage == 0) {
// 第一阶段：强制定位到0度
ctrl->openloop_angle = 0;
align_angle = 0;
// 施加定位电流
ctrl->align_current = hw_config.motor_params.max_current * 0.3f;
ctrl->start_timer = system_tick;
ctrl->start_stage = 1;
printf("Stage 1: Aligning rotor...\n");
}
if (ctrl->start_stage == 1) {
// 保持定位
if (system_tick - ctrl->start_timer >= align_time_ms) {
ctrl->start_stage = 2;
ctrl->start_timer = system_tick;
printf("Stage 2: Starting open loop...\n");
}
// 输出固定位置的PWM
BLDC_OpenLoopControl(ctrl, align_angle, ctrl->align_current);
}
if (ctrl->start_stage == 2) {
// 进入开环启动
ctrl->state = STATE_OPENLOOP_START;
ctrl->openloop_speed = 10.0f; // 初始速度 10 RPM
ctrl->start_stage = 0;
}
}
// 开环启动状态
static void State_OpenLoopStart(BLDC_Controller* ctrl, float dt) {
const float accel_rate = 50.0f; // 50 RPM/s
const float min_speed_for_closedloop = 100.0f; // 100 RPM
// 加速
ctrl->openloop_speed += accel_rate * dt;
// 更新开环角度
ctrl->openloop_angle += (ctrl->openloop_speed * 2 * M_PI / 60.0f) * dt;
if (ctrl->openloop_angle >= 2 * M_PI) {
ctrl->openloop_angle -= 2 * M_PI;
}
// 控制电流
float target_current = 0.5f; // 固定启动电流
BLDC_OpenLoopControl(ctrl, ctrl->openloop_angle, target_current);
// 尝试检测反电动势
if (ctrl->openloop_speed >= min_speed_for_closedloop) {
// 检查反电动势是否有效
if (BLDC_CheckBEMFValid(ctrl)) {
ctrl->state = STATE_CLOSEDLOOP;
printf("Switching to closed loop control.\n");
}
}
// 超时保护
if (ctrl->openloop_speed > 500.0f) { // 如果达到500RPM仍未切闭环
ctrl->state = STATE_FAULT;
ctrl->fault_stall = true;
printf("Startup timeout!\n");
}
}
// 闭环控制状态
static void State_ClosedLoop(BLDC_Controller* ctrl, float dt) {
// 估算速度和位置
ctrl->actual_speed_rpm = BLDC_EstimateSpeed(ctrl);
ctrl->electrical_angle = BLDC_EstimateAngle(ctrl);
// 根据控制模式计算目标电流
float target_current = 0;
switch (ctrl->control_mode) {
case CONTROL_MODE_SPEED: {
// 速度环PI控制
float speed_radps = ctrl->target_speed_rpm * 2 * M_PI / 60.0f;
float actual_speed_radps = ctrl->actual_speed_rpm * 2 * M_PI / 60.0f;
target_current = PI_Update(&ctrl->speed_pi, speed_radps, actual_speed_radps, dt);
break;
}
case CONTROL_MODE_TORQUE: {
// 转矩控制（简化为电流控制）
// 假设转矩常数 Kt = 60 / (2π * KV)
float kt = 60.0f / (2 * M_PI * hw_config.motor_params.kv_rating);
target_current = ctrl->target_torque_nm / kt;
break;
}
case CONTROL_MODE_OPEN_LOOP:
// 开环控制
target_current = ctrl->target_current_a;
break;
default:
break;
}
// 电流限幅
if (target_current > hw_config.motor_params.max_current) {
target_current = hw_config.motor_params.max_current;
} else if (target_current < -hw_config.motor_params.max_current) {
target_current = -hw_config.motor_params.max_current;
}
// 执行电流控制
BLDC_CurrentControl(ctrl, target_current, dt);
}
// 开环控制
static void BLDC_OpenLoopControl(BLDC_Controller* ctrl, float angle, float current) {
// 生成三相PWM占空比
float u = current * sinf(angle);
float v = current * sinf(angle + 2 * M_PI / 3);
float w = current * sinf(angle + 4 * M_PI / 3);
// 设置PWM占空比
ctrl->pwm_duty_u = (u + 1.0f) / 2.0f;
ctrl->pwm_duty_v = (v + 1.0f) / 2.0f;
ctrl->pwm_duty_w = (w + 1.0f) / 2.0f;
// 更新PWM输出
PWM_SetDuty(ctrl->pwm_duty_u, ctrl->pwm_duty_v, ctrl->pwm_duty_w);
}
// 电流闭环控制
static void BLDC_CurrentControl(BLDC_Controller* ctrl, float target_current, float dt) {
// 读取相电流
ctrl->phase_current_u = ADC_GetCurrentU();
ctrl->phase_current_v = ADC_GetCurrentV();
// 计算第三相电流（基尔霍夫定律）
ctrl->phase_current_w = -(ctrl->phase_current_u + ctrl->phase_current_v);
// 获取当前电角度
float angle = ctrl->electrical_angle;
// Clarke变换
float i_alpha = ctrl->phase_current_u;
float i_beta = (ctrl->phase_current_u + 2 * ctrl->phase_current_v) / sqrtf(3.0f);
// Park变换
float id = i_alpha * cosf(angle) + i_beta * sinf(angle);
float iq = -i_alpha * sinf(angle) + i_beta * cosf(angle);
// 电流环PI控制 (只控制q轴)
float vq = PI_Update(&ctrl->current_pi, target_current, iq, dt);
float vd = 0; // d轴电压设为0（最大转矩控制）
// 反Park变换
float valpha = vd * cosf(angle) - vq * sinf(angle);
float vbeta = vd * sinf(angle) + vq * cosf(angle);
// 反Clarke变换
float vu = valpha;
float vv = -0.5f * valpha + 0.8660254f * vbeta; // √3/2
float vw = -0.5f * valpha - 0.8660254f * vbeta;
// 计算占空比
ctrl->pwm_duty_u = 0.5f + vu / (2.0f * ctrl->bus_voltage);
ctrl->pwm_duty_v = 0.5f + vv / (2.0f * ctrl->bus_voltage);
ctrl->pwm_duty_w = 0.5f + vw / (2.0f * ctrl->bus_voltage);
// 限制占空比
ctrl->pwm_duty_u = fminf(fmaxf(ctrl->pwm_duty_u, 0.0f), 1.0f);
ctrl->pwm_duty_v = fminf(fmaxf(ctrl->pwm_duty_v, 0.0f), 1.0f);
ctrl->pwm_duty_w = fminf(fmaxf(ctrl->pwm_duty_w, 0.0f), 1.0f);
// 更新PWM输出
PWM_SetDuty(ctrl->pwm_duty_u, ctrl->pwm_duty_v, ctrl->pwm_duty_w);
}
// 保护检查
void BLDC_ProtectionCheck(BLDC_Controller* ctrl) {
// 过流保护
float max_current = fmaxf(fabsf(ctrl->phase_current_u),
fmaxf(fabsf(ctrl->phase_current_v),
fabsf(ctrl->phase_current_w)));
if (max_current > hw_config.protection.overcurrent_threshold) {
ctrl->overcurrent_count++;
if (ctrl->overcurrent_count > 5) { // 连续5次过流
ctrl->fault_overcurrent = true;
ctrl->state = STATE_FAULT;
}
} else {
ctrl->overcurrent_count = 0;
}
// 欠压保护
if (ctrl->bus_voltage < hw_config.protection.undervoltage_threshold) {
ctrl->fault_undervoltage = true;
ctrl->state = STATE_FAULT;
}
// 过压保护
if (ctrl->bus_voltage > hw_config.protection.overvoltage_threshold) {
ctrl->state = STATE_FAULT;
}
// 过温保护
if (ctrl->temperature > hw_config.protection.overtemperature_threshold) {
ctrl->fault_overtemperature = true;
ctrl->state = STATE_FAULT;
}
// 堵转检测
if (ctrl->state == STATE_CLOSEDLOOP) {
float speed_threshold = 10.0f; // 10 RPM
if (fabsf(ctrl->actual_speed_rpm) < speed_threshold) {
if (ctrl->stall_start_time == 0) {
ctrl->stall_start_time = system_tick;
} else if (system_tick - ctrl->stall_start_time > hw_config.protection.stall_timeout_ms) {
ctrl->fault_stall = true;
ctrl->state = STATE_FAULT;
}
} else {
ctrl->stall_start_time = 0;
}
}
// 故障处理
if (ctrl->state == STATE_FAULT) {
BLDC_FaultHandler(ctrl, 0);
}
}
四、位置和速度估算
4.1 反电动势过零检测
// bemf_sensor.h
#ifndef __BEMF_SENSOR_H
#define __BEMF_SENSOR_H
#include "bldc_core.h"
// 反电动势状态
typedef struct {
float bemf_u; // U相反电动势
float bemf_v; // V相反电动势
float bemf_w; // W相反电动势
float bemf_u_filtered; // 滤波后U相反电动势
float bemf_v_filtered; // 滤波后V相反电动势
float bemf_w_filtered; // 滤波后W相反电动势
uint8_t zc_u; // U相过零点检测
uint8_t zc_v; // V相过零点检测
uint8_t zc_w; // W相过零点检测
uint32_t zc_time; // 过零点时间
uint32_t zc_period; // 过零点周期
float bemf_amplitude; // 反电动势幅值
float bemf_frequency; // 反电动势频率
} BEMF_Sensor;
// 函数声明
void BEMF_Init(BEMF_Sensor* sensor);
void BEMF_Update(BEMF_Sensor* sensor, BLDC_Controller* ctrl);
float BEMF_EstimateSpeed(BEMF_Sensor* sensor);
float BEMF_EstimateAngle(BEMF_Sensor* sensor);
uint8_t BEMF_GetSector(BEMF_Sensor* sensor);
bool BEMF_CheckValid(BEMF_Sensor* sensor);
#endif
// bemf_sensor.c
#include "bemf_sensor.h"
#include "math.h"
#define BEMF_FILTER_COEFF 0.1f
#define ZC_THRESHOLD 0.1f // 过零阈值
static BEMF_Sensor bemf_sensor;
void BEMF_Init(BEMF_Sensor* sensor) {
memset(sensor, 0, sizeof(BEMF_Sensor));
}
void BEMF_Update(BEMF_Sensor* sensor, BLDC_Controller* ctrl) {
// 读取比较器状态
uint8_t comp_u = Comparator_GetState(hw_config.comp_pins.comp_u_pin);
uint8_t comp_v = Comparator_GetState(hw_config.comp_pins.comp_v_pin);
uint8_t comp_w = Comparator_GetState(hw_config.comp_pins.comp_w_pin);
// 获取当前换相状态
Commutation_State comm_state = ctrl->comm_state;
// 根据换相状态选择检测的反电动势
switch (comm_state) {
case COMM_STATE_0: // A+B-: 检测C相
sensor->bemf_w = GetPhaseVoltage(C_PHASE) - GetNeutralVoltage();
break;
case COMM_STATE_1: // A+C-: 检测B相
sensor->bemf_v = GetPhaseVoltage(B_PHASE) - GetNeutralVoltage();
break;
case COMM_STATE_2: // B+C-: 检测A相
sensor->bemf_u = GetPhaseVoltage(A_PHASE) - GetNeutralVoltage();
break;
case COMM_STATE_3: // B+A-: 检测C相
sensor->bemf_w = GetPhaseVoltage(C_PHASE) - GetNeutralVoltage();
break;
case COMM_STATE_4: // C+A-: 检测B相
sensor->bemf_v = GetPhaseVoltage(B_PHASE) - GetNeutralVoltage();
break;
case COMM_STATE_5: // C+B-: 检测A相
sensor->bemf_u = GetPhaseVoltage(A_PHASE) - GetNeutralVoltage();
break;
default:
break;
}
// 低通滤波
sensor->bemf_u_filtered = sensor->bemf_u_filtered * (1 - BEMF_FILTER_COEFF) +
sensor->bemf_u * BEMF_FILTER_COEFF;
sensor->bemf_v_filtered = sensor->bemf_v_filtered * (1 - BEMF_FILTER_COEFF) +
sensor->bemf_v * BEMF_FILTER_COEFF;
sensor->bemf_w_filtered = sensor->bemf_w_filtered * (1 - BEMF_FILTER_COEFF) +
sensor->bemf_w * BEMF_FILTER_COEFF;
// 检测过零点
static float prev_u = 0, prev_v = 0, prev_w = 0;
// U相过零检测
if ((prev_u > 0 && sensor->bemf_u_filtered <= 0) ||
(prev_u < 0 && sensor->bemf_u_filtered >= 0)) {
if (fabsf(sensor->bemf_u_filtered) < ZC_THRESHOLD) {
sensor->zc_u = 1;
sensor->zc_time = system_tick;
// 计算频率
static uint32_t last_zc_time = 0;
if (last_zc_time > 0) {
sensor->zc_period = sensor->zc_time - last_zc_time;
sensor->bemf_frequency = 1000000.0f / sensor->zc_period; // Hz
}
last_zc_time = sensor->zc_time;
}
} else {
sensor->zc_u = 0;
}
prev_u = sensor->bemf_u_filtered;
// 同样处理V相和W相...
}
float BEMF_EstimateSpeed(BEMF_Sensor* sensor) {
if (sensor->zc_period == 0) return 0;
// 电频率 = 1 / 过零周期
float electrical_freq_hz = 1000000.0f / sensor->zc_period;
// 机械转速 = 电频率 * 60 / 极对数
float speed_rpm = electrical_freq_hz * 60.0f / hw_config.motor_params.pole_pairs;
return speed_rpm;
}
float BEMF_EstimateAngle(BEMF_Sensor* sensor) {
if (sensor->zc_period == 0) return 0;
// 计算从上次过零点到现在的时间
uint32_t time_since_zc = system_tick - sensor->zc_time;
// 计算电角度
float angle = 2 * M_PI * time_since_zc / sensor->zc_period;
// 限制在0-2π之间
if (angle > 2 * M_PI) {
angle -= 2 * M_PI;
}
return angle;
}
uint8_t BEMF_GetSector(BEMF_Sensor* sensor) {
// 根据反电动势极性判断扇区
if (sensor->bemf_u_filtered > 0 && sensor->bemf_v_filtered < 0 && sensor->bemf_w_filtered < 0) {
return 0; // 扇区1
} else if (sensor->bemf_u_filtering > 0 && sensor->bemf_v_filtered > 0 && sensor->bemf_w_filtered < 0) {
return 1; // 扇区2
} else if (sensor->bemf_u_filtered < 0 && sensor->bemf_v_filtered > 0 && sensor->bemf_w_filtered < 0) {
return 2; // 扇区3
} else if (sensor->bemf_u_filtered < 0 && sensor->bemf_v_filtered > 0 && sensor->bemf_w_filtered > 0) {
return 3; // 扇区4
} else if (sensor->bemf_u_filtered < 0 && sensor->bemf_v_filtered < 0 && sensor->bemf_w_filtered > 0) {
return 4; // 扇区5
} else if (sensor->bemf_u_filtered > 0 && sensor->bemf_v_filtered < 0 && sensor->bemf_w_filtered > 0) {
return 5; // 扇区6
}
return 0;
}
bool BEMF_CheckValid(BEMF_Sensor* sensor) {
// 检查反电动势是否有效
if (sensor->zc_period == 0) return false;
// 检查频率是否在合理范围内
float freq = 1000000.0f / sensor->zc_period;
if (freq < 1.0f || freq > 1000.0f) { // 1Hz - 1kHz
return false;
}
// 检查幅值
float amplitude = fmaxf(fabsf(sensor->bemf_u_filtered),
fmaxf(fabsf(sensor->bemf_v_filtered),
fabsf(sensor->bemf_w_filtered)));
if (amplitude < 0.1f) { // 最小幅值
return false;
}
return true;
}
五、六步换向控制
5.1 换向控制器
// six_step_commutation.h
#ifndef __SIX_STEP_COMMUTATION_H
#define __SIX_STEP_COMMUTATION_H
#include "bldc_core.h"
// 六步换向表
typedef struct {
Commutation_State state;
uint8_t uh_enable; // U相高侧
uint8_t vh_enable; // V相高侧
uint8_t wh_enable; // W相高侧
uint8_t ul_enable; // U相低侧
uint8_t vl_enable; // V相低侧
uint8_t wl_enable; // W相低侧
} Commutation_Table;
// 换向控制器
typedef struct {
Commutation_State current_state;
Commutation_State next_state;
uint8_t sector;
uint32_t commutation_time;
uint32_t phase_advance_us; // 相位超前补偿
float duty_cycle;
} SixStep_Controller;
// 函数声明
void SixStep_Init(SixStep_Controller* ctrl);
void SixStep_SetState(SixStep_Controller* ctrl, Commutation_State state, float duty);
void SixStep_NextState(SixStep_Controller* ctrl, uint8_t direction);
void SixStep_ApplyPWM(SixStep_Controller* ctrl);
Commutation_State SixStep_GetStateFromSector(uint8_t sector, uint8_t direction);
void SixStep_UpdateFromBEMF(SixStep_Controller* ctrl, BEMF_Sensor* bemf, uint8_t direction);
#endif
// six_step_commutation.c
#include "six_step_commutation.h"
// 六步换向表（顺时针方向）
static const Commutation_Table comm_table_cw[6] = {
// 状态 UH UL VH VL WH WL
{COMM_STATE_0, 1, 0, 0, 1, 0, 0}, // A+B-
{COMM_STATE_1, 1, 0, 0, 0, 0, 1}, // A+C-
{COMM_STATE_2, 0, 0, 1, 0, 0, 1}, // B+C-
{COMM_STATE_3, 0, 1, 1, 0, 0, 0}, // B+A-
{COMM_STATE_4, 0, 1, 0, 0, 1, 0}, // C+A-
{COMM_STATE_5, 0, 0, 0, 1, 1, 0} // C+B-
};
// 六步换向表（逆时针方向）
static const Commutation_Table comm_table_ccw[6] = {
{COMM_STATE_5, 0, 0, 0, 1, 1, 0}, // C+B-
{COMM_STATE_4, 0, 1, 0, 0, 1, 0}, // C+A-
{COMM_STATE_3, 0, 1, 1, 0, 0, 0}, // B+A-
{COMM_STATE_2, 0, 0, 1, 0, 0, 1}, // B+C-
{COMM_STATE_1, 1, 0, 0, 0, 0, 1}, // A+C-
{COMM_STATE_0, 1, 0, 0, 1, 0, 0} // A+B-
};
void SixStep_Init(SixStep_Controller* ctrl) {
ctrl->current_state = COMM_STATE_0;
ctrl->next_state = COMM_STATE_1;
ctrl->sector = 0;
ctrl->commutation_time = 0;
ctrl->phase_advance_us = 0;
ctrl->duty_cycle = 0;
}
void SixStep_SetState(SixStep_Controller* ctrl, Commutation_State state, float duty) {
ctrl->current_state = state;
ctrl->duty_cycle = duty;
// 获取换向表
const Commutation_Table* table = &comm_table_cw[state];
// 设置PWM输出
if (table->uh_enable) {
PWM_SetDutyU(duty);
GPIO_SetHigh(hw_config.pwm_pins.uh_pin);
} else {
PWM_SetDutyU(0);
GPIO_SetLow(hw_config.pwm_pins.uh_pin);
}
if (table->ul_enable) {
GPIO_SetHigh(hw_config.pwm_pins.ul_pin);
} else {
GPIO_SetLow(hw_config.pwm_pins.ul_pin);
}
if (table->vh_enable) {
PWM_SetDutyV(duty);
GPIO_SetHigh(hw_config.pwm_pins.vh_pin);
} else {
PWM_SetDutyV(0);
GPIO_SetLow(hw_config.pwm_pins.vh_pin);
}
if (table->vl_enable) {
GPIO_SetHigh(hw_config.pwm_pins.vl_pin);
} else {
GPIO_SetLow(hw_config.pwm_pins.vl_pin);
}
if (table->wh_enable) {
PWM_SetDutyW(duty);
GPIO_SetHigh(hw_config.pwm_pins.wh_pin);
} else {
PWM_SetDutyW(0);
GPIO_SetLow(hw_config.pwm_pins.wh_pin);
}
if (table->wl_enable) {
GPIO_SetHigh(hw_config.pwm_pins.wl_pin);
} else {
GPIO_SetLow(hw_config.pwm_pins.wl_pin);
}
ctrl->commutation_time = system_tick;
}
void SixStep_NextState(SixStep_Controller* ctrl, uint8_t direction) {
// 计算下一个状态
Commutation_State next_state = (ctrl->current_state + 1) % 6;
if (direction == 0) { // 顺时针
SixStep_SetState(ctrl, next_state, ctrl->duty_cycle);
} else { // 逆时针
next_state = (ctrl->current_state - 1 + 6) % 6;
SixStep_SetState(ctrl, next_state, ctrl->duty_cycle);
}
}
void SixStep_ApplyPWM(SixStep_Controller* ctrl) {
SixStep_SetState(ctrl, ctrl->current_state, ctrl->duty_cycle);
}
Commutation_State SixStep_GetStateFromSector(uint8_t sector, uint8_t direction) {
if (direction == 0) { // 顺时针
return (Commutation_State)sector;
} else { // 逆时针
return (Commutation_State)((6 - sector) % 6);
}
}
void SixStep_UpdateFromBEMF(SixStep_Controller* ctrl, BEMF_Sensor* bemf, uint8_t direction) {
// 从BEMF获取扇区
uint8_t new_sector = BEMF_GetSector(bemf);
if (new_sector != ctrl->sector) {
ctrl->sector = new_sector;
// 获取对应的换向状态
Commutation_State new_state = SixStep_GetStateFromSector(new_sector, direction);
// 计算换向时间
uint32_t comm_period = bemf->zc_period * 3; // 每个扇区60度
uint32_t elapsed_time = system_tick - ctrl->commutation_time;
// 计算相位超前
uint32_t advance_time = ctrl->phase_advance_us;
// 如果时间到了，执行换向
if (elapsed_time >= (comm_period / 6 - advance_time)) {
SixStep_SetState(ctrl, new_state, ctrl->duty_cycle);
}
}
}
参考代码 面向3相无感BLDC控制控制程序 www.youwenfan.com/contentcnv/103317.html
六、PWM驱动实现
6.1 PWM驱动器
// pwm_driver.h
#ifndef __PWM_DRIVER_H
#define __PWM_DRIVER_H
#include "bldc_hw.h"
// PWM驱动结构
typedef struct {
uint32_t frequency_hz;
uint16_t resolution;
float deadtime_ns; // 死区时间
uint8_t polarity; // PWM极性
float max_duty; // 最大占空比
float min_duty; // 最小占空比
} PWM_Config;
// PWM驱动器
typedef struct {
PWM_Config config;
float duty_u;
float duty_v;
float duty_w;
uint8_t enabled;
} PWM_Driver;
// 函数声明
void PWM_InitDriver(PWM_Driver* driver, uint32_t freq_hz);
void PWM_SetFrequency(PWM_Driver* driver, uint32_t freq_hz);
void PWM_SetDeadtime(PWM_Driver* driver, float deadtime_ns);
void PWM_SetDuty(PWM_Driver* driver, float u, float v, float w);
void PWM_Enable(PWM_Driver* driver);
void PWM_Disable(PWM_Driver* driver);
void PWM_SetOutputs(uint8_t uh, uint8_t vh, uint8_t wh,
uint8_t ul, uint8_t vl, uint8_t wl);
#endif
// pwm_driver.c
#include "pwm_driver.h"
#include "stm32f4xx_hal.h"
// 全局PWM驱动器
static PWM_Driver pwm_driver;
static TIM_HandleTypeDef htim1;
void PWM_InitDriver(PWM_Driver* driver, uint32_t freq_hz) {
driver->config.frequency_hz = freq_hz;
driver->config.resolution = 1680; // 对于168MHz时钟，20kHz PWM的分辨率
driver->config.deadtime_ns = 1000; // 1us死区时间
driver->config.polarity = 1; // 高电平有效
driver->config.max_duty = 0.95f; // 最大95%占空比
driver->config.min_duty = 0.0f; // 最小0%占空比
driver->duty_u = 0;
driver->duty_v = 0;
driver->duty_w = 0;
driver->enabled = 0;
// 初始化定时器
TIM1_Init(freq_hz);
}
void PWM_SetFrequency(PWM_Driver* driver, uint32_t freq_hz) {
driver->config.frequency_hz = freq_hz;
// 重新配置定时器
// ...
}
void PWM_SetDeadtime(PWM_Driver* driver, float deadtime_ns) {
driver->config.deadtime_ns = deadtime_ns;
// 配置死区时间寄存器
// ...
}
void PWM_SetDuty(PWM_Driver* driver, float u, float v, float w) {
// 限制占空比范围
u = fmaxf(fminf(u, driver->config.max_duty), driver->config.min_duty);
v = fmaxf(fminf(v, driver->config.max_duty), driver->config.min_duty);
w = fmaxf(fminf(w, driver->config.max_duty), driver->config.min_duty);
driver->duty_u = u;
driver->duty_v = v;
driver->duty_w = w;
if (driver->enabled) {
// 计算比较值
uint32_t arr = __HAL_TIM_GET_AUTORELOAD(&htim1);
uint32_t ccr1 = (uint32_t)(u * arr);
uint32_t ccr2 = (uint32_t)(v * arr);
uint32_t ccr3 = (uint32_t)(w * arr);
// 设置比较寄存器
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_1, ccr1);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_2, ccr2);
__HAL_TIM_SET_COMPARE(&htim1, TIM_CHANNEL_3, ccr3);
}
}
void PWM_Enable(PWM_Driver* driver) {
driver->enabled = 1;
// 启动PWM输出
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_1);
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_2);
HAL_TIM_PWM_Start(&htim1, TIM_CHANNEL_3);
// 启动互补通道
HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_1);
HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_2);
HAL_TIMEx_PWMN_Start(&htim1, TIM_CHANNEL_3);
}
void PWM_Disable(PWM_Driver* driver) {
driver->enabled = 0;
// 停止PWM输出
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_1);
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_2);
HAL_TIM_PWM_Stop(&htim1, TIM_CHANNEL_3);
HAL_TIMEx_PWMN_Stop(&htim1, TIM_CHANNEL_1);
HAL_TIMEx_PWMN_Stop(&htim1, TIM_CHANNEL_2);
HAL_TIMEx_PWMN_Stop(&htim1, TIM_CHANNEL_3);
// 关闭所有MOSFET
GPIO_SetLow(hw_config.pwm_pins.uh_pin);
GPIO_SetLow(hw_config.pwm_pins.vh_pin);
GPIO_SetLow(hw_config.pwm_pins.wh_pin);
GPIO_SetLow(hw_config.pwm_pins.ul_pin);
GPIO_SetLow(hw_config.pwm_pins.vl_pin);
GPIO_SetLow(hw_config.pwm_pins.wl_pin);
}
void PWM_SetOutputs(uint8_t uh, uint8_t vh, uint8_t wh,
uint8_t ul, uint8_t vl, uint8_t wl) {
if (uh) GPIO_SetHigh(hw_config.pwm_pins.uh_pin);
else GPIO_SetLow(hw_config.pwm_pins.uh_pin);
if (vh) GPIO_SetHigh(hw_config.pwm_pins.vh_pin);
else GPIO_SetLow(hw_config.pwm_pins.vh_pin);
if (wh) GPIO_SetHigh(hw_config.pwm_pins.wh_pin);
else GPIO_SetLow(hw_config.pwm_pins.wh_pin);
if (ul) GPIO_SetHigh(hw_config.pwm_pins.ul_pin);
else GPIO_SetLow(hw_config.pwm_pins.ul_pin);
if (vl) GPIO_SetHigh(hw_config.pwm_pins.vl_pin);
else GPIO_SetLow(hw_config.pwm_pins.vl_pin);
if (wl) GPIO_SetHigh(hw_config.pwm_pins.wl_pin);
else GPIO_SetLow(hw_config.pwm_pins.wl_pin);
}
// STM32定时器1初始化
static void TIM1_Init(uint32_t freq_hz) {
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
TIM_OC_InitTypeDef sConfigOC = {0};
TIM_BreakDeadTimeConfigTypeDef sBreakDeadTimeConfig = {0};
// 计算预分频和自动重载值
uint32_t timer_clock = 168000000; // APB2时钟
uint32_t prescaler = 0;
uint32_t period = timer_clock / freq_hz - 1;
htim1.Instance = TIM1;
htim1.Init.Prescaler = prescaler;
htim1.Init.CounterMode = TIM_COUNTERMODE_CENTERALIGNED1; // 中心对齐模式
htim1.Init.Period = period;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.RepetitionCounter = 0;
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
if (HAL_TIM_Base_Init(&htim1) != HAL_OK) {
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig);
if (HAL_TIM_PWM_Init(&htim1) != HAL_OK) {
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig);
sConfigOC.OCMode = TIM_OCMODE_PWM1;
sConfigOC.Pulse = 0; // 初始占空比为0
sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
sConfigOC.OCNPolarity = TIM_OCNPOLARITY_HIGH;
sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
sConfigOC.OCIdleState = TIM_OCIDLESTATE_RESET;
sConfigOC.OCNIdleState = TIM_OCNIDLESTATE_RESET;
// 通道1-3配置
HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_1);
HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_2);
HAL_TIM_PWM_ConfigChannel(&htim1, &sConfigOC, TIM_CHANNEL_3);
// 死区时间配置
uint32_t deadtime = (pwm_driver.config.deadtime_ns * timer_clock) / 1000000000;
sBreakDeadTimeConfig.OffStateRunMode = TIM_OSSR_DISABLE;
sBreakDeadTimeConfig.OffStateIDLEMode = TIM_OSSI_DISABLE;
sBreakDeadTimeConfig.LockLevel = TIM_LOCKLEVEL_OFF;
sBreakDeadTimeConfig.DeadTime = deadtime;
sBreakDeadTimeConfig.BreakState = TIM_BREAK_DISABLE;
sBreakDeadTimeConfig.BreakPolarity = TIM_BREAKPOLARITY_HIGH;
sBreakDeadTimeConfig.AutomaticOutput = TIM_AUTOMATICOUTPUT_DISABLE;
HAL_TIMEx_ConfigBreakDeadTime(&htim1, &sBreakDeadTimeConfig);
}
七、应用示例
7.1 主应用程序
// main.c
#include "bldc_core.h"
#include "pwm_driver.h"
#include "bemf_sensor.h"
#include "six_step_commutation.h"
#include <stdio.h>
// 全局变量
static BLDC_Controller motor_ctrl;
static BEMF_Sensor bemf_sensor;
static SixStep_Controller sixstep_ctrl;
static PWM_Driver pwm_driver;
// 硬件配置
static BLDC_HW_Config hw_config = {
.pwm_pins = {
.uh_pin = GPIO_PIN_8, // TIM1_CH1
.vh_pin = GPIO_PIN_9, // TIM1_CH2
.wh_pin = GPIO_PIN_10, // TIM1_CH3
.ul_pin = GPIO_PIN_13, // TIM1_CH1N
.vl_pin = GPIO_PIN_14, // TIM1_CH2N
.wl_pin = GPIO_PIN_15, // TIM1_CH3N
},
.adc_channels = {
.phase_u_adc = ADC_CHANNEL_0,
.phase_v_adc = ADC_CHANNEL_1,
.phase_w_adc = ADC_CHANNEL_2,
.bus_voltage = ADC_CHANNEL_3,
.temp_adc = ADC_CHANNEL_4,
},
.comp_pins = {
.comp_u_pin = GPIO_PIN_0,
.comp_v_pin = GPIO_PIN_1,
.comp_w_pin = GPIO_PIN_2,
},
.motor_params = {
.pole_pairs = 7,
.phase_resistance = 0.1f,
.phase_inductance = 0.0001f,
.kv_rating = 1000.0f,
.max_current = 10.0f,
.max_voltage = 24.0f,
},
.protection = {
.overcurrent_threshold = 12.0f,
.undervoltage_threshold = 18.0f,
.overvoltage_threshold = 30.0f,
.overtemperature_threshold = 85.0f,
.stall_timeout_ms = 2000,
},
.pwm_frequency_hz = 20000,
.adc_resolution = 4096,
.adc_reference_voltage = 3.3f,
.current_scale = 10.0f, // 10A/V
.shunt_resistance = 0.01f,
};
// 系统定时器中断 (1kHz)
void SysTick_Handler(void) {
static uint32_t tick_counter = 0;
system_tick = tick_counter++;
// 读取ADC
ReadADCValues(&motor_ctrl);
// 更新BEMF检测
BEMF_Update(&bemf_sensor, &motor_ctrl);
// 执行控制循环
BLDC_ControlLoop(&motor_ctrl);
// 六步换向控制
if (motor_ctrl.state == STATE_CLOSEDLOOP) {
SixStep_UpdateFromBEMF(&sixstep_ctrl, &bemf_sensor, 0);
}
}
int main(void) {
// 系统初始化
SystemClock_Config();
HAL_Init();
// 初始化PWM驱动
PWM_InitDriver(&pwm_driver, hw_config.pwm_frequency_hz);
// 初始化BEMF检测
BEMF_Init(&bemf_sensor);
// 初始化六步换向
SixStep_Init(&sixstep_ctrl);
// 初始化BLDC控制器
BLDC_Init(&motor_ctrl, &hw_config);
// 初始化系统定时器 (1kHz)
HAL_SYSTICK_Config(SystemCoreClock / 1000);
HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
printf("BLDC Controller Initialized.\n");
// 主循环
while (1) {
// 处理用户输入
HandleUserInput();
// 更新状态显示
UpdateStatusDisplay();
// 监控任务
if (motor_ctrl.state == STATE_FAULT) {
HandleFault(&motor_ctrl);
}
HAL_Delay(10);
}
}
// 处理用户输入
void HandleUserInput(void) {
// 这里可以处理串口命令、按键等
// 示例：通过串口控制
if (Serial_Available()) {
char cmd = Serial_Read();
switch (cmd) {
case 'S': // 启动
BLDC_Start(&motor_ctrl);
break;
case 'X': // 停止
BLDC_Stop(&motor_ctrl);
break;
case '+': // 增加速度
motor_ctrl.target_speed_rpm += 100;
BLDC_SetSpeed(&motor_ctrl, motor_ctrl.target_speed_rpm);
break;
case '-': // 减小速度
motor_ctrl.target_speed_rpm -= 100;
BLDC_SetSpeed(&motor_ctrl, motor_ctrl.target_speed_rpm);
break;
case 'R': // 复位故障
if (motor_ctrl.state == STATE_FAULT) {
motor_ctrl.state = STATE_STOP;
motor_ctrl.fault_overcurrent = false;
motor_ctrl.fault_undervoltage = false;
motor_ctrl.fault_overtemperature = false;
motor_ctrl.fault_stall = false;
}
break;
}
}
}
// 更新状态显示
void UpdateStatusDisplay(void) {
static uint32_t last_display_time = 0;
if (system_tick - last_display_time >= 100) { // 100ms更新一次
printf("\r状态: %d, 转速: %.1f RPM, 电流: %.2f A, 电压: %.1f V, "
"温度: %.1f C, 角度: %.1f",
motor_ctrl.state,
motor_ctrl.actual_speed_rpm,
(motor_ctrl.phase_current_u + motor_ctrl.phase_current_v +
motor_ctrl.phase_current_w) / 3,
motor_ctrl.bus_voltage,
motor_ctrl.temperature,
motor_ctrl.electrical_angle * 180 / M_PI);
last_display_time = system_tick;
}
}
// 故障处理
void HandleFault(BLDC_Controller* ctrl) {
printf("\n故障发生！\n");
if (ctrl->fault_overcurrent) {
printf("过流故障！\n");
}
if (ctrl->fault_undervoltage) {
printf("欠压故障！\n");
}
if (ctrl->fault_overtemperature) {
printf("过温故障！\n");
}
if (ctrl->fault_stall) {
printf("堵转故障！\n");
}
// 停止电机
BLDC_Stop(ctrl);
// 等待复位
while (1) {
HAL_Delay(100);
}
}
7.2 调试和测试代码
// bldc_test.c
#include "bldc_core.h"
#include <stdio.h>
#include <math.h>
// 测试模式
typedef enum {
TEST_IDLE = 0,
TEST_ALIGN = 1,
TEST_OPENLOOP = 2,
TEST_CLOSEDLOOP = 3,
TEST_CURRENT_LOOP = 4,
TEST_BEMF = 5
} Test_Mode;
void Test_Alignment(BLDC_Controller* ctrl) {
printf("=== 对齐测试 ===\n");
ctrl->state = STATE_ALIGN;
ctrl->start_stage = 0;
uint32_t start_time = system_tick;
while (system_tick - start_time < 2000) { // 测试2秒
BLDC_ControlLoop(ctrl);
HAL_Delay(1);
printf("对齐电流: %.2f A\n", ctrl->phase_current_u);
}
printf("对齐测试完成\n");
}
void Test_OpenLoop(BLDC_Controller* ctrl) {
printf("=== 开环测试 ===\n");
ctrl->state = STATE_OPENLOOP_START;
ctrl->openloop_speed = 0;
ctrl->openloop_angle = 0;
// 加速测试
for (int i = 0; i < 100; i++) {
ctrl->openloop_speed += 1.0f; // 1RPM/步
BLDC_ControlLoop(ctrl);
printf("开环速度: %.1f RPM, 角度: %.1f\n",
ctrl->openloop_speed, ctrl->openloop_angle * 180 / M_PI);
HAL_Delay(10);
}
// 减速测试
for (int i = 0; i < 100; i++) {
ctrl->openloop_speed -= 1.0f;
BLDC_ControlLoop(ctrl);
printf("开环速度: %.1f RPM, 角度: %.1f\n",
ctrl->openloop_speed, ctrl->openloop_angle * 180 / M_PI);
HAL_Delay(10);
}
printf("开环测试完成\n");
}
void Test_BEMF(BEMF_Sensor* sensor) {
printf("=== BEMF测试 ===\n");
for (int i = 0; i < 100; i++) {
BEMF_Update(sensor, &motor_ctrl);
printf("BEMF: U=%.3f, V=%.3f, W=%.3f, 频率=%.1f Hz\n",
sensor->bemf_u_filtered,
sensor->bemf_v_filtered,
sensor->bemf_w_filtered,
sensor->bemf_frequency);
HAL_Delay(10);
}
}
void Run_All_Tests(void) {
printf("开始BLDC控制器测试\n");
// 1. 对齐测试
Test_Alignment(&motor_ctrl);
HAL_Delay(1000);
// 2. 开环测试
Test_OpenLoop(&motor_ctrl);
HAL_Delay(1000);
// 3. BEMF测试
Test_BEMF(&bemf_sensor);
printf("所有测试完成\n");
}
八、调试和优化
8.1 参数调试工具
// parameter_tuner.h
typedef struct {
float kp;
float ki;
float kd;
float setpoint;
float feedback;
float output;
float error_integral;
float error_previous;
} PID_Tuner;
void Tune_SpeedLoop(PID_Tuner* tuner, BLDC_Controller* ctrl) {
// 自动整定速度环参数
printf("开始速度环自动整定\n");
// 设置测试信号
tuner->setpoint = 100.0f; // 100 RPM
// 记录响应
float response_time = 0;
float overshoot = 0;
float settling_time = 0;
// 这里可以添加Ziegler-Nichols或其他整定算法
// ...
printf("整定完成: Kp=%.4f, Ki=%.4f\n", tuner->kp, tuner->ki);
}
8.2 性能监控
// performance_monitor.h
typedef struct {
uint32_t loop_count;
uint32_t max_loop_time_us;
uint32_t min_loop_time_us;
uint32_t avg_loop_time_us;
float cpu_usage_percent;
uint32_t fault_count;
} Performance_Monitor;
void Monitor_Performance(Performance_Monitor* monitor) {
static uint32_t last_time = 0;
uint32_t current_time = HAL_GetTick();
uint32_t loop_time = current_time - last_time;
monitor->loop_count++;
if (loop_time > monitor->max_loop_time_us) {
monitor->max_loop_time_us = loop_time;
}
if (loop_time < monitor->min_loop_time_us || monitor->min_loop_time_us == 0) {
monitor->min_loop_time_us = loop_time;
}
// 更新平均时间
monitor->avg_loop_time_us = (monitor->avg_loop_time_us * (monitor->loop_count - 1) + loop_time) / monitor->loop_count;
last_time = current_time;
}
浙公网安备 33010602011771号