智能电池管理系统（BMS）
智能电池管理系统（BMS）完整代码
基于STM32F103的完整BMS系统代码：
c
/**
******************************************************************************
* @file bms_main.c
* @author BMS Development Team
* @brief 智能电池管理系统主程序
* 基于STM32F103 + LTC6811 AFE芯片
* 支持12串锂电池管理
******************************************************************************
*/
#include "main.h"
#include "stm32f1xx_hal.h"
#include "ltc6811.h"
#include "bms_core.h"
#include "bms_soc.h"
#include "bms_protection.h"
#include "bms_balance.h"
#include "bms_charge.h"
#include "bms_communication.h"
#include "bms_storage.h"
#include "eeprom_emulation.h"
/* 全局变量定义 -------------------------------------------------------------*/
BMS_System_t BMS;
CAN_HandleTypeDef hcan;
SPI_HandleTypeDef hspi1;
I2C_HandleTypeDef hi2c1;
ADC_HandleTypeDef hadc1;
/* 函数声明 ---------------------------------------------------------------*/
static void SystemClock_Config(void);
static void GPIO_Init(void);
static void SPI1_Init(void);
static void I2C1_Init(void);
static void ADC1_Init(void);
static void CAN_Init(void);
static void Timer_Init(void);
static void BMS_System_Init(void);
static void BMS_Main_Task(void);
static void BMS_Periodic_Task_1ms(void);
static void BMS_Periodic_Task_10ms(void);
static void BMS_Periodic_Task_100ms(void);
static void BMS_Periodic_Task_1000ms(void);
static void Error_Handler(void);
/**
* @brief 主函数
* @retval int
*/
int main(void)
{
HAL_Init();
SystemClock_Config();
GPIO_Init();
SPI1_Init();
I2C1_Init();
ADC1_Init();
CAN_Init();
Timer_Init();
/* 初始化BMS系统 */
BMS_System_Init();
/* 启动看门狗 */
IWDG_Start();
/* 主循环 */
while (1)
{
BMS_Main_Task();
/* 低功耗模式 */
__WFI();
}
}
/**
* @brief BMS系统初始化
*/
static void BMS_System_Init(void)
{
/* 重置BMS结构体 */
memset(&BMS, 0, sizeof(BMS_System_t));
/* 从EEPROM加载参数 */
BMS_LoadParameters();
/* 初始化AFE芯片 */
LTC6811_Init();
/* 初始化SOC估算器 */
SOC_Estimator_Init();
/* 初始化保护模块 */
Protection_Module_Init();
/* 初始化均衡模块 */
Balance_Module_Init();
/* 初始化充电管理 */
Charge_Manager_Init();
/* 初始化通信模块 */
BMS_Comm_Init();
/* 设置系统状态 */
BMS.system_state = BMS_STATE_INIT;
BMS.fault_status = 0;
BMS.battery_status = BATTERY_IDLE;
/* 记录系统启动 */
BMS_LogEvent(EVENT_SYSTEM_START, 0);
}
/**
* @brief BMS主任务
*/
static void BMS_Main_Task(void)
{
static uint32_t tick_1ms = 0;
static uint32_t tick_10ms = 0;
static uint32_t tick_100ms = 0;
static uint32_t tick_1000ms = 0;
uint32_t current_tick = HAL_GetTick();
/* 1ms任务 */
if (current_tick - tick_1ms >= 1)
{
tick_1ms = current_tick;
BMS_Periodic_Task_1ms();
}
/* 10ms任务 */
if (current_tick - tick_10ms >= 10)
{
tick_10ms = current_tick;
BMS_Periodic_Task_10ms();
}
/* 100ms任务 */
if (current_tick - tick_100ms >= 100)
{
tick_100ms = current_tick;
BMS_Periodic_Task_100ms();
}
/* 1000ms任务 */
if (current_tick - tick_1000ms >= 1000)
{
tick_1000ms = current_tick;
BMS_Periodic_Task_1000ms();
}
}
/**
* @brief 1ms周期任务
*/
static void BMS_Periodic_Task_1ms(void)
{
/* 电流采样和库仑计更新 */
BMS_Current_Sampling();
/* 故障快速检测 */
Protection_Fast_Check();
/* 看门狗喂狗 */
IWDG_Reload();
}
/**
* @brief 10ms周期任务
*/
static void BMS_Periodic_Task_10ms(void)
{
/* 电压温度采集 */
BMS_Measurement_Task();
/* SOC估算 */
SOC_Estimation_Task();
/* 均衡控制 */
Balance_Control_Task();
/* 保护策略执行 */
Protection_Strategy_Task();
}
/**
* @brief 100ms周期任务
*/
static void BMS_Periodic_Task_100ms(void)
{
/* 充电管理 */
Charge_Management_Task();
/* CAN通信发送 */
BMS_CAN_Transmit_Task();
/* 状态监控 */
BMS_Status_Monitor();
}
/**
* @brief 1000ms周期任务
*/
static void BMS_Periodic_Task_1000ms(void)
{
/* 参数保存到EEPROM */
BMS_SaveParameters();
/* 故障记录管理 */
BMS_FaultLog_Management();
/* 系统自检 */
BMS_SelfTest_Task();
/* 发送心跳包 */
BMS_SendHeartbeat();
}
/**
* @brief BMS测量任务
*/
void BMS_Measurement_Task(void)
{
uint8_t afe_status;
/* 启动AFE测量 */
afe_status = LTC6811_StartCellVoltageMeasurement();
if (afe_status != AFE_OK)
{
BMS_LogEvent(EVENT_AFE_ERROR, afe_status);
return;
}
HAL_Delay(3); /* 等待测量完成 */
/* 读取电芯电压 */
afe_status = LTC6811_ReadCellVoltages(BMS.cell_voltages);
if (afe_status != AFE_OK)
{
BMS_LogEvent(EVENT_AFE_READ_ERROR, afe_status);
return;
}
/* 读取温度 */
afe_status = LTC6811_ReadTemperatures(BMS.temperatures);
if (afe_status != AFE_OK)
{
BMS_LogEvent(EVENT_TEMP_READ_ERROR, afe_status);
return;
}
/* 计算统计值 */
BMS_CalculateStatistics();
}
/**
* @brief 电流采样和库仑计更新
*/
void BMS_Current_Sampling(void)
{
static int32_t coulomb_count = 0;
int16_t current_raw;
float current;
/* 读取电流采样值 */
current_raw = ADC_GetCurrentValue();
/* 转换为实际电流值（单位：A） */
current = (float)current_raw * CURRENT_SCALE_FACTOR;
BMS.pack_current = current;
/* 更新库仑计 */
coulomb_count += (int32_t)(current * 1000 / 3600); /* mAh计数 */
BMS.coulomb_count = coulomb_count;
/* 更新电流统计 */
if (current > BMS.max_current)
BMS.max_current = current;
if (current < BMS.min_current)
BMS.min_current = current;
}
/**
* @brief SOC估算任务
*/
void SOC_Estimation_Task(void)
{
static uint32_t soc_update_counter = 0;
float soc_coulomb, soc_ocv, soc_final;
/* 每10次执行一次完整SOC估算 */
if (++soc_update_counter >= 10)
{
soc_update_counter = 0;
/* 库仑计法SOC */
soc_coulomb = SOC_CoulombCounting(&BMS);
/* OCV法SOC（需要电池静置时使用） */
if (BMS.pack_current < 0.1 && BMS.pack_current > -0.1)
{
soc_ocv = SOC_OCV_Method(BMS.pack_voltage);
/* 使用卡尔曼滤波器融合两种方法 */
soc_final = SOC_KalmanFilter(soc_coulomb, soc_ocv);
}
else
{
soc_final = soc_coulomb;
}
/* 应用温度补偿 */
soc_final = SOC_TemperatureCompensation(soc_final, BMS.temp_max);
/* 限制SOC范围 0-100% */
if (soc_final > 100.0f) soc_final = 100.0f;
if (soc_final < 0.0f) soc_final = 0.0f;
BMS.state_of_charge = soc_final;
}
}
/**
* @brief 均衡控制任务
*/
void Balance_Control_Task(void)
{
uint8_t i;
uint8_t balance_flags = 0;
/* 检查均衡条件 */
if (BMS.system_state == BMS_STATE_NORMAL &&
BMS.battery_status != BATTERY_CHARGING &&
BMS.state_of_charge > BALANCE_SOC_THRESHOLD)
{
/* 被动均衡 */
for (i = 0; i < CELL_COUNT; i++)
{
if (BMS.cell_voltages[i] > BALANCE_VOLTAGE_THRESHOLD)
{
balance_flags |= (1 << i);
LTC6811_EnableDischarge(i, ENABLE);
}
else
{
LTC6811_EnableDischarge(i, DISABLE);
}
}
/* 主动均衡（需要额外硬件支持） */
if (BMS.config.enable_active_balance)
{
Active_Balance_Control();
}
BMS.balance_flags = balance_flags;
}
else
{
/* 关闭所有均衡 */
for (i = 0; i < CELL_COUNT; i++)
{
LTC6811_EnableDischarge(i, DISABLE);
}
BMS.balance_flags = 0;
}
}
/**
* @brief 保护策略任务
*/
void Protection_Strategy_Task(void)
{
static uint32_t protection_check_counter = 0;
uint8_t fault_detected = 0;
/* 保护检查计数器 */
if (++protection_check_counter >= 5) /* 50ms检查一次 */
{
protection_check_counter = 0;
/* 过压保护检查 */
if (Protection_OverVoltage_Check())
{
fault_detected = 1;
BMS_SetFault(FAULT_OVERVOLTAGE);
}
/* 欠压保护检查 */
if (Protection_UnderVoltage_Check())
{
fault_detected = 1;
BMS_SetFault(FAULT_UNDERVOLTAGE);
}
/* 过流保护检查 */
if (Protection_OverCurrent_Check())
{
fault_detected = 1;
BMS_SetFault(FAULT_OVERCURRENT);
}
/* 过温保护检查 */
if (Protection_OverTemperature_Check())
{
fault_detected = 1;
BMS_SetFault(FAULT_OVERTEMPERATURE);
}
/* 温度过低保护 */
if (Protection_UnderTemperature_Check())
{
fault_detected = 1;
BMS_SetFault(FAULT_UNDERTEMPERATURE);
}
/* 如果有故障，执行保护动作 */
if (fault_detected)
{
Protection_Execute_Action();
}
}
}
/**
* @brief 充电管理任务
*/
void Charge_Management_Task(void)
{
static Charge_State_t charge_state = CHARGE_IDLE;
static float cc_current_setpoint = 0;
static float cv_voltage_setpoint = 0;
switch (charge_state)
{
case CHARGE_IDLE:
/* 检查是否允许充电 */
if (BMS_CanStartCharge())
{
charge_state = CHARGE_PRECHARGE;
BMS.battery_status = BATTERY_CHARGING;
BMS_LogEvent(EVENT_CHARGE_START, 0);
}
break;
case CHARGE_PRECHARGE:
/* 预充电阶段：小电流充电至最低电压 */
if (BMS.pack_voltage < PRECHARGE_VOLTAGE_THRESHOLD)
{
cc_current_setpoint = PRECHARGE_CURRENT;
Charge_SetCurrent(cc_current_setpoint);
}
else
{
charge_state = CHARGE_CC;
cc_current_setpoint = CHARGE_CURRENT_MAX;
}
break;
case CHARGE_CC:
/* 恒流充电阶段 */
Charge_SetCurrent(cc_current_setpoint);
/* 检查是否达到恒压点 */
if (BMS.cell_voltage_max >= CHARGE_VOLTAGE_MAX - 0.01f)
{
charge_state = CHARGE_CV;
cv_voltage_setpoint = CHARGE_VOLTAGE_MAX * CELL_COUNT;
}
break;
case CHARGE_CV:
/* 恒压充电阶段 */
Charge_SetVoltage(cv_voltage_setpoint);
/* 检查充电完成条件 */
if (BMS.pack_current < CHARGE_TERMINATION_CURRENT)
{
charge_state = CHARGE_COMPLETE;
}
break;
case CHARGE_COMPLETE:
/* 充电完成 */
Charge_Stop();
BMS.battery_status = BATTERY_FULL;
BMS_LogEvent(EVENT_CHARGE_COMPLETE, 0);
charge_state = CHARGE_IDLE;
break;
case CHARGE_FAULT:
/* 充电故障处理 */
Charge_Stop();
BMS.battery_status = BATTERY_FAULT;
break;
}
}
/**
* @brief CAN通信发送任务
*/
void BMS_CAN_Transmit_Task(void)
{
static uint8_t can_msg_counter = 0;
CAN_TxHeaderTypeDef tx_header;
uint8_t tx_data[8];
uint32_t tx_mailbox;
/* J1939协议消息 */
switch (can_msg_counter)
{
case 0:
/* PGN 61444: 电池组状态 */
tx_header.StdId = 0x18FF50F4; /* J1939广播地址 */
tx_header.ExtId = 0;
tx_header.RTR = CAN_RTR_DATA;
tx_header.IDE = CAN_ID_STD;
tx_header.DLC = 8;
/* 数据：SOC, SOH, 电压, 电流, 温度 */
tx_data[0] = (uint8_t)BMS.state_of_charge;
tx_data[1] = (uint8_t)BMS.state_of_health;
tx_data[2] = (uint8_t)(BMS.pack_voltage >> 8);
tx_data[3] = (uint8_t)BMS.pack_voltage;
tx_data[4] = (uint8_t)(BMS.pack_current + 1000);
tx_data[5] = (uint8_t)(BMS.pack_current >> 8);
tx_data[6] = (uint8_t)BMS.temp_max;
tx_data[7] = (uint8_t)BMS.temp_min;
HAL_CAN_AddTxMessage(&hcan, &tx_header, tx_data, &tx_mailbox);
break;
case 1:
/* PGN 61443: 电池组电压信息 */
tx_header.StdId = 0x18FF50F3;
tx_header.ExtId = 0;
tx_header.RTR = CAN_RTR_DATA;
tx_header.IDE = CAN_ID_STD;
tx_header.DLC = 8;
/* 数据：最高/最低电芯电压，电芯电压1-3 */
tx_data[0] = (uint8_t)(BMS.cell_voltage_max * 100);
tx_data[1] = (uint8_t)(BMS.cell_voltage_min * 100);
tx_data[2] = (uint8_t)(BMS.cell_voltages[0] * 100);
tx_data[3] = (uint8_t)(BMS.cell_voltages[1] * 100);
tx_data[4] = (uint8_t)(BMS.cell_voltages[2] * 100);
tx_data[5] = (uint8_t)BMS.balance_flags;
tx_data[6] = BMS.fault_status;
tx_data[7] = BMS.warning_status;
HAL_CAN_AddTxMessage(&hcan, &tx_header, tx_data, &tx_mailbox);
break;
case 2:
/* PGN 61445: 电池温度信息 */
tx_header.StdId = 0x18FF50F5;
tx_header.ExtId = 0;
tx_header.RTR = CAN_RTR_DATA;
tx_header.IDE = CAN_ID_STD;
tx_header.DLC = 8;
/* 数据：温度1-6 */
for (uint8_t i = 0; i < 6; i++)
{
tx_data[i] = (uint8_t)BMS.temperatures[i];
}
tx_data[6] = (uint8_t)BMS.temp_max;
tx_data[7] = (uint8_t)BMS.temp_min;
HAL_CAN_AddTxMessage(&hcan, &tx_header, tx_data, &tx_mailbox);
break;
}
can_msg_counter = (can_msg_counter + 1) % 3;
}
/**
* @brief EEPROM参数保存
*/
void BMS_SaveParameters(void)
{
static uint32_t save_counter = 0;
if (++save_counter >= 600) /* 每10分钟保存一次 */
{
save_counter = 0;
/* 保存系统参数 */
EE_SaveParameter(PARAM_SOC_ADDR, (uint16_t)(BMS.state_of_charge * 10));
EE_SaveParameter(PARAM_SOH_ADDR, (uint16_t)(BMS.state_of_health * 10));
EE_SaveParameter(PARAM_CYCLE_COUNT_ADDR, BMS.cycle_count);
EE_SaveParameter(PARAM_TOTAL_AH_ADDR, (uint16_t)(BMS.total_ah_throughput));
/* 保存配置参数 */
EE_SaveParameter(PARAM_CONFIG_ADDR, *(uint16_t*)&BMS.config);
}
}
/**
* @brief 故障记录管理
*/
void BMS_FaultLog_Management(void)
{
Fault_Record_t fault_record;
/* 检查是否有新故障 */
if (BMS.new_fault_detected)
{
fault_record.timestamp = HAL_GetTick();
fault_record.fault_code = BMS.latest_fault;
fault_record.soc_at_fault = BMS.state_of_charge;
fault_record.voltage_at_fault = BMS.pack_voltage;
fault_record.current_at_fault = BMS.pack_current;
fault_record.temperature_at_fault = BMS.temp_max;
/* 保存故障记录到EEPROM */
EE_SaveFaultRecord(&fault_record);
BMS.new_fault_detected = 0;
BMS.fault_record_count++;
}
}
/**
* @brief 系统时钟配置
*/
static void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/* 配置HSE */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/* 配置系统时钟 */
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief CAN初始化
*/
static void CAN_Init(void)
{
CAN_FilterTypeDef can_filter;
hcan.Instance = CAN1;
hcan.Init.Prescaler = 9;
hcan.Init.Mode = CAN_MODE_NORMAL;
hcan.Init.SyncJumpWidth = CAN_SJW_1TQ;
hcan.Init.TimeSeg1 = CAN_BS1_13TQ;
hcan.Init.TimeSeg2 = CAN_BS2_2TQ;
hcan.Init.TimeTriggeredMode = DISABLE;
hcan.Init.AutoBusOff = ENABLE;
hcan.Init.AutoWakeUp = DISABLE;
hcan.Init.AutoRetransmission = ENABLE;
hcan.Init.ReceiveFifoLocked = DISABLE;
hcan.Init.TransmitFifoPriority = DISABLE;
if (HAL_CAN_Init(&hcan) != HAL_OK)
{
Error_Handler();
}
/* 配置CAN过滤器 */
can_filter.FilterBank = 0;
can_filter.FilterMode = CAN_FILTERMODE_IDMASK;
can_filter.FilterScale = CAN_FILTERSCALE_32BIT;
can_filter.FilterIdHigh = 0x0000;
can_filter.FilterIdLow = 0x0000;
can_filter.FilterMaskIdHigh = 0x0000;
can_filter.FilterMaskIdLow = 0x0000;
can_filter.FilterFIFOAssignment = CAN_RX_FIFO0;
can_filter.FilterActivation = ENABLE;
can_filter.SlaveStartFilterBank = 14;
HAL_CAN_ConfigFilter(&hcan, &can_filter);
/* 启动CAN */
HAL_CAN_Start(&hcan);
HAL_CAN_ActivateNotification(&hcan, CAN_IT_RX_FIFO0_MSG_PENDING);
}
/**
* @brief 定时器初始化
*/
static void Timer_Init(void)
{
/* 配置系统定时器 */
HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq() / 1000);
/* 配置独立看门狗 */
IWDG_InitTypeDef iwdg;
iwdg.Prescaler = IWDG_PRESCALER_64;
iwdg.Reload = 0x0FFF;
iwdg.Window = 0x0FFF;
HAL_IWDG_Init(&iwdg);
}
/**
* @brief 错误处理函数
*/
static void Error_Handler(void)
{
/* 点亮错误指示灯 */
HAL_GPIO_WritePin(LED_ERROR_GPIO_Port, LED_ERROR_Pin, GPIO_PIN_SET);
/* 记录系统复位 */
BMS_LogEvent(EVENT_SYSTEM_RESET, 0);
/* 系统复位 */
NVIC_SystemReset();
}
/**
* @brief CAN接收中断回调函数
*/
void HAL_CAN_RxFifo0MsgPendingCallback(CAN_HandleTypeDef *hcan)
{
CAN_RxHeaderTypeDef rx_header;
uint8_t rx_data[8];
if (HAL_CAN_GetRxMessage(hcan, CAN_RX_FIFO0, &rx_header, rx_data) == HAL_OK)
{
/* 处理CAN消息 */
BMS_ProcessCANMessage(rx_header.StdId, rx_data);
}
}
/* 头文件: bms_core.h ------------------------------------------------------*/
#ifndef __BMS_CORE_H
#define __BMS_CORE_H
#include <stdint.h>
#include <stdbool.h>
/* 系统定义 */
#define CELL_COUNT 12
#define TEMP_SENSOR_COUNT 6
#define ADC_RESOLUTION 4096
#define CURRENT_SCALE_FACTOR 0.1f /* 电流转换系数 */
#define VOLTAGE_SCALE_FACTOR 0.0001f /* 电压转换系数 */
/* 系统状态 */
typedef enum
{
BMS_STATE_INIT,
BMS_STATE_STANDBY,
BMS_STATE_NORMAL,
BMS_STATE_CHARGING,
BMS_STATE_FAULT,
BMS_STATE_SLEEP
} BMS_State_t;
/* 电池状态 */
typedef enum
{
BATTERY_IDLE,
BATTERY_DISCHARGING,
BATTERY_CHARGING,
BATTERY_FULL,
BATTERY_EMPTY,
BATTERY_FAULT
} Battery_Status_t;
/* 充电状态 */
typedef enum
{
CHARGE_IDLE,
CHARGE_PRECHARGE,
CHARGE_CC,
CHARGE_CV,
CHARGE_COMPLETE,
CHARGE_FAULT
} Charge_State_t;
/* 故障代码 */
typedef enum
{
FAULT_NONE = 0,
FAULT_OVERVOLTAGE,
FAULT_UNDERVOLTAGE,
FAULT_OVERCURRENT,
FAULT_OVERTEMPERATURE,
FAULT_UNDERTEMPERATURE,
FAULT_SHORT_CIRCUIT,
FAULT_OPEN_WIRE,
FAULT_AFE_COMM_ERROR,
FAULT_CELL_BALANCE_FAIL,
FAULT_INTERNAL_ERROR
} Fault_Code_t;
/* 事件类型 */
typedef enum
{
EVENT_SYSTEM_START,
EVENT_SYSTEM_RESET,
EVENT_CHARGE_START,
EVENT_CHARGE_COMPLETE,
EVENT_DISCHARGE_START,
EVENT_DISCHARGE_COMPLETE,
EVENT_FAULT_OCCURRED,
EVENT_FAULT_CLEARED,
EVENT_AFE_ERROR,
EVENT_TEMP_READ_ERROR,
EVENT_CAN_ERROR
} Event_Type_t;
/* BMS配置结构体 */
typedef struct
{
uint8_t enable_passive_balance : 1;
uint8_t enable_active_balance : 1;
uint8_t enable_cell_protection : 1;
uint8_t enable_temperature_protection : 1;
uint8_t enable_current_protection : 1;
uint8_t reserve : 3;
float cell_voltage_max; /* 电芯最大电压 */
float cell_voltage_min; /* 电芯最小电压 */
float charge_current_max; /* 最大充电电流 */
float discharge_current_max; /* 最大放电电流 */
float temperature_max; /* 最高温度 */
float temperature_min; /* 最低温度 */
float balance_voltage_threshold; /* 均衡启动电压 */
float soc_balance_threshold; /* 均衡SOC阈值 */
} BMS_Config_t;
/* BMS系统结构体 */
typedef struct
{
/* 系统状态 */
BMS_State_t system_state;
Battery_Status_t battery_status;
/* 电池参数 */
float cell_voltages[CELL_COUNT];
float cell_voltage_max;
float cell_voltage_min;
float cell_voltage_avg;
float pack_voltage;
float temperatures[TEMP_SENSOR_COUNT];
float temp_max;
float temp_min;
float temp_avg;
float pack_current;
float max_current;
float min_current;
float current_avg;
/* SOC/SOH */
float state_of_charge;
float state_of_health;
int32_t coulomb_count;
uint32_t cycle_count;
float total_ah_throughput;
/* 保护状态 */
uint16_t fault_status;
uint16_t warning_status;
Fault_Code_t latest_fault;
uint8_t new_fault_detected;
/* 均衡状态 */
uint16_t balance_flags;
/* 配置参数 */
BMS_Config_t config;
/* 统计信息 */
uint32_t operation_time;
uint32_t charge_time;
uint32_t discharge_time;
uint8_t fault_record_count;
} BMS_System_t;
/* 故障记录结构体 */
typedef struct
{
uint32_t timestamp;
Fault_Code_t fault_code;
float soc_at_fault;
float voltage_at_fault;
float current_at_fault;
float temperature_at_fault;
} Fault_Record_t;
/* 外部变量声明 */
extern BMS_System_t BMS;
/* 函数声明 */
void BMS_System_Init(void);
void BMS_Main_Task(void);
void BMS_Measurement_Task(void);
void BMS_Current_Sampling(void);
void SOC_Estimation_Task(void);
void Balance_Control_Task(void);
void Protection_Strategy_Task(void);
void Charge_Management_Task(void);
void BMS_CAN_Transmit_Task(void);
void BMS_ProcessCANMessage(uint32_t std_id, uint8_t* data);
void BMS_SaveParameters(void);
void BMS_LoadParameters(void);
void BMS_FaultLog_Management(void);
void BMS_LogEvent(Event_Type_t event, uint16_t data);
void BMS_SetFault(Fault_Code_t fault);
void BMS_ClearFault(Fault_Code_t fault);
void BMS_CalculateStatistics(void);
#endif /* __BMS_CORE_H */关键特性说明
1. 硬件架构
- STM32F103作为主控制器
- LTC6811作为AFE芯片（SPI接口）
- 支持12串锂电池管理
- CAN总线通信接口
- EEPROM用于参数存储
2. 核心功能
- 电压/温度采集：高精度测量，定期校准
- SOC估算：融合库仑计法和OCV法，使用卡尔曼滤波
- 均衡控制：支持被动均衡和主动均衡
- 充电管理：CC/CV充电曲线，多阶段充电控制
- 多重保护：过压、欠压、过流、过温等保护策略
3. 通信协议
- SAE J1939标准CAN通信
- 实时上报电池状态信息
- 支持远程诊断和控制
4. 数据存储
- EEPROM存储关键参数
- 故障记录功能
- 循环计数和寿命统计
5. 安全特性
- 看门狗定时器
- 多重保护策略
- 故障自恢复机制
- 系统自检功能
使用说明
-
硬件连接：
- 连接LTC6811到STM32的SPI1接口
- 连接CAN收发器到PA11/PA12
- 连接电流采样ADC
- 连接温度传感器
-
参数配置：
- 根据电池规格修改
bms_core.h中的参数 - 配置保护阈值
- 设置通信参数
- 根据电池规格修改
-
系统调试：
- 使用CAN分析仪监控通信
- 通过调试接口查看实时数据
- 使用EEPROM读写工具检查参数存储
注意事项
- 本代码为示例框架，需要根据实际硬件调整
- 生产环境需要添加更多错误处理和冗余设计
- 安全相关功能必须经过充分测试
- 建议添加电池老化补偿算法
- 考虑环境温度对测量精度的影响