bms/Application/app/sox/state.c

#include "bsp/gpio.h"
#include "bsp/ml5238.h"
#include "bsp/uart.h"
#include "bsp/mcu_power_sleep.h"
#include "app/sox/measure.h"
#include "app/sox/measure_task.h"
#include "libs/shark_task.h"
#include "libs/logger.h"
#include "app/nv_storage.h"
#include "health.h"
#include "soc.h"
#include "state.h"
#include "iostate.h"

#define ALLOW_DEEP_SLEEP 1
#define SLEEP_IGNORE_UNHEALTH 1
#define ALLOW_POWER_DOWN 0 //disable power down for debug
#define ALLOW_5238_BALANCE 1

static void _current_notify(void);
static void _voltage_notify(void);
static void _temperature_notify(void);
static u32 _bms_main_task_handler(void);
static void _balance_timer_handler(shark_timer_t *t);

static bms_state_t _bms_state;
static shark_task_t _bms_main_task = {.handler = _bms_main_task_handler};
static shark_timer_t _balance_timer = {.handler = _balance_timer_handler};


void bms_state_init(void){
	set_log_level(MOD_STATE, L_debug);
	state_debug("BMS System Starting......\n");	
	_bms_state.cell_index_of_max_vol = 0xff;
	measure_task_init(_current_notify, _voltage_notify, _temperature_notify);
	io_state_init();
	health_init();
	soc_init();
	shark_task_add(&_bms_main_task);
}

bms_state_t *bms_state_get(void){
	return &_bms_state;
}

/*
 放电mos和充电mos的开关要小心:
 1. 大部分的情况下，尽量能做到同时开关，主要是用来保护被关闭那路mos的体二极管(不能过大电流)
 2. 充电过压的情况下，必须要关闭充电mos，但是这个时候放电mos可能是打开的，这样的情况下，
    需要检测放电电流，超过10A必须强制打开充电mos,防止烧充电mos的体二极管
 3. 收到打开大电的指令后，必须两个mos都要打开,然后再经过2的判断
    。。。。。
*/
static void discharger_open(int open){
	/* 打开大电前，先打开短路保护*/
	if (open) {
		ml5238_short_current_detect(SHORT_CURRENT_MODE_100A_200A);//SP600:100A, SP700:200A
	}else {
		ml5238_short_current_detect(SHORT_CURRENT_MODE_DISABLE);
	}
	ml5238_enable_discharger_mosfet(open);
}


static void charger_open(int open) {
	ml5238_enable_charger_mosfet(open);
}


#define Health_Success 0
#define Health_Discharger_Failt 1
#define Health_charger_Fault 2
#define Health_aux_Fault 4

static s32 _process_unheath(void){
	if (bms_health()->load_current_short) {//短路检测后，关闭充放电mos
		discharger_open(0);
		charger_open(0); //disable charger mosfet
		AUX_VOL_OPEN(0);
		_bms_state.charging = 0;
		return (Health_Discharger_Failt | Health_charger_Fault);
	}

	if (bms_health()->charger_over_current || bms_health()->charger_over_temp || bms_health()->charger_lower_temp){
		charger_open(0); //disable charger mosfet
		_bms_state.charging = 0;
		return Health_charger_Fault;
	}

	if (bms_health()->discharger_over_temp || bms_health()->discharger_lower_temp || bms_health()->discharger_lower_voltage){
		discharger_open(0); //disable charger mosfet
		return Health_Discharger_Failt;
	}

	if (io_state()->aux_lock_detect || bms_health()->small_current_short) {
		return Health_aux_Fault;
	}
	
	return Health_Success;
}


//处理PS100/310/320/360，充电底座，充电柜的指令或者bms自己发给自己的指令
static void _process_user_request(s32 health){
	if (_bms_state.user_request & USER_REQUEST_PENDING){
		if ((health & Health_charger_Fault) == 0){
			charger_open(!!(_bms_state.user_request & USER_REQUEST_CHARGER));
		}
		if ((health & Health_Discharger_Failt) == 0){
			discharger_open(!!(_bms_state.user_request & USER_REQUEST_DISCHARGER));
		}
		if ((health & Health_aux_Fault) == 0){
			AUX_VOL_OPEN(!!(_bms_state.user_request & USER_REQUEST_SMALLCURRENT));
		}	
		_bms_state.user_request &= ~USER_REQUEST_PENDING;//clear user request pending
	}
}

