huxi
623 lines
19 KiB
C
623 lines
19 KiB
C
#include "soc.h"
|
|
#include "system/includes.h"
|
|
#include "app_power_manage.h"
|
|
#include "app_main.h"
|
|
#include "app_config.h"
|
|
#include "app_action.h"
|
|
#include "asm/charge.h"
|
|
#include "ui_manage.h"
|
|
#include "tone_player.h"
|
|
#include "btstack/avctp_user.h"
|
|
#include "user_cfg.h"
|
|
#include "bt.h"
|
|
#include "asm/charge.h"
|
|
#include "ui/ui_api.h"
|
|
#include "../../include/key_event_deal.h"
|
|
#include "smartbox_user_app.h"
|
|
#include "gpadc.h"
|
|
#include "smartbox_info_manager.h"
|
|
|
|
|
|
#define LOG_TAG_CONST APP_CHGBOX
|
|
#define LOG_TAG "[SOC]"
|
|
#define LOG_ERROR_ENABLE
|
|
#define LOG_DEBUG_ENABLE
|
|
#define LOG_INFO_ENABLE
|
|
/* #define LOG_DUMP_ENABLE */
|
|
#define LOG_CLI_ENABLE
|
|
#include "debug.h"
|
|
|
|
|
|
#define CHARGE_QUXIAN_TEST 0
|
|
#define LOW_POWER_READREAD 0//比记忆低重新校准
|
|
#define DISP_TEST_SOC_UI_FIRST 0//校准显示UI
|
|
|
|
#define SOC_SIMULATE 0//仿真测试
|
|
#if (defined CUSTOM_BATTERY_CURVE_MANAGEMENT) && CUSTOM_BATTERY_CURVE_MANAGEMENT
|
|
|
|
|
|
// 低电参数
|
|
#define LOW_POW_STORAGE_MODE 0//1 // 低电是否直接进仓储模式
|
|
#define LOWPOWER_V 3.550 //低电提示电压
|
|
#define POWEROFF_V 3.500 //低电关机电压
|
|
#define POWEROFF_V_OFFSET 0.1 //开机滞回电压差，避免低电反复开机
|
|
// #define POWEROFF_SOC 0.01 //低电百分比关机
|
|
#define POWERSHUTDOWN_V 3.400 //严重低电关机电压
|
|
#define LOWPOWER_CNT 3 //关机计数3*8S关机
|
|
|
|
|
|
// 充电曲线
|
|
#define CHARGE_PA_END_V 4.1//0.1//4.300 //恒流结束电压（估计）
|
|
#define CHARGE_PA_START_V (LOWPOWER_V+0.1)//3.5//0.0//3.500 //恒流开始电压（估计）
|
|
#define CHARGE_PA_END_SOC 0.8//0.0//0.8 //恒流结束百分比（估计）
|
|
#define CHARGE_PA_START_SOC 0.0//0.0 //恒流开始百分比（估计）
|
|
#define CHARGE_PV_TIME (1*25*60*1000)//(1.0*60*60*1000) //恒压充电时间（估计）
|
|
|
|
#if (CHARGE_PV_TIME == 0)
|
|
#define CHARGE_PA_START_A 250 // 恒压充电开始电流
|
|
#define CHARGE_PA_END_A 20 //50 // 恒压充电满电电流
|
|
#endif
|
|
|
|
// 滤波参数
|
|
#define CHR_SPEED 0.003 //充电电量追赶速度
|
|
#define DIS_SPEED 0.001 //放电电量追赶速度
|
|
#define DIS_K 0.2 //放电滤波系数，越大越快
|
|
#define CHANGE_FIL_TIME 10000 //切换过滤不靠谱时间
|
|
#define SOC_CICLE_TIME 8000 //电量循环读取时间
|
|
|
|
|
|
// #define ERROR_SOC 1.0//0.3 //放电差异太大需要重新读
|
|
// #define ZERO_RE_READ 0//1 //放电状态下 电量0 % 是否重新读，关闭比较保险
|
|
// #define CHARG_ZERO_RE_READ 0//1//0// //第一次充电是否重读电量,982给过来的信息概率不准不建议开启
|
|
//
|
|
|
|
// 校准
|
|
// #define charge_first_work_charge_out_trim_vbat 1//0//1
|
|
// #define NO_CHARGE_CNT 2//5//5次采样后才认为稳定
|
|
// #define FIRST_START_INFO /看VM序号实际配置
|
|
// #define ALL_USR_CFG 34//看VM序号实际配置
|
|
|
|
// 放电曲线
|
|
// #define NEW_NUM_POINTS 3//11 // 实际应用的电池曲线（放电）
|
|
static float cap_ocv[][2] = {
|
|
{1.00, 4.1},//100% //建议满电稍低一点，避免出现满电拔掉充电立即掉电的情况 {0.10, LOWPOWER_V},//10%
|
|
{0.00, POWEROFF_V},//0%
|
|
};
|
|
|
|
void earphone_controller_in_poweroff_battery_capacity();
|
|
|
|
#define NEW_NUM_POINTS (ARRAY_SIZE(cap_ocv))
|
|
#if (CHARGE_PV_TIME)
|
|
int get_vbat_a_from_f98 = 0;
|
|
#else
|
|
extern int get_vbat_a_from_f98;
|
|
#endif
|
|
|
|
#if CHARGE_QUXIAN_TEST
|
|
static float vbat_val_test = 4.200;
|
|
|
|
static void change_vbat_val_test(void)
|
|
{
|
|
vbat_val_test -= 0.001;
|
|
r_printf("%s, test val:%f\n", __func__, vbat_val_test);
|
|
}
|
|
#endif /* CHARGE_QUXIAN_TEST */
|
|
|
|
|
|
static void trig_vcb(void (*func)(void))
|
|
{
|
|
log_info("os:%s func:%p", os_current_task(), func);
|
|
func();
|
|
}
|
|
|
|
int send_to_trig_vcb(void (*func)(void), char *taskname)
|
|
{
|
|
if (0) {
|
|
return 0;
|
|
}
|
|
log_info("send_to_trig_ui_vcb:%p", func);
|
|
int argv[3];
|
|
|
|
argv[0] = (int)trig_vcb;
|
|
argv[1] = 1;
|
|
argv[2] = (int)func;
|
|
|
|
int ret = os_taskq_post_type(taskname, Q_CALLBACK, 3, argv);
|
|
if (ret) {
|
|
printf("post ret:%d \n", ret);
|
|
}
|
|
return 0;
|
|
}
|
|
int now_soc_trim_info;
|
|
|
|
// 获取上电信息
|
|
u8 get_first_start_info()
|
|
{
|
|
int reset_sour = 0;
|
|
int vmret = syscfg_read(FIRST_START_INFO, &reset_sour, sizeof(reset_sour));
|
|
if (vmret == sizeof(reset_sour)) {
|
|
g_printf("write_first_start_info 读VM成功: %d", reset_sour);
|
|
}
|
|
now_soc_trim_info = reset_sour;
|
|
return reset_sour;
|
|
}
|
|
|
|
static u8 get_chr_cap(float ocv, float *soc)
|
|
{
|
|
if (ocv < CHARGE_PA_START_V) {
|
|
printf("%s %d", __func__, __LINE__);
|
|
*soc = CHARGE_PA_START_SOC;
|
|
} else if (ocv >= CHARGE_PA_END_V) {
|
|
#if(CHARGE_PV_TIME)
|
|
*soc += (float)SOC_CICLE_TIME / (float)CHARGE_PV_TIME * (1.0 - CHARGE_PA_END_SOC);
|
|
if (*soc > 1.0) {
|
|
*soc = 1.0;
|
|
}
|
|
printf("%s %d", __func__, __LINE__);
|
|
return 1;
|
|
#else
|
|
*soc = CHARGE_PA_END_SOC + (CHARGE_PA_START_A - get_vbat_a_from_f98) * (1.0 - CHARGE_PA_END_SOC) / (CHARGE_PA_START_A - CHARGE_PA_END_A);
|
|
printf("%s %d", __func__, __LINE__);
|
|
return 0;
|
|
#endif
|
|
} else {
|
|
printf("%s %d", __func__, __LINE__);
|
|
*soc = CHARGE_PA_START_SOC + (CHARGE_PA_END_SOC - CHARGE_PA_START_SOC) * (ocv - CHARGE_PA_START_V) / (CHARGE_PA_END_V - CHARGE_PA_START_V);
|
|
}
|
|
printf("%s %d", __func__, __LINE__);
|
|
return 0 ;
|
|
}
|
|
|
|
static float get_ocv(float cap)
|
|
{
|
|
if (cap >= cap_ocv[0][0]) {
|
|
return cap_ocv[0][1];
|
|
} else if (cap <= cap_ocv[NEW_NUM_POINTS - 1][0]) {
|
|
return cap_ocv[NEW_NUM_POINTS - 1][1];
|
|
} else {
|
|
for (int i = 0; i < NEW_NUM_POINTS - 1; i++) {
|
|
if (cap <= cap_ocv[i][0] && cap >= cap_ocv[i + 1][0]) {
|
|
float ocv = cap_ocv[i][1] + (cap - cap_ocv[i][0]) * (cap_ocv[i + 1][1] - cap_ocv[i][1]) / (cap_ocv[i + 1][0] - cap_ocv[i][0]);
|
|
return ocv;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static float get_cap(float ocv)
|
|
{
|
|
|
|
printf("%f %f %f %f", cap_ocv[0][1], cap_ocv[0][0], cap_ocv[NEW_NUM_POINTS - 1][1], cap_ocv[NEW_NUM_POINTS - 1][0]);
|
|
if (ocv >= cap_ocv[0][1]) {
|
|
return cap_ocv[0][0];
|
|
} else if (ocv <= cap_ocv[NEW_NUM_POINTS - 1][1]) {
|
|
return cap_ocv[NEW_NUM_POINTS - 1][0];
|
|
} else {
|
|
for (int i = 0; i < NEW_NUM_POINTS - 1; i++) {
|
|
if (ocv <= cap_ocv[i][1] && ocv >= cap_ocv[i + 1][1]) {
|
|
float cap = cap_ocv[i][0] + (ocv - cap_ocv[i][1]) * (cap_ocv[i + 1][0] - cap_ocv[i][0]) / (cap_ocv[i + 1][1] - cap_ocv[i][1]);
|
|
return cap;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
|
|
static int vm_vbat_value = 0;
|
|
static void write_vm_vbat_value(int vm_value)
|
|
{
|
|
if (vm_value < -1) {
|
|
vm_value = -1;
|
|
} else if (vm_value > 100) {
|
|
vm_value = -1;
|
|
}
|
|
printf("%s %d", __func__, vm_value);
|
|
syscfg_write(VM_BAT_PRESENT, &vm_value, sizeof(vm_value));
|
|
}
|
|
|
|
static int read_vm_vbat_value()
|
|
{
|
|
int vm_value = -1;
|
|
int ret = syscfg_read(VM_BAT_PRESENT, &vm_value, sizeof(vm_value));
|
|
if (ret > 0) {
|
|
if (vm_value < 0) {
|
|
vm_value = -1;
|
|
} else if (vm_value > 100) {
|
|
vm_value = -1;
|
|
}
|
|
|
|
printf(">>>>>>>>> VM init val is %d", vm_vbat_value);
|
|
} else {
|
|
vm_value = -1;
|
|
}
|
|
|
|
// vm_vbat_value = vm_value;
|
|
return vm_value;
|
|
}
|
|
|
|
u8 check_bat_vm_is_vaild()
|
|
{
|
|
if (-1 == read_vm_vbat_value()) {
|
|
return 0;
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
|
|
static float disp_soc;
|
|
static void soc_calculate_loop(void *p);
|
|
static void low_enter_poweroff();
|
|
static void force_poweroff(void *p);
|
|
// #include "lvgl.h"
|
|
|
|
int get_curr_soc()
|
|
{
|
|
return sbox_battery_box_get();
|
|
}
|
|
|
|
|
|
static u8 reread = 0;
|
|
|
|
|
|
static int soc_trim_id = 0;
|
|
|
|
static int app_is_sleep = 0;
|
|
static u16 app_sleep_check_timer = 0;
|
|
void app_sleep_check()
|
|
{
|
|
int value = 1;
|
|
/* struct lp_target *p; */
|
|
// list_for_each_lp_target(p){
|
|
// value = 1 & (p->is_idle());
|
|
// putchar('*');
|
|
// }
|
|
int lcd_sleep_flag = true;
|
|
|
|
#ifdef CONFIG_UI_STYLE_JL_CSC_PUBLIC_MODLS_ENABLE
|
|
lcd_sleep_flag = lcd_sleep_status();
|
|
#endif
|
|
|
|
if (value && lcd_sleep_flag && (sbox_ble_connect_flag_get() == 0) && !sbox_box_charging_get()) {
|
|
++app_is_sleep;
|
|
putchar('o');
|
|
if (app_is_sleep > TCFG_AUTO_POWER_OFF_TIME) {
|
|
putchar('P');
|
|
// app_chargebox_api_shutdown();
|
|
// power_event_to_user(POWER_EVENT_POWER_LOW);
|
|
// set_sys_soft_shutdown_flag(1);
|
|
// app_chargebox_api_shutdown();
|
|
sys_timer_del(app_sleep_check_timer);
|
|
// soft_poweroff_mode(1); ///强制关机
|
|
sys_enter_soft_poweroff(POWEROFF_NORMAL);
|
|
}
|
|
} else {
|
|
// putchar('@');
|
|
app_is_sleep = 0;
|
|
}
|
|
}
|
|
|
|
void soc_check_init()
|
|
{
|
|
r_printf("soc_check_init reset ok");
|
|
#if CHARGE_QUXIAN_TEST
|
|
sys_timer_add(NULL, change_vbat_val_test, 2000);
|
|
#endif /* CHARGE_QUXIAN_TEST */
|
|
get_first_start_info();
|
|
// 读取各个电量信息
|
|
#if CHARGE_QUXIAN_TEST
|
|
float current_707_vbat = vbat_val_test;//(float)(adc_get_voltage(AD_CH_PMU_VBAT) * 4)/1000.0;
|
|
r_printf("current_707_vbat init:%f\n", (float)(adc_get_voltage(AD_CH_PMU_VBAT) * 4) / 1000.0);
|
|
#else
|
|
float current_707_vbat = (float)(adc_get_voltage(AD_CH_PMU_VBAT) * 4) / 1000.0;
|
|
#endif /* CHARGE_QUXIAN_TEST */
|
|
float current_982_vbat = current_707_vbat;//(float)(adc_get_value_f98())/1000.0;
|
|
u8 charging = (sbox_box_charging_get() /*|| (nocharge_cnt<NO_CHARGE_CNT)*/);
|
|
|
|
// 读取VM的电量
|
|
vm_vbat_value = read_vm_vbat_value();
|
|
r_printf("init vm_vbat_value %d", vm_vbat_value);
|
|
|
|
// 无效电量，看时机校准
|
|
if (vm_vbat_value == -1) {
|
|
r_printf("init vm_vbat_value invail");
|
|
} else {
|
|
// 初始电量
|
|
disp_soc = (float)vm_vbat_value / 100.0;
|
|
r_printf("init disp_soc:%f", disp_soc);
|
|
|
|
r_printf("arry : %d", NEW_NUM_POINTS);
|
|
#if LOW_POWER_READREAD
|
|
|
|
|
|
// 非充电状态，比记忆低，重新读取
|
|
if (!charging && (get_cap(current_707_vbat) < disp_soc - 0.1)) {
|
|
g_printf(">>>>no charge vbat low low :%f, %f", disp_soc, get_cap(current_707_vbat));
|
|
disp_soc = get_cap(current_707_vbat);
|
|
}
|
|
#endif
|
|
// 范围控制
|
|
disp_soc = SOC_CLAMP(-1.0, disp_soc, 101.0);
|
|
vm_vbat_value = (int)(disp_soc * 100.0);
|
|
if (vm_vbat_value < 1) {
|
|
vm_vbat_value += 1;
|
|
}
|
|
vm_vbat_value = SOC_CLAMP(0, vm_vbat_value, 100);
|
|
sbox_battery_box_set(vm_vbat_value);
|
|
write_vm_vbat_value(sbox_battery_box_get());
|
|
}
|
|
|
|
g_printf(">>>>set_soc_first_work c %d init %d mapsoc:%f 701:%f 982:%f", charging, sbox_battery_box_get(), disp_soc, current_707_vbat, current_982_vbat);
|
|
|
|
#if SOC_SIMULATE
|
|
if (!soc_trim_id) {
|
|
soc_trim_id = sys_timer_add(NULL, soc_calculate_loop, 10);
|
|
}
|
|
#else
|
|
if (!soc_trim_id) {
|
|
soc_trim_id = sys_timer_add(NULL, soc_calculate_loop, (vm_vbat_value == -1) ? 500 : SOC_CICLE_TIME);
|
|
}
|
|
#endif
|
|
|
|
if (app_sleep_check_timer == 0) {
|
|
app_sleep_check_timer = sys_timer_add(NULL, app_sleep_check, 60000);//检查是否进入低功耗
|
|
}
|
|
|
|
}
|
|
|
|
float current_701_vbat;
|
|
float current_982_vbat;
|
|
float map_soc;
|
|
static int last_change_time = 0;
|
|
|
|
static void soc_calculate_loop(void *p)
|
|
{
|
|
r_printf("Entering soc_calculate_loop\n");
|
|
|
|
// 读取各个电量信息
|
|
#if CHARGE_QUXIAN_TEST
|
|
current_701_vbat = vbat_val_test;
|
|
r_printf("Testing mode: current_701_vbat: %f\n", (float)(adc_get_voltage(AD_CH_PMU_VBAT) * 4) / 1000.0);
|
|
#else
|
|
current_701_vbat = (float)(adc_get_voltage(AD_CH_PMU_VBAT) * 4) / 1000.0;
|
|
r_printf("Normal mode: current_701_vbat: %f\n", current_701_vbat);
|
|
#endif /* CHARGE_QUXIAN_TEST */
|
|
|
|
current_982_vbat = current_701_vbat;
|
|
u8 charging = sbox_box_charging_get();
|
|
|
|
r_printf("Charging status: %d\n", charging);
|
|
|
|
if (current_701_vbat < 2.0) {
|
|
r_printf("Error: 701 VBAT below threshold\n");
|
|
return;
|
|
}
|
|
|
|
if (charging && current_982_vbat < 2.0) {
|
|
r_printf("Error: 982 VBAT below threshold while charging\n");
|
|
return;
|
|
}
|
|
|
|
// 严重低电
|
|
if (!charging && (current_701_vbat < POWERSHUTDOWN_V)) {
|
|
earphone_controller_in_poweroff_battery_capacity();
|
|
g_printf("Critical low battery: %f\n", current_701_vbat);
|
|
vm_vbat_value = 0;
|
|
sbox_battery_box_set(vm_vbat_value);
|
|
write_vm_vbat_value(vm_vbat_value);
|
|
force_poweroff(NULL);
|
|
return;
|
|
}
|
|
|
|
// 记录变化时间点
|
|
static s8 state = -1;
|
|
if (state != charging || last_change_time == 0) {
|
|
last_change_time = jiffies_msec();
|
|
state = charging;
|
|
r_printf("State change detected: charging = %d, time = %d\n", charging, last_change_time);
|
|
}
|
|
|
|
#if DISP_TEST_SOC_UI_FIRST
|
|
if (vm_vbat_value == -1) {
|
|
static u8 firstsoc_disp = 1;
|
|
if (firstsoc_disp) {
|
|
firstsoc_disp = 0;
|
|
send_to_trig_vcb(soc_disp, "ui");
|
|
r_printf("First SOC display triggered\n");
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// 过滤不靠谱时间
|
|
r_printf("Current time: %d, Last change time: %d\n", jiffies_msec(), last_change_time);
|
|
if (jiffies_msec() - last_change_time < CHANGE_FIL_TIME) {
|
|
r_printf("Time filter active, skipping calculation\n");
|
|
return;
|
|
}
|
|
r_printf("Passed time filter\n");
|
|
|
|
// 无效电量，需要重新校准
|
|
if (vm_vbat_value == -1) {
|
|
r_printf("Invalid battery value detected, starting recalibration\n");
|
|
|
|
if (!charging) {
|
|
r_printf("Device is not charging, proceeding with recalibration\n");
|
|
|
|
// 修改定时器
|
|
sys_timer_modify(soc_trim_id, SOC_CICLE_TIME);
|
|
r_printf("Timer modified with SOC_CICLE_TIME: %d\n", SOC_CICLE_TIME);
|
|
|
|
// 获取当前电量
|
|
disp_soc = get_cap(current_701_vbat);
|
|
r_printf("Calculated SOC from voltage: %f\n", disp_soc);
|
|
|
|
// 限制 SOC 范围
|
|
disp_soc = SOC_CLAMP(-1.0, disp_soc, 101.0);
|
|
r_printf("Clamped SOC: %f\n", disp_soc);
|
|
|
|
// 转换为整数
|
|
vm_vbat_value = (int)(disp_soc * 100.0);
|
|
r_printf("Converted SOC to integer value: %d\n", vm_vbat_value);
|
|
|
|
// 确保电量值不低于 1
|
|
if (vm_vbat_value < 1) {
|
|
vm_vbat_value += 1;
|
|
r_printf("Adjusted SOC to minimum threshold: %d\n", vm_vbat_value);
|
|
}
|
|
|
|
// 再次限制范围
|
|
vm_vbat_value = SOC_CLAMP(0, vm_vbat_value, 100);
|
|
r_printf("Final clamped SOC value: %d\n", vm_vbat_value);
|
|
|
|
// 更新电池信息
|
|
sbox_battery_box_set(vm_vbat_value);
|
|
write_vm_vbat_value(vm_vbat_value);
|
|
r_printf("Recalibrated SOC saved: %d\n", vm_vbat_value);
|
|
} else {
|
|
r_printf("Device is charging, skipping recalibration\n");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
// 低电关机
|
|
static int low_cnt = 0;
|
|
if (!charging && (current_701_vbat < POWEROFF_V)) {
|
|
g_printf("Low battery detected: %f\n", current_701_vbat);
|
|
low_cnt++;
|
|
}
|
|
if (charging) {
|
|
low_cnt = 0;
|
|
}
|
|
if (low_cnt > LOWPOWER_CNT) {
|
|
g_printf("Low power shutdown triggered\n");
|
|
vm_vbat_value = 0;
|
|
sbox_battery_box_set(vm_vbat_value);
|
|
write_vm_vbat_value(vm_vbat_value);
|
|
low_enter_poweroff();
|
|
return;
|
|
}
|
|
|
|
// 计算电量
|
|
r_printf("Calculating SOC\n");
|
|
if (charging) {
|
|
map_soc = disp_soc;
|
|
u8 ret = get_chr_cap(current_982_vbat, &map_soc);
|
|
if (ret) {
|
|
disp_soc = map_soc;
|
|
r_printf("Charging: SOC updated to %f\n", disp_soc);
|
|
}
|
|
} else {
|
|
map_soc = get_cap(current_701_vbat);
|
|
r_printf("Discharging: Calculated SOC = %f\n", map_soc);
|
|
}
|
|
|
|
// 追赶
|
|
r_printf("Adjusting SOC\n");
|
|
if (map_soc > disp_soc && charging) {
|
|
if (disp_soc < 0.01) {
|
|
disp_soc += 0.02;
|
|
}
|
|
disp_soc += CHR_SPEED;
|
|
r_printf("Charging: SOC increased to %f\n", disp_soc);
|
|
}
|
|
if (map_soc < disp_soc && !charging) {
|
|
disp_soc -= (disp_soc - map_soc) < DIS_SPEED ? DIS_SPEED : (disp_soc - map_soc) * DIS_K;
|
|
r_printf("Discharging: SOC decreased to %f\n", disp_soc);
|
|
}
|
|
|
|
// 转化整形
|
|
r_printf("Clamping SOC\n");
|
|
disp_soc = SOC_CLAMP(-1.0, disp_soc, 101.0);
|
|
vm_vbat_value = (int)(disp_soc * 100.0);
|
|
if (vm_vbat_value < 1) {
|
|
vm_vbat_value += 1;
|
|
}
|
|
vm_vbat_value = SOC_CLAMP(0, vm_vbat_value, 100);
|
|
sbox_battery_box_set(vm_vbat_value);
|
|
|
|
// 电量变化保存
|
|
static u8 lastboxbat = -3;
|
|
if (lastboxbat != sbox_battery_box_get()) {
|
|
lastboxbat = sbox_battery_box_get();
|
|
write_vm_vbat_value(lastboxbat);
|
|
UI_MSG_POST("batcharge:process=%4", lastboxbat);
|
|
r_printf("Battery value saved: %d\n", lastboxbat);
|
|
}
|
|
|
|
r_printf("Charge: %d, SOC: %.2f, 701: %.2f, Map: %.2f, 982: %.2f\n",
|
|
charging, disp_soc * 100.0, current_701_vbat, map_soc, current_982_vbat);
|
|
|
|
r_printf("Exiting soc_calculate_loop\n");
|
|
}
|
|
|
|
|
|
|
|
|
|
// 开机前电压判断
|
|
void usr_check_power_on_voltage(void)
|
|
{
|
|
float current_vbat;
|
|
current_vbat = (float)(adc_get_voltage(AD_CH_PMU_VBAT) * 4) / 1000.0;
|
|
g_printf("usr_check_power_on_voltage current_vbat %f ", current_vbat);
|
|
if (current_vbat <= POWEROFF_V + POWEROFF_V_OFFSET) {
|
|
extern void sbox_storage_mode_enter();
|
|
sbox_storage_mode_enter();
|
|
}
|
|
}
|
|
|
|
static void force_poweroff(void *p)
|
|
{
|
|
g_printf("%s %d", __func__, __LINE__);
|
|
sbox_battery_box_set(0);
|
|
write_vm_vbat_value(0);
|
|
|
|
#if LOW_POW_STORAGE_MODE
|
|
extern void sbox_storage_mode_enter();
|
|
sbox_storage_mode_enter();
|
|
#else
|
|
// soft_poweroff_mode(1); ///强制关机
|
|
sys_enter_soft_poweroff(0);
|
|
#endif
|
|
}
|
|
|
|
static void low_enter_poweroff()
|
|
{
|
|
g_printf("%s %d", __func__, __LINE__);
|
|
sbox_battery_box_set(0);
|
|
write_vm_vbat_value(0);
|
|
// ui_poweroff_enter();
|
|
sys_timer_add(NULL, force_poweroff, 5000);
|
|
}
|
|
|
|
// 升级代码、上电复位、清
|
|
void write_first_start_info(int reset_sour)
|
|
{
|
|
|
|
y_printf("write_first_start_info : %d", reset_sour);
|
|
|
|
// if(reset_sour == 200){
|
|
// // 设置成无效状态
|
|
// // box_info.box_bat = vm_vbat_value = -1;
|
|
// // write_vm_vbat_value(box_info.box_bat);
|
|
// // sys_timer_modify(soc_trim_id, 100);
|
|
// }
|
|
|
|
int ret = 0;
|
|
int retry = 10;
|
|
do {
|
|
ret = syscfg_write(FIRST_START_INFO, &reset_sour, sizeof(reset_sour));
|
|
y_printf("retry:%d", retry);
|
|
os_time_dly(1);
|
|
} while (ret <= 0 && retry);
|
|
now_soc_trim_info = reset_sour;
|
|
}
|
|
|
|
#endif //#if (defined CUSTOM_BATTERY_CURVE_MANAGEMENT) && CUSTOM_BATTERY_CURVE_MANAGEMENT
|
|
|