低功耗设计与 BMS 开发指南
目录
- 消费电子低功耗技术(#第 1 章消费电子低功耗技术)
- 1.1 MCU 休眠模式配置
- 1.2 外设时钟控制
- 1.3 无线模块间歇唤醒
- 锂电池管理系统(BMS)设计(#第 2 章锂电池管理系统 design)
- 2.1 充电管理
- 2.2 电量计设计
- 2.3 电池保护电路
- 低功耗测试方法(#第 3 章低功耗测试方法)
- 3.1 电流测量技术
- 3.2 功耗优化对比
- 3.3 续航测试方法
第 1 章:消费电子低功耗技术
1.1 MCU 休眠模式配置
在现代便携式电子设备中,MCU(微控制器单元)的低功耗设计是整个系统功耗优化的核心。大多数现代 MCU 都提供多种低功耗模式,包括睡眠模式、深度睡眠模式和待机模式等。
1.1.1 低功耗模式概述
运行模式(Run Mode):MCU 全速运行,所有外设和时钟都开启,功耗最高。
睡眠模式(Sleep Mode):CPU 内核停止运行,但外设继续工作。可以快速唤醒,适合短时间等待外部事件。
深度睡眠模式(Deep Sleep Mode):CPU 和大部分外设停止,仅保留基本功能(如 RTC、看门狗)。唤醒时间较长,但功耗显著降低。
待机模式(Standby Mode):几乎全部电路关闭,仅保留唤醒逻辑。功耗最低,但唤醒时间最长,会丢失 RAM 数据。
1.1.2 STM32 低功耗配置实例
以下代码展示如何配置 STM32 MCU 的各种低功耗模式:
c
/**
* @brief 配置 STM32 进入睡眠模式
* @note 睡眠模式下,CPU 停止,外设继续运行
*/
void Enter_Sleep_Mode(void)
{
// 1. 设置 SLEEPDEEP 位为 0,选择睡眠模式(非深度睡眠)
CLEAR_BIT(PWR->CR, PWR_CR_PDDS);
CLEAR_BIT(SCB->SCR, SCB_SCR_SLEEPDEEP_Msk);
// 2. 选择唤醒源(例如 EXTI 线 0)
__HAL_GPIO_EXTI_CLEAR_IT(GPIO_PIN_0);
// 3. 执行 WFI(Wait For Interrupt)指令进入睡眠
__WFI();
}
/**
* @brief 配置 STM32 进入深度睡眠模式
* @note 深度睡眠下,大部分外设时钟关闭,仅低速时钟运行
*/
void Enter_DeepSleep_Mode(void)
{
// 1. 使能低压差稳压器(LDO)或降压转换器
// 根据具体型号选择低功耗调节器
HAL_PWREx_EnableLowPowerRegulator();
// 2. 设置 SLEEPDEEP 位为 1,选择深度睡眠模式
SET_BIT(PWR->CR, PWR_CR_PDDS);
SET_BIT(SCB->SCR, SCB_SCR_SLEEPDEEP_Msk);
// 3. 配置唤醒源(RTC 闹钟、EXTI 等)
RTC_AlarmConfig(); // 配置 RTC 闹钟唤醒
// 4. 进入深度睡眠
__WFI();
}
/**
* @brief 配置 STM32 进入待机模式
* @note 待机模式功耗最低,但会丢失 SRAM 数据
*/
void Enter_Standby_Mode(void)
{
// 1. 启用唤醒引脚(例如 WKUP pin)
HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);
// 2. 设置 PDDS 位,选择待机模式
SET_BIT(PWR->CR, PWR_CR_PDDS);
// 3. 设置 SLEEPDEEP 位
SET_BIT(SCB->SCR, SCB_SCR_SLEEPDEEP_Msk);
// 4. 清除待机标志位
__HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
// 5. 进入待机模式(需要外部唤醒或复位)
__WFI();
}
/**
* @brief RTC 闹钟配置,用于定时唤醒
* @param interval_sec 唤醒间隔(秒)
*/
void RTC_AlarmConfig(uint32_t interval_sec)
{
RTC_TimeTypeDef sTime = {0};
RTC_DateTypeDef sDate = {0};
RTC_AlarmTypeDef sAlarm = {0};
// 1. 使能 RTC 时钟
__HAL_RCC_RTC_ENABLE();
// 2. 配置 RTC 预分频器(使用 LSE 32.768kHz)
hrtc.Instance = RTC;
hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
hrtc.Init.AsynchPrediv = 127; // 异步预分频
hrtc.Init.SynchPrediv = 255; // 同步预分频
// 计算:32.768kHz / (128*256) = 1Hz
if (HAL_RTC_Init(&hrtc) != HAL_OK)
{
Error_Handler();
}
// 3. 配置闹钟
sAlarm.AlarmTime.Hours = 0;
sAlarm.AlarmTime.Minutes = 0;
sAlarm.AlarmTime.Seconds = interval_sec % 60;
sAlarm.AlarmTime.SubSeconds = 0;
sAlarm.AlarmMask = RTC_ALARMMASK_DATEWEEKDAY;
sAlarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_ALL;
sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DAYS;
sAlarm.AlarmDateWeekDay = 1;
if (HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BIN) != HAL_OK)
{
Error_Handler();
}
// 4. 使能闹钟中断
HAL_NVIC_SetPriority(RTC_Alarm_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn);
}
/**
* @brief RTC 闹钟中断回调函数
*/
void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{
// 清除闹钟标志
__HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
// 这里可以执行唤醒后的操作
// 例如:读取传感器、发送数据等
}
代码说明:
上述代码展示了 STM32 MCU 三种低功耗模式的配置方法:
-
睡眠模式配置 :通过清除
SLEEPDEEP位来选择普通睡眠模式。此模式下 CPU 停止但外设继续运行,适合等待中断事件的场景。 -
深度睡眠模式配置 :设置
SLEEPDEEP位并配置低功耗调节器。此模式下大部分高速时钟关闭,仅保留低速时钟(LSI/LSE),功耗大幅降低。 -
待机模式配置:这是最低功耗的模式,几乎所有电路都关闭,仅保留唤醒引脚和待机电路。需要注意此模式会丢失 SRAM 中的数据。
-
RTC 闹钟配置:使用外部晶振 LSE(32.768kHz)作为时钟源,通过配置预分频器获得 1Hz 的时基。闹钟中断可以作为可靠的唤醒源。
关键要点:
- 选择合适的低功耗模式需要根据应用场景权衡:唤醒时间 vs 功耗
- 配置唤醒源至关重要,常用的有:外部 GPIO、RTC 闹钟、看门狗
- 进入低功耗模式前,应关闭不必要的外设以进一步降低功耗
- 从低功耗模式唤醒后,需要重新初始化系统时钟和外设
1.1.3 ESP32 低功耗配置实例
ESP32 是广泛应用于 IoT 设备的低功耗 Wi-Fi/蓝牙双模芯片,它提供多种功耗模式:
c
#include "driver/rtc_io.h"
#include "esp_sleep.h"
/**
* @brief 配置 ESP32 进入 Light Sleep 模式
* @note Light Sleep 模式下,CPU 和大部分数字外设暂停,但内存保持
*/
void esp32_light_sleep_config(uint64_t sleep_time_us)
{
// 1. 配置唤醒源:RTC GPIO(例如 GPIO 25)
rtc_gpio_init(GPIO_NUM_25);
rtc_gpio_set_direction(GPIO_NUM_25, RTC_GPIO_MODE_INPUT_ONLY);
rtc_gpio_pulldown_en(GPIO_NUM_25);
rtc_gpio_pullup_dis(GPIO_NUM_25);
// 允许 RTC GPIO 唤醒
esp_sleep_enable_ext1_wakeup(1ULL << GPIO_NUM_25, ESP_EXT1_WAKEUP_ANY_HIGH);
// 2. 配置定时器唤醒
esp_sleep_enable_timer_wakeup(sleep_time_us);
// 3. 配置 ULP 协处理器唤醒(可选)
// ulp_run(entry_point);
// 4. 进入 Light Sleep
esp_light_sleep_start();
// 5. 唤醒后继续执行
esp_sleep_wakeup_cause_t wakeup_reason = esp_sleep_get_wakeup_cause();
switch(wakeup_reason) {
case ESP_SLEEP_WAKEUP_TIMER:
printf("Timer wakeup\n");
break;
case ESP_SLEEP_WAKEUP_EXT1:
printf("GPIO wakeup\n");
break;
default:
printf("Other wakeup reason\n");
}
}
/**
* @brief 配置 ESP32 进入 Deep Sleep 模式
* @note Deep Sleep 模式下,CPU 和大部分外设关闭,仅 RTC 控制器运行
*/
void esp32_deep_sleep_config(uint64_t sleep_time_us)
{
// 1. 配置 RTC GPIO 保持(避免唤醒时 GPIO 状态跳变)
rtc_gpio_hold_en(GPIO_NUM_25);
// 2. 配置定时器唤醒
esp_sleep_enable_timer_wakeup(sleep_time_us);
// 3. 配置 EXT0 唤醒(单个 GPIO)
// esp_sleep_enable_ext0_wakeup(GPIO_NUM_25, 1); // 高电平唤醒
// 4. 配置 EXT1 唤醒(多个 GPIO)
esp_sleep_enable_ext1_wakeup(1ULL << GPIO_NUM_25, ESP_EXT1_WAKEUP_ANY_HIGH);
// 5. 配置触摸唤醒(如果使用了触摸传感器)
// esp_sleep_enable_touchpad_wakeup();
// 6. 进入 Deep Sleep(此函数不会返回)
esp_deep_sleep_start();
}
/**
* @brief 配置 WiFi 和蓝牙的节能模式
*/
void wifi_bluetooth_power_save(void)
{
// WiFi 节能模式配置
wifi_ps_type_t ps_type = WIFI_PS_MAX_MODEM; // 最大节能模式
esp_wifi_set_ps(ps_type);
// 蓝牙节能模式配置
esp_bluedroid_disable();
// 或使用经典蓝牙的 Sniff 模式
// esp_bredr_tx_power_set(ESP_BREDR_TX_POWER_P3);
}
代码说明:
ESP32 的低功耗设计具有以下特点:
-
Light Sleep 模式:CPU 暂停但 RTC 内存保持,WiFi/蓝牙基带也暂停。唤醒后可以快速恢复执行,适合周期性任务。
-
Deep Sleep 模式:只有 RTC 控制器和 RTC 内存运行,主系统完全关闭。功耗可低至 10μA 级别。
-
多种唤醒源:支持定时器、外部 GPIO、触摸传感器、ULP 协处理器等多种唤醒方式。
-
RTC GPIO 保持:在 Deep Sleep 期间保持 GPIO 状态,避免对外部电路产生影响。
-
无线模块节能:WiFi 和蓝牙都支持节能模式,通过 DTIM 信标周期性地收发数据。
1.2 外设时钟控制
除了 MCU 本身的低功耗模式外,合理管理外设时钟是降低系统功耗的另一个关键因素。许多开发者只关注 MCU 的睡眠模式,却忽视了未使用的外设仍在消耗大量电能。
1.2.1 外设时钟管理原则
最小化原则:仅开启当前需要的外设时钟,其他外设时钟全部关闭。
动态开关原则:外设使用完毕后立即关闭时钟,需要时再重新开启。
分级管理原则:根据外设的重要性分级管理,关键外设(如看门狗)保持运行,非必要外设按需开关。
1.2.2 STM32 外设时钟控制实例
c
/**
* @brief 初始化外设时钟(遵循低功耗原则)
* @note 仅开启必要的外设时钟,其他外设默认关闭
*/
void Peripherals_Clock_Init(void)
{
// 1. 配置系统时钟(选择合适的工作频率)
// 在满足性能需求的前提下,选择较低的系统时钟频率
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
// 使用 HSI(内部高速时钟)代替 HSE(外部晶振)以降低功耗
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE; // 不使用 PLL
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
// 配置系统时钟分频系数
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_SYSCLK |
RCC_CLOCKTYPE_HCLK |
RCC_CLOCKTYPE_PCLK1;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSI;
RCC_ClkInitStruct.SYSCLKDivider = RCC_SYSCLK_DIV1; // 系统时钟不分频
RCC_ClkInitStruct.AHBCLKDivider = RCC_HCLK_DIV1; // AHB 总线不分频
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; // APB1 总线不分频
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief 开启特定外设的时钟
* @param peripheral 外设标识(如 UART、SPI、I2C 等)
*/
void Peripheral_Clock_Enable(Peripheral_TypeDef peripheral)
{
switch(peripheral) {
case USART1:
__HAL_RCC_USART1_CLK_ENABLE();
break;
case SPI1:
__HAL_RCC_SPI1_CLK_ENABLE();
break;
case I2C1:
__HAL_RCC_I2C1_CLK_ENABLE();
break;
case ADC1:
__HAL_RCC_ADC1_CLK_ENABLE();
break;
default:
break;
}
}
/**
* @brief 关闭特定外设的时钟以节省功耗
* @param peripheral 外设标识
*/
void Peripheral_Clock_Disable(Peripheral_TypeDef peripheral)
{
// 重要:关闭外设前确保外设处于安全状态
switch(peripheral) {
case USART1:
HAL_UART_DeInit(&huart1); // 反初始化
__HAL_RCC_USART1_CLK_DISABLE();
break;
case SPI1:
HAL_SPI_DeInit(&hspi1);
__HAL_RCC_SPI1_CLK_DISABLE();
break;
case I2C1:
HAL_I2C_DeInit(&hi2c1);
__HAL_RCC_I2C1_CLK_DISABLE();
break;
case ADC1:
HAL_ADC_Stop(&hadc1); // 先停止 ADC 转换
HAL_ADC_DeInit(&hadc1);
__HAL_RCC_ADC1_CLK_DISABLE();
break;
default:
break;
}
}
/**
* @brief 批量关闭所有非必要外设时钟(进入低功耗模式前调用)
*/
void Disable_All_Unused_Peripherals(void)
{
// 关闭未使用的通信接口
__HAL_RCC_USART1_CLK_DISABLE();
__HAL_RCC_USART2_CLK_DISABLE();
__HAL_RCC_SPI1_CLK_DISABLE();
__HAL_RCC_SPI2_CLK_DISABLE();
__HAL_RCC_I2C1_CLK_DISABLE();
__HAL_RCC_I2C2_CLK_DISABLE();
// 关闭模拟外设
HAL_ADC_Stop(&hadc1);
__HAL_RCC_ADC1_CLK_DISABLE();
// 关闭定时器(保留基本定时器用于唤醒)
__HAL_RCC_TIM1_CLK_DISABLE();
__HAL_RCC_TIM2_CLK_DISABLE();
__HAL_RCC_TIM3_CLK_DISABLE();
// 注意:以下外设通常不应关闭
// - RTC(实时时钟,用于唤醒)
// - WWDG/IWDG(看门狗,用于系统保护)
// - PWR(电源控制)
// - RCC(时钟控制本身)
}
/**
* @brief 动态频率调节(根据负载调整 CPU 频率)
* @param frequency_level 频率等级(0: 最低,3: 最高)
*/
void Dynamic_Frequency_Scaling(uint8_t frequency_level)
{
uint32_t sysclk_source;
switch(frequency_level) {
case 0: // 最低功耗模式,使用 MSI 或 HSI 低频
sysclk_source = RCC_SYSCLKSOURCE_HSI;
// 配置 HSI 为最低频率(例如 4MHz)
break;
case 1: // 中等功耗,使用 HSI 中频
sysclk_source = RCC_SYSCLKSOURCE_HSI;
// 配置 HSI 为中频(例如 8MHz)
break;
case 2: // 标准模式,使用 HSE
sysclk_source = RCC_SYSCLKSOURCE_HSE;
break;
case 3: // 高性能模式,使用 PLL
sysclk_source = RCC_SYSCLKSOURCE_PLLCLK;
break;
default:
return;
}
// 切换系统时钟源
MODIFY_BIT(RCC->CFGR, RCC_CFGR_SW, sysclk_source);
// 等待时钟切换完成
while((__HAL_RCC_GET_SYSCLK_SOURCE() & RCC_CFGR_SWS) != sysclk_source)
{
// 等待时钟源稳定
}
}
代码说明:
外设时钟管理的核心思想是:
-
按需分配:仅在需要时开启外设时钟。例如,ADC 只在采集时开启,采集完成后立即关闭。
-
反初始化 :关闭外设时钟前,先调用
HAL_xxx_DeInit()函数将外设恢复到默认状态,避免引脚悬空或意外行为。 -
动态调频:根据应用负载动态调整 CPU 频率。轻载时使用低频降低功耗,需要高性能时切换到高频。
-
时钟源选择:内部时钟(HSI/MSI)比外部晶振(HSE)功耗更低,但精度也较低。根据应用需求权衡选择。
1.2.3 外设功耗优化实践
c
/**
* @brief 传感器数据采集的低功耗实现
* @note 展示如何在采集前后管理外设时钟
*/
uint16_t LowPower_ADC_ReadSensor(void)
{
uint16_t adc_value;
// 1. 开启 ADC 时钟
Peripheral_Clock_Enable(ADC1);
// 2. 配置 ADC(单次转换模式)
ADC_ChannelConfTypeDef sConfig = {0};
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES; // 较短采样时间
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
// 3. 启动 ADC 转换
HAL_ADC_Start(&hadc1);
// 4. 等待转换完成(轮询方式,简单但功耗较高)
// 更好的方式是使用中断或 DMA
HAL_ADC_PollForConversion(&hadc1, HAL_MAX_DELAY);
// 5. 读取转换结果
adc_value = HAL_ADC_GetValue(&hadc1);
// 6. 停止 ADC 并关闭时钟
HAL_ADC_Stop(&hadc1);
Peripheral_Clock_Disable(ADC1);
return adc_value;
}
/**
* @brief 使用中断方式降低 ADC 采集功耗
* @note CPU 在等待转换时进入睡眠模式
*/
volatile uint16_t g_adc_result = 0;
volatile uint8_t g_adc_ready = 0;
uint16_t Interrupt_ADC_ReadSensor(void)
{
g_adc_ready = 0;
// 1. 开启 ADC 时钟并配置
Peripheral_Clock_Enable(ADC1);
// 2. 配置 ADC 使用中断模式
ADC_ChannelConfTypeDef sConfig = {0};
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_15CYCLES;
if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
{
Error_Handler();
}
// 3. 启动中断模式的 ADC 转换
HAL_ADC_Start_IT(&hadc1);
// 4. CPU 进入睡眠模式,等待 ADC 中断唤醒
__WFI();
// 5. 唤醒后检查转换完成标志
if (g_adc_ready) {
return g_adc_result;
}
return 0;
}
/**
* @brief ADC 转换完成中断回调
*/
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
if (hadc->Instance == ADC1) {
// 读取结果
g_adc_result = HAL_ADC_GetValue(hadc);
g_adc_ready = 1;
// 停止 ADC 并关闭时钟
HAL_ADC_Stop_IT(hadc);
Peripheral_Clock_Disable(ADC1);
}
}
1.3 无线模块间歇唤醒
无线通信模块(如蓝牙、Wi-Fi、Zigbee)通常是便携式设备中的功耗大户。采用间歇唤醒策略,让无线模块大部分时间处于睡眠状态,周期性唤醒进行通信,可以显著降低平均功耗。
1.3.1 蓝牙低功耗(BLE)广播与连接策略
c
/**
* @brief BLE 广播参数配置
* @note 调整广播间隔和占空比以优化功耗
*/
void BLE_Advertising_Config(void)
{
ble_gap_adv_params_t adv_params;
// 1. 配置广播类型
adv_params.type = GAP_ADVERTISEMENT_TYPE_CONNECTABLE_UNDIRECTED;
// 2. 配置广播间隔(单位:0.625ms)
// 较小的间隔 = 更快的发现速度 = 更高的功耗
// 较大的间隔 = 更低的功耗 = 更慢的发现速度
adv_params.interval_min = 0x0640; // 1000ms (0x0640 * 0.625ms)
adv_params.interval_max = 0x0640; // 1000ms
// 3. 配置广播信道
adv_params.channel_map = ADV_CHANNEL_37 | ADV_CHANNEL_38 | ADV_CHANNEL_39;
// 4. 配置滤波器(可选,仅响应特定设备)
adv_params.filter_policy = GAP_ADV_FILTER_ALLOW_SCAN_ANY_CON_ANY;
// 5. 启动广播
sd_ble_gap_adv_start(&adv_params);
}
/**
* @brief BLE 连接参数更新
* @note 调整连接间隔以平衡功耗和响应速度
*/
void BLE_Connection_Parameters_Update(uint16_t conn_interval_ms)
{
ble_gap_conn_params_t conn_params;
// 连接间隔范围(单位:1.25ms)
// 7.5ms ~ 4s,常用范围:20ms ~ 100ms
uint16_t interval = conn_interval_ms / 1.25;
conn_params.min_conn_interval = interval;
conn_params.max_conn_interval = interval;
conn_params.slave_latency = 0; // 从机延迟(允许跳过多少个连接事件)
conn_params.conn_sup_timeout = 4000; // 连接超时(单位:10ms)
// 请求更新连接参数
sd_ble_gap_conn_param_update(NULL, &conn_params);
}
/**
* @brief BLE 深度睡眠配置
* @note 在无连接时进入深度睡眠
*/
void BLE_DeepSleep_With_BLE_On(void)
{
// 1. 配置 HCI 事件唤醒
hci_cmd_packet_t hci_cmd;
// 2. 设置控制器进入睡眠模式
// 不同芯片厂商的 API 不同
acil_hal_sleep(1); // 允许睡眠
// 3. 配置唤醒源(HCI 数据包到达时唤醒)
// 使用外部中断监听 HCI 引脚
// 4. 进入睡眠
__WFI();
}
1.3.2 蓝牙间歇工作周期设计
c
/**
* @brief 蓝牙间歇工作周期管理器
* @note 定时唤醒 - 通信 - 睡眠的完整流程
*/
#include "rtos.h" // 假设使用 RTOS
#define BLE_WAKE_INTERVAL_MS 1000 // 1 秒唤醒一次
#define BLE_COMM_TIMEOUT_MS 100 // 通信超时 100ms
TaskHandle_t xBLE_Task_Handle;
void BLE_Intermittent_Task(void *pvParameters)
{
TickType_t xLastWakeTime;
const TickType_t xFrequency = pdMS_TO_TICKS(BLE_WAKE_INTERVAL_MS);
// 初始化
BLE_Stack_Init();
Sensor_Init();
// 初始进入睡眠
BLE_Enter_Sleep_Mode();
// 记录上次唤醒时间
xLastWakeTime = xTaskGetTickCount();
while(1) {
// 1. 等待到预定时间唤醒
vTaskDelayUntil(&xLastWakeTime, xFrequency);
// 2. 唤醒蓝牙模块
BLE_Wakeup();
HAL_Delay(10); // 等待蓝牙稳定
// 3. 检查是否有连接
if (BLE_Is_Connected()) {
// 4a. 有连接:发送传感器数据
int16_t temperature = Sensor_ReadTemperature();
int16_t humidity = Sensor_ReadHumidity();
BLE_Send_Data(temperature, humidity);
// 等待 ACK 或发送完成
if (BLE_Wait_For_ACK(BLE_COMM_TIMEOUT_MS)) {
printf("Data sent successfully\n");
}
} else {
// 4b. 无连接:广播模式
// 可以发送广播包或保持沉默以省电
}
// 5. 通信完成后再次进入睡眠
BLE_Enter_Sleep_Mode();
}
}
/**
* @brief 蓝牙唤醒函数
*/
void BLE_Wakeup(void)
{
// 拉高蓝牙模块的使能引脚
HAL_GPIO_WritePin(BLE_EN_PORT, BLE_EN_PIN, GPIO_PIN_SET);
// 等待芯片启动(根据具体模块规格)
HAL_Delay(5);
// 初始化 HCI 接口
BLE_HCI_Init();
}
/**
* @brief 蓝牙进入睡眠
*/
void BLE_Enter_Sleep_Mode(void)
{
// 1. 确保所有数据传输完成
BLE_Wait_Transmission_Complete();
// 2. 发送睡眠命令给蓝牙芯片
BLE_Send_Sleep_Command();
// 3. 拉低使能引脚
HAL_GPIO_WritePin(BLE_EN_PORT, BLE_EN_PIN, GPIO_PIN_RESET);
// 4. 配置外部中断用于唤醒(例如检测蓝牙的中断引脚)
HAL_GPIO_EXTI_Register_Callback(BLE_IRQ_PIN, BLE_IRQ_Callback);
}
/**
* @brief 蓝牙中断回调(紧急唤醒)
*/
void BLE_IRQ_Callback(uint16_t GPIO_Pin)
{
if (GPIO_Pin == BLE_IRQ_PIN) {
// 蓝牙模块有紧急事件,唤醒主系统
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
vTaskNotifyGiveFromISR(xBLE_Task_Handle, &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
1.3.3 Wi-Fi 模块的 DTIM 节能模式
c
/**
* @brief ESP32 Wi-Fi DTIM 节能配置
* @note DTIM(Delivery Traffic Indication Message)周期决定唤醒频率
*/
#include "esp_wifi.h"
void WiFi_DTIM_PowerSave_Config(void)
{
wifi_ps_type_t ps_type = WIFI_PS_MAX_MODEM; // 最大节能模式
esp_wifi_set_ps(ps_type);
// 配置信标间隔和 DTIM 周期
// 信标间隔通常 100ms,DTIM 倍数越大,功耗越低
wifi_conf_t conf = {
.beacon_interval = 100, // 信标间隔(ms)
.dtim_period = 3 // DTIM 周期(每 3 个信标唤醒一次)
};
esp_wifi_set_config(WIFI_IF_STA, &conf);
}
/**
* @brief Wi-Fi 间歇收发数据
* @note 连接到 AP-传输数据 - 断开连接的循环
*/
#define WiFi_TX_INTERVAL_MS 60000 // 每分钟发送一次
void WiFi_Intermittent_Transmit(void *pvParameters)
{
while(1) {
// 1. 上电 Wi-Fi
esp_wifi_start();
vTaskDelay(pdMS_TO_TICKS(500));
// 2. 连接到 AP
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
esp_wifi_init(&cfg);
wifi_config_t wifi_config = {
.sta = {
.ssid = "YourSSID",
.password = "YourPassword",
},
};
esp_wifi_set_mode(WIFI_MODE_STA);
esp_wifi_set_config(WIFI_IF_STA, &wifi_config);
esp_wifi_connect();
// 3. 等待连接成功
EventBits_t bits = xEventGroupWaitBits(
wifi_event_group,
WIFI_CONNECTED_BIT,
pdTRUE,
pdTRUE,
pdMS_TO_TICKS(10000)
);
if (bits & WIFI_CONNECTED_BIT) {
// 4. 发送数据(例如上传传感器读数)
int16_t sensor_data = read_sensor();
http_post_data_to_server(sensor_data);
}
// 5. 断开连接并关闭 Wi-Fi
esp_wifi_disconnect();
esp_wifi_stop();
// 6. 进入深度睡眠直到下次传输
esp_deep_sleep_enable_timer_wakeup(WiFi_TX_INTERVAL_MS);
esp_deep_sleep_start();
}
}
无线模块节能要点总结:
-
减少工作时间占比:无线模块工作时电流可能高达 10-50mA,而睡眠时仅几微安。因此要最大化睡眠时间的占比。
-
优化连接参数:增加 BLE 连接间隔、使用从机延迟、增大 Wi-Fi DTIM 周期都可以降低功耗,但会增加延迟。
-
智能唤醒策略:使用定时器周期性唤醒,或者在检测到特定事件(如传感器超限)时才唤醒通信。
-
快速传输:预先准备好要发送的数据,唤醒后尽快完成传输并返回睡眠状态。
第 2 章:锂电池管理系统(BMS)设计
锂电池管理系统(Battery Management System, BMS)是确保锂电池组安全、可靠、高效运行的核心系统。一个完整的 BMS 需要具备充电管理、电量计量、电池保护、热管理和通信等功能。
2.1 充电管理
充电管理是 BMS 的基本功能之一,需要根据锂电池的化学特性选择合适的充电策略,既要保证充电速度,又要确保电池安全和延长寿命。
2.1.1 锂电池充电特性
锂电池通常采用**恒流 - 恒压(CC-CV)**充电方式:
恒流阶段(Constant Current):以恒定电流充电,电池电压逐渐上升。此阶段充入约 70-80% 的电量。
恒压阶段(Constant Voltage):当电池电压达到截止电压(通常为 4.2V)时,切换到恒压模式,充电电流逐渐减小。
截止阶段:当充电电流降至设定阈值(如 C/10)时,充电结束。
2.1.2 基于专用充电 IC 的控制实例
c
/**
* @brief 充电管理控制器
* @note 使用专用充电 IC(如 BQ24610、MCP73831 等)
*/
#include <stdint.h>
#include <stdbool.h>
// 充电状态定义
typedef enum {
CHARGE_STATE_IDLE, // 空闲
CHARGE_STATE_PRECHARGE, // 预充电
CHARGE_STATE_CC, // 恒流充电
CHARGE_STATE_CV, // 恒压充电
CHARGE_STATE_DONE, // 充电完成
CHARGE_STATE_FAULT // 故障状态
} ChargeState_TypeDef;
// 充电参数配置
typedef struct {
float charge_current_mA; // 充电电流(mA)
float charge_voltage_V; // 充电截止电压(V)
float precharge_current_mA; // 预充电电流(mA)
float termination_current_mA;// 终止充电电流(mA)
uint8_t max_charge_time_min; // 最大充电时间(分钟)
} ChargeConfig_TypeDef;
// 全局充电配置
ChargeConfig_TypeDef g_ChargeConfig = {
.charge_current_mA = 1000, // 1A 快充
.charge_voltage_V = 4.2, // 标准锂电电压
.precharge_current_mA = 100, // 预充电 100mA
.termination_current_mA = 100, // 终止电流 100mA
.max_charge_time_min = 180 // 最长 3 小时
};
/**
* @brief 初始化充电管理模块
*/
void Charge_Manager_Init(void)
{
// 1. 配置 ADC 用于测量电池电压和充电电流
ADC_Config();
// 2. 配置 GPIO
// CHG_EN: 充电使能控制
// CHG_STAT: 充电状态指示(来自充电 IC)
// BAT_TEMP: 电池温度检测
HAL_GPIO_WritePin(CHG_EN_PORT, CHG_EN_PIN, GPIO_PIN_RESET);
// 3. 配置 PWM 输出(如果充电 IC 支持可调电流)
TIM_PWM_Init();
// 4. 配置中断(充电完成/故障中断)
HAL_GPIO_EXTI_Register_Callback(CHG_STAT_PIN, CHG_Status_IRQ);
}
/**
* @brief 充电过程控制主循环
* @note 状态机实现完整的 CC-CV 充电流程
*/
void Charge_Manager_Task(void)
{
static ChargeState_TypeDef current_state = CHARGE_STATE_IDLE;
static uint32_t charge_start_time = 0;
// 读取电池参数
float battery_voltage = Measure_Battery_Voltage();
float battery_current = Measure_Charge_Current();
float battery_temp = Measure_Battery_Temperature();
// 检查故障条件
if (battery_temp < 0 || battery_temp > 45) {
// 温度异常,停止充电
Charge_Disable();
current_state = CHARGE_STATE_FAULT;
return;
}
if (battery_voltage < 2.0) {
// 电池电压过低,可能损坏
Charge_Disable();
current_state = CHARGE_STATE_FAULT;
return;
}
// 状态机处理
switch(current_state) {
case CHARGE_STATE_IDLE:
// 检测到充电器插入,开始充电
if (Charger_Plugged_In()) {
charge_start_time = HAL_GetTick();
Charge_Enable();
if (battery_voltage < 3.0) {
// 低压电池,先预充电
Set_Charge_Current(g_ChargeConfig.precharge_current_mA);
current_state = CHARGE_STATE_PRECHARGE;
} else {
// 正常充电
Set_Charge_Current(g_ChargeConfig.charge_current_mA);
current_state = CHARGE_STATE_CC;
}
}
break;
case CHARGE_STATE_PRECHARGE:
// 预充电阶段,以小电流充至 3.0V
if (battery_voltage >= 3.0) {
// 切换到恒流充电
Set_Charge_Current(g_ChargeConfig.charge_current_mA);
current_state = CHARGE_STATE_CC;
}
break;
case CHARGE_STATE_CC:
// 恒流充电阶段
if (battery_voltage >= g_ChargeConfig.charge_voltage_V) {
// 达到截止电压,切换到恒压充电
Set_Charge_Voltage(g_ChargeConfig.charge_voltage_V);
current_state = CHARGE_STATE_CV;
}
break;
case CHARGE_STATE_CV:
// 恒压充电阶段
// 当充电电流降至终止电流时,结束充电
if (battery_current <= g_ChargeConfig.termination_current_mA) {
Charge_Disable();
current_state = CHARGE_STATE_DONE;
}
break;
case CHARGE_STATE_DONE:
// 充电完成,进入涓流维护或完全关闭
// 可以定期检测电池电压,进行自放电补偿
break;
case CHARGE_STATE_FAULT:
// 故障状态,等待复位
if (!Charger_Plugged_In()) {
// 拔掉充电器后复位
current_state = CHARGE_STATE_IDLE;
}
break;
}
// 充电超时保护
if (current_state != CHARGE_STATE_IDLE &&
current_state != CHARGE_STATE_DONE &&
current_state != CHARGE_STATE_FAULT) {
if (HAL_GetTick() - charge_start_time >
(g_ChargeConfig.max_charge_time_min * 60 * 1000)) {
Charge_Disable();
current_state = CHARGE_STATE_FAULT;
}
}
// 更新状态指示灯
Update_Charge_LED(current_state);
}
/**
* @brief 设置充电电流
* @param current_mA 目标电流(mA)
*/
void Set_Charge_Current(float current_mA)
{
// 方法 1:通过 DAC 控制充电 IC 的电流设置引脚
DAC_SetVoltage(CHARGE_ISET_DAC, current_mA / 1000.0 * 1000); // 假设 1V/A
// 方法 2:通过 PWM 占空比控制
// 计算占空比并更新 PWM
// 方法 3:如果是数字控制的充电 IC,通过 I2C 配置
// BQ24610_WriteRegister(CHARGE_CURRENT_REG, current_mA);
}
/**
* @brief 设置充电电压
* @param voltage_V 目标电压(V)
*/
void Set_Charge_Voltage(float voltage_V)
{
// 通过 DAC 或 I2C 设置充电 IC 的输出电压
DAC_SetVoltage(CHARGE_VSET_DAC, voltage_V);
}
/**
* @brief 使能充电
*/
void Charge_Enable(void)
{
HAL_GPIO_WritePin(CHG_EN_PORT, CHG_EN_PIN, GPIO_PIN_SET);
}
/**
* @brief 禁用充电
*/
void Charge_Disable(void)
{
HAL_GPIO_WritePin(CHG_EN_PORT, CHG_EN_PIN, GPIO_PIN_RESET);
}
/**
* @brief 测量电池电压
* @return 电池电压值(V)
*/
float Measure_Battery_Voltage(void)
{
uint16_t adc_value = ADC_ReadChannel(BAT_VOLT_ADC);
// 假设 ADC 参考 3.3V,12 位精度,分压电阻 100k:100k(2:1 分压)
float voltage = (adc_value / 4095.0) * 3.3 * 2.0;
return voltage;
}
/**
* @brief 测量充电电流
* @return 充电电流(mA)
*/
float Measure_Charge_Current(void)
{
uint16_t adc_value = ADC_ReadChannel(CHAT_CURRENT_ADC);
// 假设使用电流检测放大器,增益 50,采样电阻 50mΩ
// V_sense = I * 0.05, V_out = V_sense * 50
float voltage = (adc_value / 4095.0) * 3.3;
float current = (voltage / 50.0) / 0.05 * 1000; // 转换为 mA
return current;
}
/**
* @brief 测量电池温度
* @return 温度值(摄氏度)
*/
float Measure_Battery_Temperature(void)
{
uint16_t adc_value = ADC_ReadChannel(BAT_TEMP_ADC);
// NTC 热敏电阻,使用 Steinhart-Hart 方程计算温度
float resistance = Calculate_NTC_Resistance(adc_value);
float temperature_kelvin = 1.0 / (A + B * log(resistance) + C * pow(log(resistance), 3));
return temperature_kelvin - 273.15; // 转换为摄氏度
}
/**
* @brief 充电状态中断回调
*/
void CHG_Status_IRQ(uint16_t GPIO_Pin)
{
if (GPIO_Pin == CHG_STAT_PIN) {
// 充电 IC 的状态变化
// 可以立即读取状态寄存器或设置标志位
}
}
2.1.3 多节电池平衡充电
对于多节串联的锂电池组,需要电池均衡功能来确保各单体电池的一致性:
c
/**
* @brief 被动均衡控制(电阻耗能式)
* @note 对电压较高的电池进行放电均衡
*/
#define CELL_COUNT 4 // 4 串电池
void Cell_Balancing_Task(void)
{
static uint32_t balancing_start_time = 0;
float cell_voltages[CELL_COUNT];
// 读取所有单体电池电压
for(int i = 0; i < CELL_COUNT; i++) {
cell_voltages[i] = Measure_Cell_Voltage(i);
}
// 找出最高和最低电压
float max_voltage = cell_voltages[0];
int max_cell_index = 0;
for(int i = 1; i < CELL_COUNT; i++) {
if(cell_voltages[i] > max_voltage) {
max_voltage = cell_voltages[i];
max_cell_index = i;
}
}
// 如果压差超过阈值,启动均衡
float voltage_diff_threshold = 0.01; // 10mV
for(int i = 0; i < CELL_COUNT; i++) {
if(i == max_cell_index) continue; // 跳过最高电压的电池
float diff = max_voltage - cell_voltages[i];
if(diff > voltage_diff_threshold) {
// 开启该电池的均衡电阻
Enable_Balance_Resistor(i);
} else {
Disable_Balance_Resistor(i);
}
}
// 均衡仅在充电末期进行(所有电池电压 > 4.1V)
if(max_voltage < 4.1) {
Disable_All_Balance_Resistors();
}
}
/**
* @brief 主动均衡控制(电容/电感能量转移式)
* @note 将高能量电池的能量转移到低能量电池
*/
void Active_Balancing_Control(void)
{
// 主动均衡更复杂,需要专用的均衡 IC
// 例如:TI BQ76100、Linear LTC3300
// 1. 通过 SPI/I2C 读取所有电池电压
uint16_t voltages_raw[CELL_COUNT];
AFE_ReadCellVoltages(voltages_raw);
// 2. 计算 SOC(State of Charge)
float soc[CELL_COUNT];
for(int i = 0; i < CELL_COUNT; i++) {
soc[i] = OCV_to_SOC(voltages_raw[i]); // 通过开路电压曲线估算
}
// 3. 根据 SOC 差决定能量转移方向
// 从 SOC 高的电池向 SOC 低的电池转移能量
// 具体实现依赖于硬件拓扑结构
}
2.2 电量计设计
准确的电量显示(SOC, State of Charge)对于用户体验至关重要。常用的电量估算方法有库仑积分法、开路电压法和阻抗跟踪法。
2.2.1 库仑积分法(电流积分)
c
/**
* @brief 库仑积分法电量计
* @note 通过对电流积分计算剩余容量
*/
#include <math.h>
// 电池参数
#define BATTERY_NOMINAL_CAPACITY_mAh 3000 // 标称容量 3000mAh
#define BATTERY_FULL_CAPACITY_mAh 3100 // 实际满电容量(考虑老化)
// 电量计数据结构
typedef struct {
int32_t accumulated_charge_mAh; // 累计电荷量(mAh),可正可负
float soc_percent; // 电量百分比(0-100%)
uint32_t last_update_time; // 上次更新时间
float last_current_mA; // 上次测量的电流
bool is_charging; // 充电标志
} FuelGauge_TypeDef;
FuelGauge_TypeDef g_FuelGauge;
/**
* @brief 电量计初始化
*/
void FuelGauge_Init(void)
{
g_FuelGauge.accumulated_charge_mAh = 0;
g_FuelGauge.soc_percent = 100.0; // 初始假设满电
g_FuelGauge.last_update_time = HAL_GetTick();
g_FuelGauge.last_current_mA = 0;
g_FuelGauge.is_charging = false;
// 从 EEPROM 读取上次保存的 SOC(如果有)
// EEPROM_Read(&g_FuelGauge.accumulated_charge_mAh, ADDR_SOC);
}
/**
* @brief 电量计算主循环(周期性调用,如每秒一次)
*/
void FuelGauge_Task(void)
{
uint32_t current_time = HAL_GetTick();
float delta_time_h = (current_time - g_FuelGauge.last_update_time) / 3600000.0; // 转换为小时
// 1. 读取实时电流(放电为负,充电为正)
float current_mA = Measure_Battery_Current();
g_FuelGauge.is_charging = (current_mA > 0);
// 2. 库仑积分:ΔQ = I × Δt
float delta_charge_mAh = current_mA * delta_time_h;
// 3. 累积电荷量
g_FuelGauge.accumulated_charge_mAh += (int32_t)delta_charge_mAh;
// 4. 限制范围(防止溢出)
if(g_FuelGauge.accumulated_charge_mAh > BATTERY_FULL_CAPACITY_mAh) {
g_FuelGauge.accumulated_charge_mAh = BATTERY_FULL_CAPACITY_mAh;
}
if(g_FuelGauge.accumulated_charge_mAh < 0) {
g_FuelGauge.accumulated_charge_mAh = 0;
}
// 5. 计算 SOC 百分比
g_FuelGauge.soc_percent = (float)g_FuelGauge.accumulated_charge_mAh /
BATTERY_FULL_CAPACITY_mAh * 100.0f;
// 6. 应用补偿(温度、老化、自放电等)
Apply_Temperature_Compensation();
Apply_Self_Discharge_Compensation(delta_time_h);
// 7. 满电/空校准
Calibrate_SOC_Boundaries(current_mA);
// 8. 更新时间戳
g_FuelGauge.last_update_time = current_time;
g_FuelGauge.last_current_mA = current_mA;
// 9. 保存到 EEPROM(可选,避免掉电丢失)
// EEPROM_Write(&g_FuelGauge.accumulated_charge_mAh, ADDR_SOC);
}
/**
* @brief 温度补偿
* @note 低温下电池可用容量降低
*/
void Apply_Temperature_Compensation(void)
{
float temp = Measure_Battery_Temperature();
// 简化模型:低于 0°C 时容量线性下降
if(temp < 0) {
float capacity_factor = 1.0 + (temp / 100.0); // -20°C 时约 80% 容量
if(capacity_factor < 0.5) capacity_factor = 0.5;
g_FuelGauge.soc_percent *= capacity_factor;
}
}
/**
* @brief 自放电补偿
* @param delta_time_h 经过的时间(小时)
*/
void Apply_Self_Discharge_Compensation(float delta_time_h)
{
// 锂电池月自放电率约 2-3%,换算成每小时
float self_discharge_rate_per_hour = 0.03 / (30 * 24);
// 静置时才考虑自放电(小电流判断为静置)
if(fabsf(g_FuelGauge.last_current_mA) < 10) { // 小于 10mA 认为静置
float self_discharge_mAh = BATTERY_NOMINAL_CAPACITY_mAh *
self_discharge_rate_per_hour *
delta_time_h;
g_FuelGauge.accumulated_charge_mAh -= (int32_t)self_discharge_mAh;
if(g_FuelGauge.accumulated_charge_mAh < 0) {
g_FuelGauge.accumulated_charge_mAh = 0;
}
}
}
/**
* @brief SOC 边界校准(满电和空电校准)
* @param current_mA 当前电流
*/
void Calibrate_SOC_Boundaries(float current_mA)
{
float voltage = Measure_Battery_Voltage();
// 满电校准:充电截止时重置为 100%
if(g_FuelGauge.is_charging &&
voltage >= 4.2 &&
current_mA < 100) { // 接近截止电流
g_FuelGauge.accumulated_charge_mAh = BATTERY_FULL_CAPACITY_mAh;
g_FuelGauge.soc_percent = 100.0;
}
// 空电校准:放电截止时重置为 0%
if(!g_FuelGauge.is_charging &&
voltage <= 3.0) { // 接近截止电压
g_FuelGauge.accumulated_charge_mAh = 0;
g_FuelGauge.soc_percent = 0.0;
}
}
/**
* @brief 获取剩余电量百分比
* @return SOC(0-100%)
*/
float FuelGauge_GetSOC(void)
{
return g_FuelGauge.soc_percent;
}
/**
* @brief 获取剩余运行时间估算
* @param load_current_mA 负载电流(mA)
* @return 剩余时间(分钟)
*/
uint32_t FuelGauge_GetRemainingTime(float load_current_mA)
{
if(load_current_mA <= 0) return 0;
float remaining_capacity_mAh = g_FuelGauge.accumulated_charge_mAh;
float remaining_hours = remaining_capacity_mAh / load_current_mA;
return (uint32_t)(remaining_hours * 60);
}
2.2.2 开路电压法(OCV)
c
/**
* @brief OCV-SOC 对照表(3.7V 锂离子电池典型曲线)
* @note 需要通过实验测量得到具体电池的 OCV 曲线
*/
const float OCV_SOC_Table[][2] = {
// {电压 (V), SOC(%)}
{3.0, 0},
{3.3, 5},
{3.5, 10},
{3.6, 20},
{3.7, 40},
{3.75, 50},
{3.8, 60},
{3.9, 75},
{4.0, 85},
{4.1, 95},
{4.2, 100}
};
#define OCV_TABLE_SIZE (sizeof(OCV_SOC_Table)/sizeof(OCV_SOC_Table[0]))
/**
* @brief 通过 OCV 估算 SOC
* @param ocv_voltage 开路电压(V)
* @return SOC(%)
*/
float OCV_to_SOC(float ocv_voltage)
{
// 查找表格,使用线性插值
if(ocv_voltage <= OCV_SOC_Table[0][0]) {
return OCV_SOC_Table[0][1];
}
if(ocv_voltage >= OCV_SOC_Table[OCV_TABLE_SIZE-1][0]) {
return OCV_SOC_Table[OCV_TABLE_SIZE-1][1];
}
// 找到区间
for(int i = 0; i < OCV_TABLE_SIZE - 1; i++) {
if(ocv_voltage >= OCV_SOC_Table[i][0] &&
ocv_voltage <= OCV_SOC_Table[i+1][0]) {
// 线性插值
float ratio = (ocv_voltage - OCV_SOC_Table[i][0]) /
(OCV_SOC_Table[i+1][0] - OCV_SOC_Table[i][0]);
float soc = OCV_SOC_Table[i][1] +
ratio * (OCV_SOC_Table[i+1][1] - OCV_SOC_Table[i][1]);
return soc;
}
}
return 50.0; // 默认值
}
/**
* @brief 结合库仑积分和 OCV 的混合算法
* @note 静置时用 OCV 校准,工作时用库仑积分
*/
void Hybrid_FuelGauge_Task(void)
{
static uint32_t rest_timer = 0;
float current = Measure_Battery_Current();
// 检测是否处于静置状态
if(fabsf(current) < 10) { // 小于 10mA
rest_timer++;
// 静置超过 30 分钟,可以用 OCV 校准
if(rest_timer > 1800) { // 30 分钟
float ocv = Measure_Battery_OCV();
float soc_ocv = OCV_to_SOC(ocv);
// 如果 OCV 估算的 SOC 与当前值相差较大,进行校准
if(fabsf(soc_ocv - g_FuelGauge.soc_percent) > 5) {
g_FuelGauge.soc_percent = soc_ocv;
g_FuelGauge.accumulated_charge_mAh =
(int32_t)(soc_ocv / 100.0 * BATTERY_FULL_CAPACITY_mAh);
}
rest_timer = 0;
}
} else {
rest_timer = 0;
// 工作时使用库仑积分
FuelGauge_Task();
}
}
/**
* @brief 测量电池开路电压
* @note 需要在静置足够长时间后测量
* @return OCV(V)
*/
float Measure_Battery_OCV(void)
{
// 实际上,真正的 OCV 需要静置数小时
// 这里使用简化方法:静置 30 分钟后的电压近似为 OCV
return Measure_Battery_Voltage();
}
2.2.3 专用电量计 IC(如 TI BQ27541)
c
/**
* @brief 使用专用电量计 IC
* @note TI BQ27541、Maxim MAX17048 等集成方案
*/
#include "i2c.h"
#define BQ27541_I2C_ADDR (0x55 << 1)
// BQ27541 寄存器地址
#define REG_CONTROL 0x00
#define REG_SOC 0x2C // 电量百分比
#define REG_VOLTAGE 0x08 // 电池电压
#define REG_CURRENT 0x0A // 电流
#define REG_TEMPERATURE 0x06 // 温度
#define REG_FULL_CAPACITY 0x12 // 满充容量
#define REG_REM_CAPACITY 0x10 // 剩余容量
/**
* @brief 读取电量百分比
* @return SOC(0-100%)
*/
uint8_t BQ27541_ReadSOC(void)
{
uint8_t tx_data[2] = {REG_SOC, 0};
uint8_t rx_data[2];
HAL_I2C_Master_Transmit(&hi2c1, BQ27541_I2C_ADDR, tx_data, 1, 10);
HAL_I2C_Master_Receive(&hi2c1, BQ27541_I2C_ADDR, rx_data, 2, 10);
uint16_t soc = (rx_data[1] << 8) | rx_data[0];
return (uint8_t)soc;
}
/**
* @brief 读取电池电压
* @return 电压(mV)
*/
uint16_t BQ27541_ReadVoltage(void)
{
uint8_t tx_data[2] = {REG_VOLTAGE, 0};
uint8_t rx_data[2];
HAL_I2C_Master_Transmit(&hi2c1, BQ27541_I2C_ADDR, tx_data, 1, 10);
HAL_I2C_Master_Receive(&hi2c1, BQ27541_I2C_ADDR, rx_data, 2, 10);
uint16_t voltage = (rx_data[1] << 8) | rx_data[0];
return voltage; // mV
}
/**
* @brief 读取电流
* @return 电流(mA),正值为充电,负值为放电
*/
int16_t BQ27541_ReadCurrent(void)
{
uint8_t tx_data[2] = {REG_CURRENT, 0};
uint8_t rx_data[2];
HAL_I2C_Master_Transmit(&hi2c1, BQ27541_I2C_ADDR, tx_data, 1, 10);
HAL_I2C_Master_Receive(&hi2c1, BQ27541_I2C_ADDR, rx_data, 2, 10);
int16_t current = (rx_data[1] << 8) | rx_data[0];
return current; // mA
}
/**
* @brief 初始化 BQ27541
*/
void BQ27541_Init(void)
{
// 1. 等待芯片启动
HAL_Delay(100);
// 2. 检查通信是否正常
uint16_t device_type = BQ27541_ReadDeviceType();
if(device_type != 0x0421) {
Error_Handler(); // 设备 ID 不匹配
}
// 3. 配置参数(可选)
// BQ27541_WriteDesignCapacity(3000); // 设置设计容量
}
2.3 电池保护电路
锂电池过充、过放、过流、短路都会造成安全隐患,甚至引发火灾。因此必须设计完善的保护电路。
2.3.1 硬件保护电路
硬件保护通常使用专用保护 IC(如 DW01、S-8261 等)配合 MOSFET 实现:
基本保护功能:
- 过充保护:当单体电池电压超过阈值(如 4.25V)时切断充电回路
- 过放保护:当电压低于阈值(如 2.5V)时切断放电回路
- 过流保护:当放电电流过大时快速切断
- 短路保护:检测到短路时立即关断(微秒级响应)
2.3.2 软件保护实现
c
/**
* @brief 电池保护管理模块
* @note 软件层面的多重保护策略
*/
// 保护阈值定义
#define PROTECTION_OVER_VOLTAGE_V 4.25 // 过压保护点
#define PROTECTION_UNDER_VOLTAGE_V 2.5 // 欠压保护点
#define PROTECTION_OVER_CURRENT_A 5.0 // 过流保护点(5A)
#define PROTECTION_SHORT_CIRCUIT_A 10.0 // 短路保护点
#define PROTECTION_OVER_TEMP_C 60 // 过温保护
#define PROTECTION_UNDER_TEMP_C -10 // 低温保护
// 保护状态标志
typedef struct {
bool over_voltage_flag;
bool under_voltage_flag;
bool over_current_flag;
bool short_circuit_flag;
bool over_temp_flag;
bool under_temp_flag;
bool protection_active;
} ProtectionStatus_TypeDef;
ProtectionStatus_TypeDef g_ProtectionStatus;
/**
* @brief 保护系统初始化
*/
void Battery_Protection_Init(void)
{
memset(&g_ProtectionStatus, 0, sizeof(g_ProtectionStatus));
// 配置比较器用于硬件保护
COMP_Config();
// 配置 MOSFET 驱动
MOSFET_Driver_Init();
// 使能硬件中断保护
HAL_COMP_Start(&hcomp1); // 过压比较器
HAL_COMP_Start(&hcomp2); // 欠压比较器
}
/**
* @brief 保护检测主循环(高频调用,如每 10ms)
*/
void Battery_Protection_Task(void)
{
// 1. 读取所有传感器数据
float cell_voltages[4]; // 假设 4 串电池
for(int i = 0; i < 4; i++) {
cell_voltages[i] = Measure_Cell_Voltage(i);
}
float pack_current = Measure_Pack_Current();
float temperature = Measure_Battery_Temperature();
// 2. 过压保护检查
g_ProtectionStatus.over_voltage_flag = false;
for(int i = 0; i < 4; i++) {
if(cell_voltages[i] > PROTECTION_OVER_VOLTAGE_V) {
g_ProtectionStatus.over_voltage_flag = true;
break;
}
}
// 3. 欠压保护检查
g_ProtectionStatus.under_voltage_flag = false;
for(int i = 0; i < 4; i++) {
if(cell_voltages[i] < PROTECTION_UNDER_VOLTAGE_V) {
g_ProtectionStatus.under_voltage_flag = true;
break;
}
}
// 4. 过流/短路保护检查
float abs_current = fabsf(pack_current);
g_ProtectionStatus.short_circuit_flag = (abs_current >= PROTECTION_SHORT_CIRCUIT_A);
g_ProtectionStatus.over_current_flag = (abs_current >= PROTECTION_OVER_CURRENT_A &&
!g_ProtectionStatus.short_circuit_flag);
// 5. 温度保护检查
g_ProtectionStatus.over_temp_flag = (temperature > PROTECTION_OVER_TEMP_C);
g_ProtectionStatus.under_temp_flag = (temperature < PROTECTION_UNDER_TEMP_C);
// 6. 综合判断是否需要触发保护
g_ProtectionStatus.protection_active =
g_ProtectionStatus.over_voltage_flag ||
g_ProtectionStatus.under_voltage_flag ||
g_ProtectionStatus.over_current_flag ||
g_ProtectionStatus.short_circuit_flag ||
g_ProtectionStatus.over_temp_flag ||
g_ProtectionStatus.under_temp_flag;
// 7. 执行保护动作
if(g_ProtectionStatus.protection_active) {
Execute_Protection_Action();
} else {
// 无故障,恢复正常工作
MOSFET_Enable_Charge();
MOSFET_Enable_Discharge();
}
// 8. 记录故障日志(用于后续分析)
if(g_ProtectionStatus.protection_active) {
Log_Fault_Event();
}
}
/**
* @brief 执行保护动作
*/
void Execute_Protection_Action(void)
{
// 根据故障类型采取不同措施
if(g_ProtectionStatus.short_circuit_flag) {
// 短路:立即切断充放电回路(最快响应)
MOSFET_Disable_All();
}
else if(g_ProtectionStatus.over_current_flag) {
// 过流:切断放电回路
MOSFET_Disable_Discharge();
}
else if(g_ProtectionStatus.over_voltage_flag) {
// 过压:切断充电回路
MOSFET_Disable_Charge();
// 如果正在充电,通知充电器停止
Charger_Stop_Command();
}
else if(g_ProtectionStatus.under_voltage_flag) {
// 欠压:切断放电回路,进入休眠
MOSFET_Disable_Discharge();
System_Enter_LowPower_Mode();
}
else if(g_ProtectionStatus.over_temp_flag || g_ProtectionStatus.under_temp_flag) {
// 温度异常:暂停充放电
MOSFET_Disable_All();
Charger_Stop_Command();
}
}
/**
* @brief 故障恢复检测
* @note 某些故障需要手动复位或满足特定条件才能恢复
*/
void Fault_Recovery_Check(void)
{
// 过流故障恢复:需要电流恢复正常并保持一段时间
if(g_ProtectionStatus.over_current_flag) {
static uint32_t recovery_timer = 0;
if(Measure_Pack_Current() < PROTECTION_OVER_CURRENT_A * 0.8) {
recovery_timer++;
if(recovery_timer > 100) { // 持续 1 秒正常
g_ProtectionStatus.over_current_flag = false;
recovery_timer = 0;
}
} else {
recovery_timer = 0;
}
}
// 欠压故障恢复:需要充电至恢复电压以上
if(g_ProtectionStatus.under_voltage_flag) {
float min_cell_voltage = Get_Min_Cell_Voltage();
if(min_cell_voltage > (PROTECTION_UNDER_VOLTAGE_V + 0.2)) { // 回差 200mV
g_ProtectionStatus.under_voltage_flag = false;
}
}
// 温度故障恢复
if(g_ProtectionStatus.over_temp_flag) {
if(Measure_Battery_Temperature() < (PROTECTION_OVER_TEMP_C - 5)) { // 回差 5°C
g_ProtectionStatus.over_temp_flag = false;
}
}
}
/**
* @brief MOSFET 驱动控制
*/
void MOSFET_Disable_Charge(void)
{
// 关闭充电 MOSFET
HAL_GPIO_WritePin(CHG_MOSFET_PORT, CHG_MOSFET_PIN, GPIO_PIN_RESET);
}
void MOSFET_Disable_Discharge(void)
{
// 关闭放电 MOSFET
HAL_GPIO_WritePin(DSG_MOSFET_PORT, DSG_MOSFET_PIN, GPIO_PIN_RESET);
}
void MOSFET_Disable_All(void)
{
MOSFET_Disable_Charge();
MOSFET_Disable_Discharge();
}
void MOSFET_Enable_Charge(void)
{
if(!g_ProtectionStatus.over_voltage_flag) {
HAL_GPIO_WritePin(CHG_MOSFET_PORT, CHG_MOSFET_PIN, GPIO_PIN_SET);
}
}
void MOSFET_Enable_Discharge(void)
{
if(!g_ProtectionStatus.under_voltage_flag &&
!g_ProtectionStatus.over_current_flag &&
!g_ProtectionStatus.short_circuit_flag) {
HAL_GPIO_WritePin(DSG_MOSFET_PORT, DSG_MOSFET_PIN, GPIO_PIN_SET);
}
}
/**
* @brief 故障日志记录
*/
void Log_Fault_Event(void)
{
// 保存到 FRAM 或 EEPROM
typedef struct {
uint32_t timestamp;
uint8_t fault_type;
float voltage;
float current;
float temperature;
} FaultLog_TypeDef;
static FaultLog_TypeDef fault_log;
fault_log.timestamp = HAL_GetTick();
fault_log.fault_type = 0;
if(g_ProtectionStatus.over_voltage_flag) fault_log.fault_type |= 0x01;
if(g_ProtectionStatus.under_voltage_flag) fault_log.fault_type |= 0x02;
if(g_ProtectionStatus.over_current_flag) fault_log.fault_type |= 0x04;
if(g_ProtectionStatus.short_circuit_flag) fault_log.fault_type |= 0x08;
if(g_ProtectionStatus.over_temp_flag) fault_log.fault_type |= 0x10;
if(g_ProtectionStatus.under_temp_flag) fault_log.fault_type |= 0x20;
fault_log.voltage = Get_Max_Cell_Voltage();
fault_log.current = Measure_Pack_Current();
fault_log.temperature = Measure_Battery_Temperature();
// 写入非易失存储器
// FRAM_Write(&fault_log, FAULT_LOG_ADDR);
}
2.3.3 多级保护架构
在实际应用中,通常采用硬件保护 + 软件保护+保险丝的多级保护策略:
第一级:硬件保护 IC
- 响应速度最快(微秒级)
- 处理短路、严重过流等紧急情况
- 独立于 MCU 工作,即使 MCU 死机也能保护
第二级:MCU 软件保护
- 功能灵活,可配置
- 处理过充、过放、温度等相对缓慢的故障
- 可以实现复杂的保护逻辑和故障记录
第三级:机械/熔断保护
- PTC(自恢复保险丝):过流时电阻急剧增大
- 一次性保险丝:最后防线,不可恢复
- CID(电流切断装置):内部压力过高时永久断开
第 3 章:低功耗测试方法
准确的功耗测试是验证低功耗设计效果的关键。本章介绍常用的测试仪器、测试方法和数据分析技巧。
3.1 电流测量技术
3.1.1 万用表测量法
适用场景:静态电流、较大电流(>10μA)的测量
优点:简单易用,成本低
缺点:采样率低,无法捕捉瞬态电流;电流档位有压降
测试连接:
电源正极 → 万用表电流档正极 → 万用表电流档负极 → 设备电源输入
注意事项:
- 选择合适的量程,从大量程开始逐步下调
- 注意万用表的带宽限制,普通万用表每秒仅几次采样
- 电流档内阻会造成压降,影响设备工作
3.1.2 示波器 + 电流探头测量法
适用场景:动态电流、瞬态电流波形观测
优点:高采样率,可观察电流变化细节;非接触测量不影响电路
缺点:设备昂贵;小电流测量精度有限
推荐设备:
- Tektronix TCP0030A 电流探头(最小 1mA)
- Keysight N2783B 电流探头
3.1.3 专用功耗分析仪
推荐设备:Joulescope、Otii Arc、Nordic Power Profiler
这些设备专为低功耗 IoT 设备设计,具有以下特点:
- 超宽电流量程(从 nA 到 A)
- 高采样率(可达 MHz 级别)
- 同时显示电压、电流、功率
- 自动计算累积电量和平均功耗
Joulescope 使用示例:
python
# Joulescope Python 库使用示例
import pyjoulescope
# 1. 连接设备
js = pyjoulescope.Joulescope()
js.open()
# 2. 配置参数
js.sample_rate = 2000 # 2kHz 采样率
js.range_auto = True # 自动量程
# 3. 开始记录
js.buffer_start()
# 4. 运行测试(例如 1 分钟)
import time
time.sleep(60)
# 5. 停止记录并获取数据
data = js.buffer_stop()
# 6. 分析结果
avg_current = data['current'].mean()
min_current = data['current'].min()
max_current = data['current'].max()
charge_uAh = data['charge_uAh']
print(f"平均电流:{avg_current:.2f} μA")
print(f"最小电流:{min_current:.2f} μA")
print(f"最大电流:{max_current:.2f} mA")
print(f"消耗电荷:{charge_uAh:.2f} μAh")
# 7. 绘制波形
import matplotlib.pyplot as plt
plt.plot(data['time'], data['current'])
plt.xlabel('Time (s)')
plt.ylabel('Current (μA)')
plt.title('Current Consumption Profile')
plt.show()
js.close()
3.1.4 分流电阻 + 高精度 ADC 测量
对于预算有限的情况,可以使用精密分流电阻配合高精度 ADC 进行测量:
c
/**
* @brief 基于分流电阻的电流测量电路
* @note 适用于自制测试设备
*/
// 电路设计:
// 电源 → 分流电阻 (0.1Ω) → 负载
// ↓
// 差分放大器 (INA219)
// ↓
// MCU ADC
#include "ina219.h"
INA219_HandleTypeDef hina219;
/**
* @brief INA219 电流检测芯片配置
*/
void Current_Sense_Init(void)
{
// 配置参数
INA219_ConfigTypeDef config = {0};
config.BusVoltageRange = INA219_BUSVOLTAGERANGE_32V;
config.Gain = INA219_GAIN_1DIV40MV; // ±40mV 量程
config.ADCResolution = INA219_ADCRES_12BIT;
config.SamplingRate = INA219_SAMPLINGRATE_128; // 128 次平均
// 分流电阻值(关键参数,决定测量范围和精度)
// Rshunt = 0.1Ω, 功率 1W
// 最大电流:Imax = sqrt(P/R) = sqrt(1/0.1) = 3.16A
// 满量程电压:40mV → Imax = 40mV / 0.1Ω = 400mA
config.ShuntResistance_mOhms = 100; // 0.1Ω = 100mΩ
if(HAL_INA219_Init(&hina219, &config) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief 读取电流值
* @return 电流(mA)
*/
float Measure_Current_mA(void)
{
float current_mA;
HAL_INA219_GetCurrent(&hina219, ¤t_mA);
return current_mA;
}
/**
* @brief 读取总线电压
* @return 电压(V)
*/
float Measure_Bus_Voltage(void)
{
float voltage_V;
HAL_INA219_GetBusVoltage(&hina219, &voltage_V);
return voltage_V;
}
/**
* @brief 读取功率
* @return 功率(mW)
*/
float Measure_Power_mW(void)
{
float power_mW;
HAL_INA219_GetPower(&hina219, &power_mW);
return power_mW;
}
/**
* @brief 连续记录电流数据(用于分析)
*/
void Log_Current_Data(void)
{
#define SAMPLE_COUNT 10000
float current_samples[SAMPLE_COUNT];
uint32_t timestamps[SAMPLE_COUNT];
// 高速采样(例如 10kHz)
for(int i = 0; i < SAMPLE_COUNT; i++) {
current_samples[i] = Measure_Current_mA();
timestamps[i] = HAL_GetTick();
// 延时控制采样率
for(volatile int j = 0; j < 100; j++); // 简单延时
}
// 通过 UART 发送到 PC 进行分析
for(int i = 0; i < SAMPLE_COUNT; i++) {
printf("%lu,%f\n", timestamps[i], current_samples[i]);
}
}
3.2 功耗优化对比
在进行功耗优化前后,需要进行系统的对比测试来验证优化效果。
3.2.1 测试用例设计
c
/**
* @brief 功耗测试场景定义
* @note 覆盖设备的各种工作状态
*/
typedef enum {
TEST_CASE_DEEP_SLEEP, // 深度睡眠电流
TEST_CASE_LIGHT_SLEEP, // 浅睡眠电流
TEST_CASE_ACTIVE_RUN, // 全速运行电流
TEST_CASE_SENSOR_READ, // 传感器采集电流
TEST_CASE_BLE_TX, // 蓝牙发送电流
TEST_CASE_BLE_RX, // 蓝牙接收电流
TEST_CASE_WIFI_CONNECT, // WiFi 连接电流
TEST_CASE_WIFI_TX, // WiFi 发送电流
TEST_CASE_PEAK_CURRENT, // 峰值电流
TEST_CASE_AVERAGE_24H // 24 小时平均电流
} TestCase_TypeDef;
/**
* @brief 自动化功耗测试框架
*/
void Automated_Power_Test(TestCase_TypeDef test_case)
{
PowerMeter_Init();
PowerMeter_StartLogging(1000); // 1kHz 采样
switch(test_case) {
case TEST_CASE_DEEP_SLEEP:
printf("Testing Deep Sleep Current...\n");
MCU_Enter_DeepSleep();
Delay_ms(5000); // 等待稳定
Record_Min_Current();
break;
case TEST_CASE_ACTIVE_RUN:
printf("Testing Active Run Current...\n");
// 运行典型工作负载
for(int i = 0; i < 1000; i++) {
__NOP();
Sensor_Read();
Data_Process();
}
Record_Avg_Current();
break;
case TEST_CASE_BLE_TX:
printf("Testing BLE TX Current...\n");
BLE_Connect();
BLE_SendPacket(test_data);
Record_Peak_And_Avg();
BLE_Disconnect();
break;
// ... 其他测试用例
}
PowerMeter_StopLogging();
Save_Test_Result(test_case);
}
/**
* @brief 对比优化前后的测试结果
*/
void Compare_Power_Optimization(void)
{
// 测试数据结构
typedef struct {
const char* test_name;
float before_uA; // 优化前
float after_uA; // 优化后
float improvement;// 改善百分比
} PowerTestResult_TypeDef;
PowerTestResult_TypeDef results[] = {
{"Deep Sleep", 50.0, 5.2, 0},
{"Light Sleep", 200.0, 45.0, 0},
{"Active Run", 15.0, 8.5, 0},
{"BLE TX Peak", 45.0, 38.0, 0},
{"Average 24h", 120.0, 25.0, 0},
};
// 计算改善比例
printf("\n=== Power Optimization Results ===\n\n");
for(int i = 0; i < 5; i++) {
results[i].improvement = (results[i].before_uA - results[i].after_uA) /
results[i].before_uA * 100.0f;
printf("%-15s: %8.2f μA -> %8.2f μA (%.1f%% 改善)\n",
results[i].test_name,
results[i].before_uA,
results[i].after_uA,
results[i].improvement);
}
// 计算整体续航提升
float avg_before = 120.0; // μA
float avg_after = 25.0; // μA
float battery_capacity_mAh = 3000; // 3000mAh
float life_before_h = battery_capacity_mAh / (avg_before / 1000.0);
float life_after_h = battery_capacity_mAh / (avg_after / 1000.0);
printf("\n续航时间对比:\n");
printf("优化前:%.1f 小时 (%.1f 天)\n", life_before_h, life_before_h/24);
printf("优化后:%.1f 小时 (%.1f 天)\n", life_after_h, life_after_h/24);
printf("提升倍数:%.1fx\n", life_after_h / life_before_h);
}
/*
预期输出:
=== Power Optimization Results ===
Deep Sleep : 50.00 μA -> 5.20 μA (89.6% 改善)
Light Sleep : 200.00 μA -> 45.00 μA (77.5% 改善)
Active Run : 15.00 μA -> 8.50 μA (43.3% 改善)
BLE TX Peak : 45.00 μA -> 38.00 μA (15.6% 改善)
Average 24h : 120.00 μA -> 25.00 μA (79.2% 改善)
续航时间对比:
优化前:25.0 小时 (1.0 天)
优化后:120.0 小时 (5.0 天)
提升倍数:4.8x
*/
3.2.2 功耗分解分析
c
/**
* @brief 系统各模块功耗分解
* @note 识别主要功耗来源,指导优化方向
*/
void Power_Budget_Analysis(void)
{
printf("=== Power Budget Breakdown ===\n\n");
// 各子系统电流消耗(示例数据)
float mcu_sleep = 5.2; // μA
float sensor_standby = 2.0; // μA
float ble_sleep = 1.5; // μA
float ldo_quiescent = 3.5; // μA
float leakage = 0.8; // μA
float total_sleep = mcu_sleep + sensor_standby + ble_sleep +
ldo_quiescent + leakage;
printf("睡眠状态功耗分解:\n");
printf(" MCU: %.1f μA (%.1f%%)\n", mcu_sleep,
mcu_sleep/total_sleep*100);
printf(" Sensor: %.1f μA (%.1f%%)\n", sensor_standby,
sensor_standby/total_sleep*100);
printf(" BLE: %.1f μA (%.1f%%)\n", ble_sleep,
ble_sleep/total_sleep*100);
printf(" LDO 静态电流: %.1f μA (%.1f%%)\n", ldo_quiescent,
ldo_quiescent/total_sleep*100);
printf(" 漏电流: %.1f μA (%.1f%%)\n", leakage,
leakage/total_sleep*100);
printf(" ------------------------\n");
printf(" 总计: %.1f μA\n\n", total_sleep);
printf("优化建议:\n");
printf("1. LDO 静态电流占比最高,考虑更换为纳米功耗 LDO\n");
printf("2. MCU 已优化到较低水平\n");
printf("3. 传感器可在睡眠时完全断电\n");
}
3.3 续航测试方法
3.3.1 理论续航估算
c
/**
* @brief 电池续航时间计算器
* @param battery_capacity_mAh 电池容量(mAh)
* @param avg_current_uA 平均工作电流(μA)
* @return 续航时间(小时)
*/
float Calculate_Battery_Life(float battery_capacity_mAh, float avg_current_uA)
{
// 考虑电池放电效率(通常 80-90%)
float efficiency = 0.85;
// 考虑温度影响(低温降低容量)
float temp_factor = 1.0; // 25°C 时为 1.0
// 计算
float effective_capacity = battery_capacity_mAh * efficiency * temp_factor;
float avg_current_mA = avg_current_uA / 1000.0;
float battery_life_hours = effective_capacity / avg_current_mA;
return battery_life_hours;
}
/**
* @brief 复杂工作模式下的平均电流计算
*/
float Calculate_Average_Current(void)
{
// 定义设备的工作周期和各阶段电流
typedef struct {
const char* state_name;
float current_mA; // 该状态电流
float duration_sec; // 持续时间
float frequency; // 每小时发生次数
} WorkState_TypeDef;
WorkState_TypeDef states[] = {
{"Deep Sleep", 0.005, 0, 0}, // 基础睡眠
{"Sensor Read", 2.5, 0.5, 60}, // 每分钟读一次传感器
{"BLE Adv", 8.0, 0.1, 60}, // 广播 0.1 秒
{"BLE TX", 15.0, 0.05, 10}, // 每 6 分钟发一次数据
{"WiFi Connect",80.0, 3.0, 1}, // 每小时连一次 WiFi
{"WiFi TX", 120.0, 2.0, 1}, // 发送数据
};
float total_charge_mAh = 0;
float total_time_hours = 1.0; // 计算 1 小时的平均
// 计算每个状态的电荷消耗
for(int i = 0; i < 6; i++) {
float charge_per_event = states[i].current_mA *
(states[i].duration_sec / 3600.0);
float hourly_charge = charge_per_event * states[i].frequency;
total_charge_mAh += hourly_charge;
printf("%-15s: %.2f mAh/hour\n",
states[i].state_name, hourly_charge);
}
// 平均电流 = 总电荷 / 时间
float avg_current_mA = total_charge_mAh / total_time_hours;
printf("\n平均电流:%.2f mA (%.0f μA)\n",
avg_current_mA, avg_current_mA * 1000);
return avg_current_mA * 1000; // 返回 μA
}
/**
* @brief 完整续航估算示例
*/
void Battery_Life_Estimation_Example(void)
{
float battery_capacity = 3000; // 3000mAh 锂电池
float avg_current = Calculate_Average_Current();
float life_hours = Calculate_Battery_Life(battery_capacity, avg_current);
printf("\n=== 续航估算 ===\n");
printf("电池容量:%.0f mAh\n", battery_capacity);
printf("平均电流:%.0f μA\n", avg_current);
printf("预计续航:%.1f 小时 (%.1f 天)\n",
life_hours, life_hours / 24);
}
3.3.2 实际续航测试
c
/**
* @brief 长期续航测试记录器
* @note 使用数据记录仪或功耗分析仪进行实测
*/
void Long_Duration_Battery_Test(void)
{
// 测试设置
printf("=== 电池续航实测方案 ===\n\n");
printf("测试设备:\n");
printf("- 功耗分析仪:Joulescope / Otii Arc\n");
printf("- 采样率:1Hz(长周期测试)\n");
printf("- 测试时长:至少一个完整充放电周期\n\n");
printf("测试步骤:\n");
printf("1. 将设备连接至功耗仪\n");
printf("2. 充满电池至 100%\n");
printf("3. 启动设备正常运行程序\n");
printf("4. 开始连续记录电压、电流\n");
printf("5. 记录至设备因低压关机\n");
printf("6. 分析数据,提取以下指标:\n");
printf(" - 总运行时间\n");
printf(" - 平均电流\n");
printf(" - 不同工作模式的占比\n");
printf(" - 电池放电曲线\n\n");
printf("数据分析要点:\n");
printf("- 对比理论估算和实际测试结果\n");
printf("- 识别异常的高功耗事件\n");
printf("- 分析电池电压下降趋势\n");
printf("- 评估低电量保护策略的有效性\n");
}
/**
* @brief 加速寿命测试(ALT)
* @note 通过提高工作频率加速电池耗尽,外推正常使用条件下的续航
*/
void Accelerated_Life_Test(void)
{
// 方法:将设备的工作频率提高 N 倍
// 例如:原本每小时上报一次数据,改为每分钟上报一次
printf("加速因子计算:\n");
printf("正常工作:每小时 1 次数据上报\n");
printf("加速测试:每分钟 1 次数据上报\n");
printf("加速因子 = 60x\n\n");
printf("如果加速测试下续航时间为 T_acc,\n");
printf("则正常续航时间估算为:T_normal = T_acc × 60\n\n");
printf("注意:加速测试不能完全反映自放电等时间相关效应\n");
}
3.3.3 测试报告模板
markdown
## 低功耗测试报告
### 1. 测试概述
- 设备型号:XXX
- 电池规格:3.7V/3000mAh 锂离子电池
- 测试日期:2024-XX-XX
- 测试人员:XXX
- 测试仪器:Joulescope(固件 v2.1)
### 2. 测试结果汇总
| 测试项目 | 优化前 | 优化后 | 改善幅度 |
|---------|--------|--------|----------|
| 深度睡眠电流 | 50 μA | 5.2 μA | 89.6% |
| 浅睡眠电流 | 200 μA | 45 μA | 77.5% |
| 主动运行电流 | 15 mA | 8.5 mA | 43.3% |
| BLE 发送峰值 | 45 mA | 38 mA | 15.6% |
| 24 小时平均电流 | 120 μA | 25 μA | 79.2% |
### 3. 续航时间对比
**理论估算:**
- 优化前:25 小时(1.0 天)
- 优化后:120 小时(5.0 天)
- **提升倍数:4.8 倍**
**实际测试:**
- 测试方法:连续运行至电池耗尽
- 优化后续航:115 小时(4.8 天)
- 与理论值偏差:-4.2%
### 4. 功耗分解(睡眠状态)
| 组件 | 电流 (μA) | 占比 |
|------|-----------|------|
| MCU | 5.2 | 42% |
| 传感器 | 2.0 | 16% |
| BLE 芯片 | 1.5 | 12% |
| LDO | 3.5 | 28% |
| 漏电 | 0.8 | 6% |
| **总计** | **12.5** | **100%** |
### 5. 关键发现
1. **主要优化成果:**
- 优化 MCU 休眠模式,睡眠电流从 50μA降至 5μA
- 更换低静态电流 LDO(从 20μA降至 3.5μA)
- 优化 BLE 广播策略,减少占空比
2. **待优化项:**
- LDO 静态电流仍占总睡眠功耗的 28%,考虑使用更低 IQ 的 LDO
- 传感器可在睡眠时完全断电
3. **异常发现:**
- 偶发尖峰电流(约 80mA,持续 10ms),需进一步调查原因
### 6. 结论
通过系统性的低功耗优化,设备续航从 1 天提升至 5 天,达到预期目标。主要优化措施有效,建议在下一代产品中继续优化电源器件选型。
附录
附录 A:常用低功耗元器件推荐
超低功耗 LDO:
- Texas Instruments TPS782: Iq = 500nA
- Analog Devices ADP150: Iq = 1μA
- Maxim MAX8867: Iq = 15μA
低功耗 MCU:
- TI MSP430: active 100μA/MHz, sleep 0.5μA
- ST STM32L4: active 100μA/MHz, sleep 1.2μA
- Silicon Labs EFM32: active 36μA/MHz, sleep 0.5μA
低功耗运放:
- TI TLV881: 330nA/ch
- ADI ADA4505: 10μA/ch
电池保护 IC:
- DW01A: 经典单节锂电保护
- Seiko S-8261: 高精度过充检测
附录 B:相关标准和规范
- IEC 62133: 便携式密封二次电池安全标准
- UN 38.3: 锂电池运输安全测试
- GB/T 18287: 中国手机用锂离子电池标准
- IEEE 1625/1725: 可充电电池系统标准
附录 C:参考资料
- 《Battery Management Systems》by Gregory L. Plett
- TI BQ 系列 BMS 芯片数据手册
- ST STM32 低功耗应用笔记 (AN4553)
- Nordic nRF52 低功耗设计指南
- 《Portable Power Design》by Jim Williams