update log&cs1180

Signed-off-by: huhui <huhui@sharkgulf.com>

Application/app/sox/health.c

@@ -8,11 +8,12 @@
 #include "health.h"
 
 #define MAX_CURRENT_FOR_CHARGER (20*1000) //最大充电电流20A
+#if 0
 #define MIN_VOLTAGE_FOR_DISCHARGER (2.2f * CELLS_NUM * 1000) //允许能放电的最小电压
 #define MIN_VOLTAGE_FOR_RECOVERY_DISCHARGER (2.3f * CELLS_NUM * 1000) //恢复放电的最小电压
 #define MIN_VOLTAGE_FOR_POWER_DOWN (2.1f * CELLS_NUM* 1000)
 #define SIGLE_CELL_LOWER_DISCHARGER_VOLTAGE (1820) //最小允许的电芯放电电压 1.8v, 考虑到采样的误差取 1.82
-
+#endif
 #define SIGLE_CELL_MAX_CHARGER_VOLTAGE (3800)//最大允许充电电压，3.9v,考虑到采样的误差取 3.88
 
 static int8_t charger_normal_low_temp[PACK_TEMPS_NUM] = {0,0,0,0}; //正常的充电最低温度
@@ -26,20 +27,20 @@ static int8_t discharger_lower_low_temp[PACK_TEMPS_NUM] = {-15,-15,-15,-10}; //
 static int8_t discharger_higher_high_temp[PACK_TEMPS_NUM] = {55,55,55,60};//需要停止放电的最高温度
 
 /*定义低温和正常温度下的电池保护参数, [0]低温参数, [1]常温参数 */
-/*能提供大电的最小电压*/
-static float min_discharger_vol[] = {(2100 * CELLS_NUM), (2300 * CELLS_NUM)};//允许能放电的最小电压
-static float min_discharger_recovery_vol[] = {(2200 * CELLS_NUM), (2400 * CELLS_NUM)};//恢复放电的最小电压
-static float min_discharger_cell_vol[] = {2100, 2300};//允许能放电的最小电芯电压
-static float min_discharger_cell_recovery_vol[] = {2200, 2400};//恢复放电的最小电芯电压
-
 /*能提供动力的最小电压*/
-static float min_discharger_power_vol[] = {(2100 * CELLS_NUM), (2300 * CELLS_NUM)}; //允许能提供动力的最小电压
-static float min_discharger_power_recovery_vol[] = {(2100 * CELLS_NUM), (2300 * CELLS_NUM)}; //恢复能提供动力的最小电压
-static float min_discharger_power_cell_vol[] = {2100, 2300}; //允许能提供动力的最小电芯电压
-static float min_discharger_power_recovery_cell_vol[] = {2100, 2300}; //恢复能提供动力的最小电芯电压
+static float min_discharger_power_vol[] = {32000, 38000}; //允许能提供动力的最小电压
+static float min_discharger_power_recovery_vol[] = {34000, 40000}; //恢复能提供动力的最小电压
+static float min_discharger_power_cell_vol[] = {2100, 2500}; //允许能提供动力的最小电芯电压
+static float min_discharger_power_recovery_cell_vol[] = {2200, 2600}; //恢复能提供动力的最小电芯电压
+
+/*能提供大电的最小电压*/
+static float min_discharger_vol[] = {30000, 36000};//允许能放电的最小电压
+static float min_discharger_recovery_vol[] = {32000, 38000};//恢复放电的最小电压
+static float min_discharger_cell_vol[] = {2000, 2400};//允许能放电的最小电芯电压
+static float min_discharger_cell_recovery_vol[] = {2100, 2500};//恢复放电的最小电芯电压
 
 /*电池PowerDown的最小电压 */
-static float min_discharger_pdown_vol[] = {(2000 * CELLS_NUM), (2400 * CELLS_NUM)}; //power down的最小电压
+static float min_discharger_pdown_vol[] = {28000, 34000}; //power down的最小电压
 static float min_discharger_pdown_cell_vol[] = {1900, 2200};                        //power down的最小电芯电压
 
 /* health 模块，只检测状态，不做任何控制,如果有异常情况，控制中心会统一处理  */

Application/app/sox/iostate.c