static void _process_power_down(void){
#if (ALLOW_POWER_DOWN==1)	
	if (bms_health()->powerdown_lower_voltage){
		state_debug("BMS System PowerDown!!\n");

		nv_save_soc();
		
		ml5238_enable_charger_detect(AUX_VOL_IS_OPEN(), 1);
		delay_us(2* 1000);
		shark_uart_flush();
		if (!ml5238_charger_is_disconnect(AUX_VOL_IS_OPEN())){//have charger, do'nt power down
			bms_health()->powerdown_lower_voltage = 0;
			ml5238_enable_charger_detect(AUX_VOL_IS_OPEN(), 0);
			return;
		}
		ml5238_enable_charger_detect(AUX_VOL_IS_OPEN(), 0);
		AUX_VOL_OPEN(0);
		discharger_open(0);
		charger_open(0);
		
		/*需要等待B-和P-之间的电容放电掉后，才能设置5238 power down，
		否则5238会触发充电器插入检测，导致重新开机，进入powerdown <->开机的无限循环*/		
		ml5238_enable_charger_detect(AUX_VOL_IS_OPEN(), 1);
		delay_us(2* 1000);
		u64 wait_start = shark_get_mseconds();
		while(!ml5238_charger_is_disconnect(AUX_VOL_IS_OPEN())){
			shark_uart_flush();
			if (shark_get_mseconds() - wait_start >= 2000){
				bms_health()->powerdown_lower_voltage = 0;
				ml5238_enable_charger_detect(AUX_VOL_IS_OPEN(), 0);
				return;
			}
		}
		CS1180_PWR_ENABLE(0);
		DCDC_VOL_OPEN(0);
		ml5238_power_down();
	}
#endif
}

static u64 _sleep_time = 0;
static void _process_deepsleep(s32 health){
#if (ALLOW_DEEP_SLEEP==1)
#if (SLEEP_IGNORE_UNHEALTH==0)
	if (health != Health_Success){
		return;
	}
#endif
	if (ml5238_is_charging() || ml5238_is_discharging() || IS_CHARGER_IN()){
		return;
	}

	if(io_state()->hall_detect){
		return;
	}

	/*if (红外或者485通信没有超时){
		return;
	}*/

	if (io_state()->aux_lock_detect){
		return;
	}
	if (shark_get_mseconds() < (_sleep_time + 10 * 1000)){
		return;
	}
	
	nv_save_soc();
	mcu_enter_deepsleep();
	_sleep_time = shark_get_mseconds();
#endif	
}

static void _process_iostate_changed(void){
	if (!(io_state()->hall_detect)){
		if (ml5238_is_discharging()){
			discharger_open(0);
		}
		if (!AUX_VOL_IS_OPEN()){
			AUX_VOL_OPEN(1);
		}
	}
	if (IS_CHARGER_IN()) {
		if (!ml5238_is_charging()){
			charger_open(1);
		}
	}
}

static u32 _bms_main_task_handler(void){
	s32 unhealth = _process_unheath();
	_process_user_request(unhealth);
	_process_deepsleep(unhealth);
	_process_power_down();
	_process_iostate_changed();
	return 0;
}

static debounce_t _charging_detect = {.count = 10, .max_count = 20, .init_count = 10};
static void check_charging(){
	if ((measure_value()->load_current >= MIN_START_CHARGER_CURRENT) && !_bms_state.charging) {
		debounce_inc(_charging_detect);
		if (debounce_reach_max(_charging_detect)){
			_bms_state.charging = 1;
			debounce_reset(_charging_detect);
		}
	}else if ((measure_value()->load_current < MIN_START_CHARGER_CURRENT) && _bms_state.charging){
		debounce_dec(_charging_detect);
		if (debounce_reach_zero(_charging_detect)){
			_bms_state.charging = 0;
			debounce_reset(_charging_detect);
		}		
	}	
}

