低功耗设计与BMS开发指南

低功耗设计与 BMS 开发指南

目录

  1. 消费电子低功耗技术(#第 1 章消费电子低功耗技术)
    • 1.1 MCU 休眠模式配置
    • 1.2 外设时钟控制
    • 1.3 无线模块间歇唤醒
  2. 锂电池管理系统(BMS)设计(#第 2 章锂电池管理系统 design)
    • 2.1 充电管理
    • 2.2 电量计设计
    • 2.3 电池保护电路
  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 三种低功耗模式的配置方法:

  1. 睡眠模式配置 :通过清除 SLEEPDEEP 位来选择普通睡眠模式。此模式下 CPU 停止但外设继续运行,适合等待中断事件的场景。

  2. 深度睡眠模式配置 :设置 SLEEPDEEP 位并配置低功耗调节器。此模式下大部分高速时钟关闭,仅保留低速时钟(LSI/LSE),功耗大幅降低。

  3. 待机模式配置:这是最低功耗的模式,几乎所有电路都关闭,仅保留唤醒引脚和待机电路。需要注意此模式会丢失 SRAM 中的数据。

  4. 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 的低功耗设计具有以下特点:

  1. Light Sleep 模式:CPU 暂停但 RTC 内存保持,WiFi/蓝牙基带也暂停。唤醒后可以快速恢复执行,适合周期性任务。

  2. Deep Sleep 模式:只有 RTC 控制器和 RTC 内存运行,主系统完全关闭。功耗可低至 10μA 级别。

  3. 多种唤醒源:支持定时器、外部 GPIO、触摸传感器、ULP 协处理器等多种唤醒方式。

  4. RTC GPIO 保持:在 Deep Sleep 期间保持 GPIO 状态,避免对外部电路产生影响。

  5. 无线模块节能: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)
    {
        // 等待时钟源稳定
    }
}

代码说明:

外设时钟管理的核心思想是:

  1. 按需分配:仅在需要时开启外设时钟。例如,ADC 只在采集时开启,采集完成后立即关闭。

  2. 反初始化 :关闭外设时钟前,先调用 HAL_xxx_DeInit() 函数将外设恢复到默认状态,避免引脚悬空或意外行为。

  3. 动态调频:根据应用负载动态调整 CPU 频率。轻载时使用低频降低功耗,需要高性能时切换到高频。

  4. 时钟源选择:内部时钟(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();
    }
}

无线模块节能要点总结:

  1. 减少工作时间占比:无线模块工作时电流可能高达 10-50mA,而睡眠时仅几微安。因此要最大化睡眠时间的占比。

  2. 优化连接参数:增加 BLE 连接间隔、使用从机延迟、增大 Wi-Fi DTIM 周期都可以降低功耗,但会增加延迟。

  3. 智能唤醒策略:使用定时器周期性唤醒,或者在检测到特定事件(如传感器超限)时才唤醒通信。

  4. 快速传输:预先准备好要发送的数据,唤醒后尽快完成传输并返回睡眠状态。


第 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)的测量

优点:简单易用,成本低

缺点:采样率低,无法捕捉瞬态电流;电流档位有压降

复制代码
测试连接:
电源正极 → 万用表电流档正极 → 万用表电流档负极 → 设备电源输入

注意事项:

  1. 选择合适的量程,从大量程开始逐步下调
  2. 注意万用表的带宽限制,普通万用表每秒仅几次采样
  3. 电流档内阻会造成压降,影响设备工作
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, &current_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:参考资料

  1. 《Battery Management Systems》by Gregory L. Plett
  2. TI BQ 系列 BMS 芯片数据手册
  3. ST STM32 低功耗应用笔记 (AN4553)
  4. Nordic nRF52 低功耗设计指南
  5. 《Portable Power Design》by Jim Williams

相关推荐
老师我太想进步了20261 小时前
【数据结构-8】栈的实现
c语言·数据结构·算法
Risehuxyc1 小时前
来自PHP项目devnexen的回信
开发语言·php
FRing032 小时前
vue2干货总结10(json-server、vant-ui、postcss插件、axios二次封装、图形验证码、toast轻提示)
开发语言·前端·vue.js·ui·json·vue2·postcss
LCG元2 小时前
串口乱码,先算波特率误差再动代码
c语言·嵌入式
我是大猴子2 小时前
分析sss
开发语言
geats人山人海2 小时前
现代c++4.1
java·开发语言·c++
布莱克6053 小时前
Swift 字符串详解:从基础用法到性能与最佳实践
服务器·开发语言·ssh·字符串·swift
饿了吃洗衣凝珠4 小时前
SELinux
服务器·开发语言·php
蜗牛一步步往上爬4 小时前
第四章 更多的bash shell命令
linux·开发语言·bash