402 lines
12 KiB
C
402 lines
12 KiB
C
/*
|
|
* SPDX-FileCopyrightText: 2024-2026 Espressif Systems (Shanghai) CO LTD
|
|
*
|
|
* SPDX-License-Identifier: Apache-2.0
|
|
*/
|
|
|
|
#include "platform.h"
|
|
|
|
#include <limits.h>
|
|
#include <stdint.h>
|
|
#include <string.h>
|
|
|
|
#include "driver/gpio.h"
|
|
#include "esp_adc/adc_cali.h"
|
|
#include "esp_adc/adc_cali_scheme.h"
|
|
#include "esp_adc/adc_oneshot.h"
|
|
#include "esp_log.h"
|
|
#include "esp_rom_sys.h"
|
|
#include "esp_timer.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/portmacro.h"
|
|
#include "freertos/semphr.h"
|
|
#include "platform_battery_internal.h"
|
|
#include "sdkconfig.h"
|
|
|
|
#if CONFIG_TQ_BATTERY_ENABLE
|
|
|
|
/*
|
|
* 每次采16个样本并裁掉最低/最高各4个，剩余8个取均值；200us 间隔用于跨越短促
|
|
* 开关噪声。2500-4500mV 只是硬件合理性范围，不是 SOC 阈值；越界样本标记无效，
|
|
* domain 层不得把它直接解释为没电。
|
|
*/
|
|
#define BATTERY_ADC_SAMPLE_COUNT 16
|
|
#define BATTERY_ADC_TRIM_COUNT 4
|
|
#define BATTERY_VALID_MIN_MV 2500
|
|
#define BATTERY_VALID_MAX_MV 4500
|
|
#define BATTERY_ADC_SAMPLE_DELAY_US 200
|
|
|
|
static const char *TAG = "platform_battery";
|
|
static adc_oneshot_unit_handle_t s_adc_handle;
|
|
static adc_cali_handle_t s_cali_handle;
|
|
static adc_channel_t s_adc_channel;
|
|
static bool s_initialized;
|
|
static bool s_inputs_initialized;
|
|
static StaticSemaphore_t s_adc_lock_buffer;
|
|
static SemaphoreHandle_t s_adc_lock;
|
|
static portMUX_TYPE s_adc_lock_init_guard = portMUX_INITIALIZER_UNLOCKED;
|
|
static portMUX_TYPE s_state_lock = portMUX_INITIALIZER_UNLOCKED;
|
|
static uint16_t s_load_ref_count[PLATFORM_BATTERY_LOAD_COUNT];
|
|
static int64_t s_cooldown_until_us;
|
|
|
|
/* ADC 读取可能跨任务发生，使用有界互斥等待防止采样路径无限阻塞。 */
|
|
static bool lock_adc(void)
|
|
{
|
|
if (s_adc_lock == NULL) {
|
|
portENTER_CRITICAL(&s_adc_lock_init_guard);
|
|
if (s_adc_lock == NULL) {
|
|
s_adc_lock = xSemaphoreCreateMutexStatic(&s_adc_lock_buffer);
|
|
}
|
|
portEXIT_CRITICAL(&s_adc_lock_init_guard);
|
|
}
|
|
return s_adc_lock != NULL &&
|
|
xSemaphoreTake(s_adc_lock, pdMS_TO_TICKS(100)) == pdTRUE;
|
|
}
|
|
|
|
static void unlock_adc(void)
|
|
{
|
|
(void)xSemaphoreGive(s_adc_lock);
|
|
}
|
|
|
|
static uint64_t gpio_mask(int gpio_num)
|
|
{
|
|
return 1ULL << (unsigned)gpio_num;
|
|
}
|
|
|
|
static void sort_ints(int *values, size_t count)
|
|
{
|
|
for (size_t i = 1; i < count; ++i) {
|
|
int value = values[i];
|
|
size_t j = i;
|
|
while (j > 0U && values[j - 1U] > value) {
|
|
values[j] = values[j - 1U];
|
|
--j;
|
|
}
|
|
values[j] = value;
|
|
}
|
|
}
|
|
|
|
static esp_err_t create_calibration(adc_unit_t unit, adc_channel_t channel)
|
|
{
|
|
/* 优先曲线拟合，芯片不支持时回退到线性拟合校准方案。 */
|
|
#if ADC_CALI_SCHEME_CURVE_FITTING_SUPPORTED
|
|
{
|
|
adc_cali_curve_fitting_config_t config = {
|
|
.unit_id = unit,
|
|
.chan = channel,
|
|
.atten = ADC_ATTEN_DB_12,
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
};
|
|
esp_err_t err = adc_cali_create_scheme_curve_fitting(&config, &s_cali_handle);
|
|
if (err == ESP_OK) {
|
|
return ESP_OK;
|
|
}
|
|
ESP_LOGW(TAG, "Curve-fitting ADC calibration unavailable: %s", esp_err_to_name(err));
|
|
}
|
|
#endif
|
|
|
|
#if ADC_CALI_SCHEME_LINE_FITTING_SUPPORTED
|
|
{
|
|
adc_cali_line_fitting_config_t config = {
|
|
.unit_id = unit,
|
|
.atten = ADC_ATTEN_DB_12,
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
.default_vref = 0,
|
|
};
|
|
esp_err_t err = adc_cali_create_scheme_line_fitting(&config, &s_cali_handle);
|
|
if (err == ESP_OK) {
|
|
return ESP_OK;
|
|
}
|
|
ESP_LOGW(TAG, "Line-fitting ADC calibration unavailable: %s", esp_err_to_name(err));
|
|
}
|
|
#endif
|
|
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
/* 调用者持有 ADC/输入互斥锁；数字输入可独立初始化，不依赖 ADC 校准成功。 */
|
|
static esp_err_t configure_charge_inputs_locked(void)
|
|
{
|
|
if (s_inputs_initialized) {
|
|
return ESP_OK;
|
|
}
|
|
if (!GPIO_IS_VALID_GPIO(CONFIG_TQ_BATTERY_CHARGE_GPIO) ||
|
|
!GPIO_IS_VALID_GPIO(CONFIG_TQ_BATTERY_FULL_GPIO) ||
|
|
CONFIG_TQ_BATTERY_CHARGE_GPIO == CONFIG_TQ_BATTERY_FULL_GPIO ||
|
|
CONFIG_TQ_BATTERY_ADC_GPIO == CONFIG_TQ_BATTERY_CHARGE_GPIO ||
|
|
CONFIG_TQ_BATTERY_ADC_GPIO == CONFIG_TQ_BATTERY_FULL_GPIO) {
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
gpio_config_t config = {
|
|
.pin_bit_mask = gpio_mask(CONFIG_TQ_BATTERY_CHARGE_GPIO) |
|
|
gpio_mask(CONFIG_TQ_BATTERY_FULL_GPIO),
|
|
.mode = GPIO_MODE_INPUT,
|
|
.pull_up_en = GPIO_PULLUP_ENABLE,
|
|
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
|
.intr_type = GPIO_INTR_DISABLE,
|
|
};
|
|
esp_err_t err = gpio_config(&config);
|
|
if (err == ESP_OK) {
|
|
s_inputs_initialized = true;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
esp_err_t platform_battery_read_charge_inputs(platform_battery_charge_inputs_t *out_inputs)
|
|
{
|
|
if (out_inputs == NULL) {
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
memset(out_inputs, 0, sizeof(*out_inputs));
|
|
if (!lock_adc()) {
|
|
return ESP_ERR_TIMEOUT;
|
|
}
|
|
esp_err_t err = configure_charge_inputs_locked();
|
|
if (err == ESP_OK) {
|
|
out_inputs->charge_level = gpio_get_level(CONFIG_TQ_BATTERY_CHARGE_GPIO);
|
|
out_inputs->full_level = gpio_get_level(CONFIG_TQ_BATTERY_FULL_GPIO);
|
|
out_inputs->valid = true;
|
|
}
|
|
unlock_adc();
|
|
return err;
|
|
}
|
|
|
|
esp_err_t platform_battery_init(void)
|
|
{
|
|
if (!lock_adc()) {
|
|
return ESP_ERR_TIMEOUT;
|
|
}
|
|
if (s_initialized) {
|
|
unlock_adc();
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t input_err = configure_charge_inputs_locked();
|
|
if (input_err != ESP_OK) {
|
|
unlock_adc();
|
|
return input_err;
|
|
}
|
|
|
|
adc_unit_t unit = ADC_UNIT_1;
|
|
adc_channel_t channel = ADC_CHANNEL_0;
|
|
esp_err_t err = adc_oneshot_io_to_channel(CONFIG_TQ_BATTERY_ADC_GPIO,
|
|
&unit,
|
|
&channel);
|
|
/* 新板 GPIO17 属于 ADC2；通道和校准均使用 IDF 返回的实际单元。
|
|
* ADC2 仲裁/读取失败继续向上传播，不能把失败样本当作低电量。 */
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(TAG,
|
|
"Battery ADC GPIO%d is not a supported ADC input: %s",
|
|
CONFIG_TQ_BATTERY_ADC_GPIO,
|
|
esp_err_to_name(err));
|
|
unlock_adc();
|
|
return err;
|
|
}
|
|
|
|
adc_oneshot_unit_init_cfg_t unit_config = {
|
|
.unit_id = unit,
|
|
.ulp_mode = ADC_ULP_MODE_DISABLE,
|
|
};
|
|
err = adc_oneshot_new_unit(&unit_config, &s_adc_handle);
|
|
if (err != ESP_OK) {
|
|
unlock_adc();
|
|
return err;
|
|
}
|
|
|
|
adc_oneshot_chan_cfg_t channel_config = {
|
|
.atten = ADC_ATTEN_DB_12,
|
|
.bitwidth = ADC_BITWIDTH_DEFAULT,
|
|
};
|
|
err = adc_oneshot_config_channel(s_adc_handle, channel, &channel_config);
|
|
if (err != ESP_OK) {
|
|
(void)adc_oneshot_del_unit(s_adc_handle);
|
|
s_adc_handle = NULL;
|
|
unlock_adc();
|
|
return err;
|
|
}
|
|
|
|
err = create_calibration(unit, channel);
|
|
if (err != ESP_OK) {
|
|
(void)adc_oneshot_del_unit(s_adc_handle);
|
|
s_adc_handle = NULL;
|
|
unlock_adc();
|
|
return err;
|
|
}
|
|
|
|
s_adc_channel = channel;
|
|
s_initialized = true;
|
|
ESP_LOGI(TAG,
|
|
"Battery monitor ready ADC_GPIO=%d divider=%d/%d charge_GPIO=%d",
|
|
CONFIG_TQ_BATTERY_ADC_GPIO,
|
|
CONFIG_TQ_BATTERY_DIVIDER_HIGH_OHM,
|
|
CONFIG_TQ_BATTERY_DIVIDER_LOW_OHM,
|
|
CONFIG_TQ_BATTERY_CHARGE_GPIO);
|
|
unlock_adc();
|
|
return ESP_OK;
|
|
}
|
|
|
|
static void snapshot_load_state(bool *out_active, bool *out_cooldown)
|
|
{
|
|
/* active 表示当前高负载，cooldown 表示负载刚结束且电压尚未完全恢复。 */
|
|
bool active = false;
|
|
int64_t cooldown_until_us = 0;
|
|
|
|
portENTER_CRITICAL(&s_state_lock);
|
|
for (size_t i = 0; i < PLATFORM_BATTERY_LOAD_COUNT; ++i) {
|
|
if (s_load_ref_count[i] > 0U) {
|
|
active = true;
|
|
break;
|
|
}
|
|
}
|
|
cooldown_until_us = s_cooldown_until_us;
|
|
portEXIT_CRITICAL(&s_state_lock);
|
|
|
|
*out_active = active;
|
|
*out_cooldown = !active && esp_timer_get_time() < cooldown_until_us;
|
|
}
|
|
|
|
esp_err_t platform_battery_read_sample(platform_battery_sample_t *out_sample)
|
|
{
|
|
/* 多次采样排序后去除两端异常值，以降低电机和音频负载造成的瞬态噪声。 */
|
|
if (out_sample == NULL) {
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
memset(out_sample, 0, sizeof(*out_sample));
|
|
|
|
esp_err_t err = platform_battery_init();
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
if (!lock_adc()) {
|
|
return ESP_ERR_TIMEOUT;
|
|
}
|
|
|
|
int raw = 0;
|
|
for (size_t i = 0; i < 4U; ++i) {
|
|
err = adc_oneshot_read(s_adc_handle, s_adc_channel, &raw);
|
|
if (err != ESP_OK) {
|
|
unlock_adc();
|
|
return err;
|
|
}
|
|
esp_rom_delay_us(BATTERY_ADC_SAMPLE_DELAY_US);
|
|
}
|
|
|
|
int samples_mv[BATTERY_ADC_SAMPLE_COUNT];
|
|
for (size_t i = 0; i < BATTERY_ADC_SAMPLE_COUNT; ++i) {
|
|
err = adc_oneshot_read(s_adc_handle, s_adc_channel, &raw);
|
|
if (err != ESP_OK) {
|
|
unlock_adc();
|
|
return err;
|
|
}
|
|
err = adc_cali_raw_to_voltage(s_cali_handle, raw, &samples_mv[i]);
|
|
if (err != ESP_OK) {
|
|
unlock_adc();
|
|
return err;
|
|
}
|
|
esp_rom_delay_us(BATTERY_ADC_SAMPLE_DELAY_US);
|
|
}
|
|
|
|
sort_ints(samples_mv, BATTERY_ADC_SAMPLE_COUNT);
|
|
/* 对称裁剪最高/最低样本后取均值，抑制开关噪声但保留缓慢电压变化。 */
|
|
int64_t sum_mv = 0;
|
|
for (size_t i = BATTERY_ADC_TRIM_COUNT;
|
|
i < BATTERY_ADC_SAMPLE_COUNT - BATTERY_ADC_TRIM_COUNT;
|
|
++i) {
|
|
sum_mv += samples_mv[i];
|
|
}
|
|
int adc_mv = (int)(sum_mv /
|
|
(BATTERY_ADC_SAMPLE_COUNT - 2 * BATTERY_ADC_TRIM_COUNT));
|
|
int64_t battery_mv = (int64_t)adc_mv *
|
|
((int64_t)CONFIG_TQ_BATTERY_DIVIDER_HIGH_OHM +
|
|
CONFIG_TQ_BATTERY_DIVIDER_LOW_OHM) /
|
|
CONFIG_TQ_BATTERY_DIVIDER_LOW_OHM;
|
|
battery_mv = battery_mv * CONFIG_TQ_BATTERY_CALIBRATION_GAIN_PPM / 1000000LL +
|
|
CONFIG_TQ_BATTERY_CALIBRATION_OFFSET_MV;
|
|
|
|
out_sample->adc_voltage_mv = adc_mv;
|
|
out_sample->voltage_mv = battery_mv > INT_MAX ? INT_MAX : (int)battery_mv;
|
|
out_sample->voltage_valid = out_sample->voltage_mv >= BATTERY_VALID_MIN_MV &&
|
|
out_sample->voltage_mv <= BATTERY_VALID_MAX_MV;
|
|
snapshot_load_state(&out_sample->high_load_active, &out_sample->cooldown_active);
|
|
|
|
unlock_adc();
|
|
return ESP_OK;
|
|
}
|
|
|
|
void platform_battery_load_begin(platform_battery_load_source_t source)
|
|
{
|
|
/* 饱和递增防止异常嵌套调用造成引用计数回绕。 */
|
|
if (source < 0 || source >= PLATFORM_BATTERY_LOAD_COUNT) {
|
|
return;
|
|
}
|
|
portENTER_CRITICAL(&s_state_lock);
|
|
if (s_load_ref_count[source] < UINT16_MAX) {
|
|
++s_load_ref_count[source];
|
|
}
|
|
portEXIT_CRITICAL(&s_state_lock);
|
|
}
|
|
|
|
void platform_battery_load_end(platform_battery_load_source_t source)
|
|
{
|
|
/* 最后一个负载结束时启动冷却窗口，给电池端电压留出恢复时间。 */
|
|
if (source < 0 || source >= PLATFORM_BATTERY_LOAD_COUNT) {
|
|
return;
|
|
}
|
|
int64_t cooldown_until_us = esp_timer_get_time() +
|
|
(int64_t)CONFIG_TQ_BATTERY_LOAD_COOLDOWN_SEC * 1000000LL;
|
|
|
|
portENTER_CRITICAL(&s_state_lock);
|
|
if (s_load_ref_count[source] > 0U) {
|
|
--s_load_ref_count[source];
|
|
if (cooldown_until_us > s_cooldown_until_us) {
|
|
s_cooldown_until_us = cooldown_until_us;
|
|
}
|
|
}
|
|
portEXIT_CRITICAL(&s_state_lock);
|
|
}
|
|
|
|
#else
|
|
|
|
esp_err_t platform_battery_read_charge_inputs(platform_battery_charge_inputs_t *out_inputs)
|
|
{
|
|
if (out_inputs != NULL) {
|
|
memset(out_inputs, 0, sizeof(*out_inputs));
|
|
}
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
esp_err_t platform_battery_init(void)
|
|
{
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
esp_err_t platform_battery_read_sample(platform_battery_sample_t *out_sample)
|
|
{
|
|
if (out_sample != NULL) {
|
|
memset(out_sample, 0, sizeof(*out_sample));
|
|
}
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
|
|
void platform_battery_load_begin(platform_battery_load_source_t source)
|
|
{
|
|
(void)source;
|
|
}
|
|
|
|
void platform_battery_load_end(platform_battery_load_source_t source)
|
|
{
|
|
(void)source;
|
|
}
|
|
|
|
#endif
|