@@ -26,9 +26,12 @@ static io_timer_t charger_io = {._timer.handler = io_timer_handler, .debounce_ti
 static io_timer_t aux_short_io = {._timer.handler = io_timer_handler, .debounce_time_zero = 50, .debounce_time_one = 50};
 static io_timer_t dcdc_pwr_io = {._timer.handler = io_timer_handler, .debounce_time_zero = 50, .debounce_time_one = 50};
 
-static void debug_io(void){
-	uint16_t *io = (uint16_t *)&_io_state;
-	io_debug("io state = 0x%x, %lld\n", *io, shark_get_mseconds());
+void iostate_log(void){
+	io_debug("Hall:%d, %d, %d\n", _io_state.hall_detect, IS_HALL1_DETECTED(), IS_HALL2_DETECTED());
+	io_debug("AuxLocked:%d\n", _io_state.aux_lock_detect);
+	io_debug("ChargDet:%d\n", _io_state.charger_detect);
+	io_debug("PwrGood:%d\n", _io_state.pwr_good_detect);
+	io_debug("DcdcGood:%d\n", _io_state.dcdc_good_detect);
 }
 
 void io_state_init(void){
@@ -46,8 +49,8 @@ void io_state_init(void){
 	small_current_short_irq_enable(1);
 
 	bms_message_update_insert(_io_state.hall_detect);
-	
-	debug_io();
+
+	iostate_log();
 }
 
 io_state_t *io_state(void){
@@ -100,7 +103,6 @@ static void _set_io_value(io_timer_t *t){
 	if (t == &aux_short_io){
 		_io_state.aux_lock_detect = t->value;
 	}
-	debug_io();
 }
 
 static int _debounce_time_reach(io_timer_t *t){
@@ -141,7 +143,6 @@ static void io_timer_handler(shark_timer_t *t){
 static void small_current_irq_timer_handler(shark_timer_t *t){
 	aux_short_io.value = _io_state.aux_lock_detect = IS_AUX_VOL_LOCKED() && AUX_VOL_IS_OPEN();
 	aux_short_io.detect_cnt = 0;
-	debug_io();
 	health_process_aux_lock();
 }
 static shark_timer_t _small_current_irq_timer = {.handler = small_current_irq_timer_handler};

Application/app/sox/iostate.h

@@ -11,6 +11,7 @@ typedef struct{
 
 void io_state_init(void);
 io_state_t *io_state(void);
+void iostate_log(void);
 
 #endif /* _IO_state_H__ */
 

Application/app/sox/measure.c

@@ -125,12 +125,9 @@ static float get_pack_current_by_cs1180(void){
 
 
 float get_pack_current(void){
-	if (!cs1180_is_ready()){ //if cs1180 is not ready, just use gd adc
-		return get_pack_current_by_gd();
-	}
-	float current = get_pack_current_by_cs1180();
-	if (abs(current) >= CS1180_MAX_CURRENT){
-		return get_pack_current_by_gd();
+	float current = get_pack_current_by_gd();
+	if (abs(current) < CS1180_MAX_CURRENT && cs1180_is_ready()){
+		current = get_pack_current_by_cs1180();
 	}
 	return current;
 }

Application/app/sox/measure_task.c

@@ -35,7 +35,12 @@ measure_value_t * measure_value(void){
 	return &_measure_value;
 }
 
-
+void measure_log(void){
+	measure_debug("Current %.2f\n", (float)_measure_value.load_current/1000.0f);
+	for (int i = 0; i < CELLS_NUM; i++){
+		measure_debug("Cell[%d]: %.2fv\n", i, _measure_value.cell_vol[i]/1000.0f);
+	}
+}
 /*
  * 测量电芯电压，计算出总电压, 测量总电流，放电和充电
 */

Application/app/sox/measure_task.h

@@ -12,6 +12,7 @@ typedef void (*measure_notify)(void);
 
 void measure_task_init(measure_notify cn, measure_notify vn, measure_notify tn);
 measure_value_t * measure_value(void);
+void measure_log(void);
 
 #endif /* _Measure_Task_H__ */
 

Application/app/sox/soc.c

@@ -20,7 +20,7 @@ static void calibrate_soc_by_ocv(void);
 void soc_init(void){
 	set_log_level(MOD_SOC, L_debug);
 	time_ms = shark_get_mseconds();
-	if (nv_restore_soc() != 0){
+	if (1/*nv_restore_soc() != 0*/){
 		soc_warning("SOC: nv storage is not inited, use default value!!\n");
 		_soc.coulomb_min = 0;
 		_soc.coulomb_max = DEFALUT_MAX_COULOMB; //30HA,这个值最总需要soh模块给
@@ -35,6 +35,22 @@ void soc_init(void){
 		calibrate_soc_by_ocv();
 		nv_save_soc();
 	}
+	soc_log();
+}
+
+void soc_log(void){
+	soc_debug("C now: %.1f\n", _soc.coulomb_now);
+	soc_debug("C min: %.1f\n", _soc.coulomb_min);
+	soc_debug("C max: %.1f\n", _soc.coulomb_max);
+	soc_debug("C char: %.1f\n", _soc.charger_coulomb);
+	soc_debug("C dischar: %.1f\n", _soc.dischrger_coulomb);
+	soc_debug("C pre char: %.1f\n", _soc.pre_discharger_coulomb);
+	soc_debug("C pre dischar: %.1f\n", _soc.pre_charger_coulomb);
+	soc_debug("C tol: %d\n", _soc.total_coulomb);
+	soc_debug("C energy: %.1f\n", _soc.energy);
+	if (chargering){
+		soc_debug("C remain %d\n", charger_remain_time);
+	}
 }
 
 //初始上电或者nv出问题后，通过开路电压对soc做一次初略校准
@@ -170,7 +186,7 @@ void soc_update(void){
 			}
 		}
 	}
-	_soc.energy = bms_state_get()->pack_voltage/1000.f * (_soc.coulomb_now - _soc.coulomb_min) * _soc.capacity/100.0f;
+	_soc.energy = bms_state_get()->pack_voltage/1000.f * (_soc.coulomb_now - _soc.coulomb_min);
 	if (old_cap != _soc.capacity) {
 		nv_save_soc();
 	}

Application/app/sox/soc.h

@@ -27,3 +27,5 @@ void soc_update_by_ocv(void);
 uint32_t soc_get_cycle(void);
 uint32_t soc_get_charger_remain_time(void);
 soc_t *get_soc(void);
+void soc_log(void);
+

Application/app/sox/state.c

@@ -22,11 +22,13 @@ 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 void _debug_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};
 
+static shark_timer_t _debug_timer = {.handler = _debug_timer_handler};
 
 void bms_state_init(void){
 	set_log_level(MOD_STATE, L_debug);
@@ -38,6 +40,7 @@ void bms_state_init(void){
 	soc_init();
 	_bms_state.user_request = USER_REQUEST_PENDING | USER_REQUEST_SMALLCURRENT_ON;
 	shark_task_add(&_bms_main_task);
+	shark_timer_post(&_debug_timer, 2000);
 }
 
 bms_state_t *bms_state_get(void){
@@ -77,6 +80,33 @@ int bms_work_mode_set(int mode, int start){
 	return 0;
 }
 
+void bms_state_log(void){
+	state_debug("Charging: %d\n", _bms_state.charging);
+	state_debug("WorkMode %d\n", _bms_state.work_mode);
+	state_debug("DMos: %d\n", ml5238_is_discharging());
+	state_debug("CMos: %d\n", ml5238_is_charging());
+	state_debug("AuxPower: %d\n", AUX_VOL_IS_OPEN());
+}
+static int _log_count = 0;
+static void _debug_timer_handler(shark_timer_t *t){
+	int mod = _log_count % 4;
+	if (mod == 0){
+		bms_state_log();
+	}
+	if (mod == 1) {
+		iostate_log();
+	}
+	if (mod == 2) {
+		soc_log();
+	}
+	if (mod == 3) {
+		measure_log();
+	}
+	_log_count ++;
+	shark_timer_post(&_debug_timer, 2000);
+}
+
+
 /*
  放电mos和充电mos的开关要小心:
  1. 大部分的情况下，尽量能做到同时开关，主要是用来保护被关闭那路mos的体二极管(不能过大电流)
@@ -125,6 +155,10 @@ static s32 _process_unheath(void){
 	if (bms_health()->discharger_over_temp || bms_health()->discharger_lower_temp || bms_health()->discharger_lower_voltage){
 		discharger_open(0); //disable charger mosfet
 		unhealth |= Health_Discharger_Failt;
+		if (bms_health()->discharger_over_temp){ //放电过高温后，小电流也必须关闭
+			AUX_VOL_OPEN(0);
+			unhealth |= Health_aux_Fault;
+		}
 	}
 
 	if (io_state()->aux_lock_detect || bms_health()->small_current_short) {

Application/bsp/cs1180.c

@@ -48,6 +48,7 @@ static void spi_write_reg(uint8_t reg, uint8_t *data, uint8_t len){
 static void spi_read_reg(uint8_t reg, uint8_t *data, uint8_t len){
 	cs1180_send_cmd(CS1180_RREG|reg);
 	cs1180_send_cmd(len - 1);
+	delay_us(60);
 	while(len -- > 0){
 		*data = cs1180_read_data(0xFF);
 		data++;
@@ -210,8 +211,8 @@ float cs1180_adc_sample(void)
 	while (IS_CS1180_NOT_READY()); //µ±drdy Ϊ¸ßʱ£¬²»¶ÁÈ¡Êý¾Ý
 
 	cs1180_cs(0);
-	//spi_read_reg(0xD, data, 3);
 	cs1180_send_cmd(CS1180_RDATA);
+	delay_us(60);
 	data[0] = cs1180_read_data(0xFF);
 	data[1] = cs1180_read_data(0xFF);
 	data[2] = cs1180_read_data(0xFF);

Application/libs/logger.c

@@ -19,7 +19,7 @@ void set_log_level(int mod, int l){
 }
 
 static void log_out(char *fmt, va_list args){
-	// vprintf(fmt, args);
+	vprintf(fmt, args);
 }
 
 void log_debug(int mod, char *fmt, ...){