/* if discharger mos and charger mos, one is open but other is closed.
   we must judage the current: if current is large than 10A(-10A), 
   we must open the closed mos to avoid the closed mos to be destroyed
*/
#define MIN_CURRENT_FOR_BOTH_MOS_OPEN (10 * 1000)
static int _min_current_for_both_mos_count = 0;
static void _check_mos_stat(void){
	if (abs(measure_value()->load_current) >= MIN_CURRENT_FOR_BOTH_MOS_OPEN){
		_min_current_for_both_mos_count ++;
		if (_min_current_for_both_mos_count == 2){
			int dmos = ml5238_is_discharging();
			int cmos = ml5238_is_charging();
			if (dmos + cmos == 0){
				state_error("current = %d, but all mos is closed\n", measure_value()->load_current);
				return;
			}
			if (dmos == 1 && cmos == 1){
				return;
			}
			uint32_t request = USER_REQUEST_PENDING;
			if (!dmos) {
				request |= USER_REQUEST_DISCHARGER;
			}else {
				request |= USER_REQUEST_CHARGER;
			}
			_bms_state.user_request = request;
		}
	}else {
		_min_current_for_both_mos_count = 0;
	}
}

static void _current_notify(void){
	check_current_state(); //check health of current
	check_charging();
	_check_mos_stat();
	soc_update(); //计算soc
}

/* 需要检查电芯的电压，如果发现有电芯电压过高，需要开启被动均衡 
 * 充电过程中考虑balance,主要是希望cell 电压扩散后，保证1. 单电芯不能过压， 2. 单电芯不能比平均电压过低,导致
 * 木桶效应,目标是电压最高的那个cell，尽量压制，不让电压再升高，或者升高的尽量慢一些
*/
static debounce_t _cell_balance = {.count = 10, .max_count = 20};

static void _balance_timer_handler(shark_timer_t *t){
	ml5238_cell_start_balance(0);
	_bms_state.pack_balancing = 0;
}
static void check_cell_balance(uint8_t current_max_index){
	if (!_bms_state.charging){ //not charging, need not do balance
		if (_bms_state.pack_balancing){
			_bms_state.pack_balancing = 0;
			_cell_balance.count = 10;
			ml5238_cell_start_balance(0);
		}
		return;
	}
	if (!_bms_state.pack_balancing && _bms_state.cell_min_vol < CELL_FUSION_VOLTAGE){
		return;
	}
	if (_bms_state.cell_max_vol - _bms_state.cell_min_vol >= MAX_DIFF_BETWEEN_MIN_MAX_CELL){
		debounce_inc(_cell_balance);
	}else {
		debounce_dec(_cell_balance);
	}
	if (!_bms_state.pack_balancing && debounce_reach_max(_cell_balance)){
		_bms_state.pack_balancing = 1;
	}else if (_bms_state.pack_balancing && debounce_reach_zero(_cell_balance)){
		_bms_state.pack_balancing = 0;
		ml5238_cell_start_balance(0);
	}
	if (_bms_state.pack_balancing && (current_max_index != _bms_state.cell_index_of_max_vol)){
		ml5238_cell_start_balance(BIT(current_max_index));
		shark_timer_post(&_balance_timer, 60 * 1000); //stop balance after 1 minute
	}
	_bms_state.cell_index_of_max_vol = current_max_index;	
}

static uint8_t calc_cell_voltage(void){
	uint16_t voltage = 0;
	uint16_t max_cell = 0;
	uint16_t min_cell = 0xf000;
	uint8_t max_index = 0;
	for (int i = 0; i < CELLS_NUM; i++){
		voltage += measure_value()->cell_vol[i];
		if (max_cell > measure_value()->cell_vol[i]){
			max_cell = measure_value()->cell_vol[i];
			max_index = i;
		}
		if (min_cell < measure_value()->cell_vol[i]){
			min_cell = measure_value()->cell_vol[i];
		}		
	}
	_bms_state.pack_voltage = voltage;
	_bms_state.cell_max_vol = max_cell;
	_bms_state.cell_min_vol = min_cell;	
	return max_index;
}

static void _voltage_notify(void){
	uint8_t max_index = calc_cell_voltage();
	check_voltage_state(); //check health of cell voltage
#if (ALLOW_5238_BALANCE==1)
	check_cell_balance(max_index);
#endif
}

static void _temperature_notify(void){
	check_temp_state(); //check health of cell/pcb temperature
}