update charge logic

Signed-off-by: FuangCao <cavan.cao@foxmail.com>

Source/app.c

@@ -11,6 +11,7 @@
 #include "app_end_ctr.h"
 #include "drv_io.h"
 #include "shark_xl.h"
+#include "shark_charge.h"
 
 // CB_VAL cb_val_last;
 uint8_t cb_operate_state = CB_BAT_NO;
@@ -24,8 +25,6 @@ uint8_t cfg_operate = CFG_BAT_NO;
 uint8_t work_normal = 0;
 
 uint8_t is_intelligent = 1;
-uint8_t CB_OPERATE_PRECEDENCE_PARRALLEL = PRE_SERIES; 
-uint8_t CB_OPERATE_PRECEDENCE_Config = PRE_SERIES; 
 
 DELAY_COMMON Series_delay;
 
@@ -60,7 +59,6 @@ void CB_Operate_Initial(void)
 
 void App_Initial(void)
 {
-	CB_OPERATE_PRECEDENCE_PARRALLEL = CB_OPERATE_PRECEDENCE_Config;
 	memset(&Series_delay,0x00,sizeof(Series_delay));
 	Initial_Neng_Hao_Bi();	
 }
@@ -309,6 +307,10 @@ static u8 shark_battery_switch_single(void)
 
 static shark_bool shark_battery_series_enabled(void)
 {
+	if (shark_charger_detected) {
+		return shark_false;
+	}
+
 	if (QD_Dect()) {
 		if (shark_xl_check()) {
 			return shark_false;
@@ -341,10 +343,6 @@ static shark_bool shark_battery_series_enabled(void)
 		return shark_false;
 	}
 
-	if (IS_CHARGE_IN()) {
-		return shark_false;
-	}
-
 	return shark_true;
 }
 
@@ -354,15 +352,16 @@ static shark_bool shark_battery_check_series(u8 operate)
 		if (is_intelligent == 0) {
 			return shark_false;
 		}
-
-		if (CB_OPERATE_PRECEDENCE_PARRALLEL != PRE_SERIES) {
-			return shark_false;
-		}
 	}
 
 	return shark_battery_series_enabled();
 }
 
+static shark_bool shark_battery_parrallel_enabled(void)
+{
+	return shark_charger_detected;
+}
+
 static shark_bool shark_battery_check_parrallel(u8 operate)
 {
 	if (operate != CB_BAT1_BAT2_PARRALLEL) {
@@ -370,18 +369,14 @@ static shark_bool shark_battery_check_parrallel(u8 operate)
 			return shark_false;
 		}
 
-		if (CB_OPERATE_PRECEDENCE_PARRALLEL != PRE_PARRALLEL) {
+		if (shark_battery_get_voltage_delta() > SHARK_PARRALLEL_VOL_MIN) {
 			return shark_false;
 		}
 
 		return shark_false;
 	}
 
-	if (shark_battery_get_voltage_delta() > PARRALLEL_BL_DELTA_VOL) {
-		return shark_false;
-	}
-
-	return IS_CHARGE_IN();
+	return shark_battery_parrallel_enabled();
 }
 
 static u8 shark_battery_switch_auto(u8 operate)
@@ -419,7 +414,7 @@ static u8 shark_battery_switch_auto(u8 operate)
 				return operate;
 			} else if (shark_battery_check_parrallel(operate)) {
 				return shark_battery_switch_parrallel();
-			} else if (IS_CHARGE_IN()) {
+			} else if (shark_charger_detected) {
 				return shark_battery_switch_charge();
 			} else {
 				return shark_battery_switch_single();
@@ -444,7 +439,13 @@ int8_t Battery_CB_Switch(uint8_t cb_operate)
 	sub_bms_info_1.exit_times = 0;
 	sub_bms_info_2.exit_times = 0;
 	shark_battery_switch_busy = shark_false;
+
 	println("switch: %d", cb_operate_state);
+
+	if (shark_charger_detected) {
+		shark_charger_set_enable(shark_true);
+	}
+
 	return cb_operate_state;
 #else
 #define COM_TIMEOUT  (15)
@@ -954,53 +955,6 @@ void test_io(void)
 
 uint8_t Select_One_BAT(void)
 {
-#if 0
-	uint8_t temp_op = CB_BAT_NO;
-
-	println("select one");
-
-	sub_bms_info_1.state = SHARK_BATT_STATE_IDLE;
-	sub_bms_info_2.state = SHARK_BATT_STATE_IDLE;
-
-	if(Is_Sub_BMS_1_Normal() == SHARK_BATT_EXIT_SUCCESS)
-	{
-		if(Is_Sub_BMS_2_Normal() == SHARK_BATT_EXIT_SUCCESS)
-		{
-			if(sub_bms_info_1.packet_common.m_total_vol >= sub_bms_info_2.packet_common.m_total_vol)
-			{
-				if(IS_CHARGE_IN())
-				{
-					temp_op = CB_BAT2;
-				}
-				else
-				{
-					temp_op = CB_BAT1;
-				}
-			}
-			else
-			{
-				if(IS_CHARGE_IN())
-				{
-					temp_op = CB_BAT1;
-				}
-				else
-				{
-					temp_op = CB_BAT2;
-				}
-			}
-		}
-		else
-		{
-			temp_op = CB_BAT1;
-		}
-	}
-	else if(Is_Sub_BMS_2_Normal() == SHARK_BATT_EXIT_SUCCESS)
-	{
-		temp_op = CB_BAT2;
-	}
-
-	return temp_op;
-#else
 	if (sub_bms_info_1.connected) {
 		return CB_BAT1_BAT2_AUTO;
 	}
@@ -1020,7 +974,6 @@ uint8_t Select_One_BAT(void)
 	}
 
 	return CB_BAT_NO;
-#endif
 }
 
 
@@ -1099,7 +1052,7 @@ uint8_t Check_CB_BAT1_BAT2_PARRALLEL(void)
 {
 	uint8_t temp_op = CB_MAX;
 
-	if(is_intelligent && CB_OPERATE_PRECEDENCE_PARRALLEL != PRE_PARRALLEL)
+	if (!shark_battery_parrallel_enabled())
 	{
 		temp_op = Select_One_BAT();
 		return temp_op;
@@ -1160,7 +1113,7 @@ uint8_t Select_One_BAT_Han_Guo(void)
 		{
 			if(sub_bms_info_1.packet_common.m_total_vol >= sub_bms_info_2.packet_common.m_total_vol)
 			{
-				if(IS_CHARGE_IN())
+				if(shark_charger_detected)
 				{
 					temp_op = CB_BAT2;
 				}
@@ -1171,7 +1124,7 @@ uint8_t Select_One_BAT_Han_Guo(void)
 			}
 			else
 			{
-				if(IS_CHARGE_IN())
+				if(shark_charger_detected)
 				{
 					temp_op = CB_BAT1;
 				}
@@ -1229,12 +1182,6 @@ uint8_t Check_CB_BAT1_BAT2_SERIES(void)
 {
 	uint8_t temp_op = CB_MAX;
 
-	if(is_intelligent && CB_OPERATE_PRECEDENCE_PARRALLEL != PRE_SERIES)
-	{
-		temp_op = Select_One_BAT();
-		return temp_op;
-	}
-
 #ifndef HAN_GUO_VERSION
 	if (shark_battery_series_locked)
 	{
@@ -1243,7 +1190,7 @@ uint8_t Check_CB_BAT1_BAT2_SERIES(void)
 	}
 #endif
 
-	if(IS_CHARGE_IN())
+	if (shark_charger_detected)
 	{
 		temp_op = Select_One_BAT();
 		return temp_op;
@@ -1433,109 +1380,6 @@ uint8_t Is_BAT2_Lock(void)
 		
 }
 
-void Charger_Out(void)
-{
-	Set_Charger_In(0);
-
-	if(sub_bms_info_1.packet_common.m_percent >= 100 && sub_bms_info_2.packet_common.m_percent >= 100)
-		battery_charged_full = 1;
-}
-void Check_Charge_In(void)
-{
-
-	if(sub_bms_info_1.packet_common.m_percent < 97 || sub_bms_info_2.packet_common.m_percent < 97)
-		battery_charged_full = 0;
-	//if(gpio_input_bit_get(GPIOC,GPIO_PIN_4) == 0)
-	{
-	//	Set_Charger_In(1);
-	}
-
-	if(IS_CHARGE_IN())
-	{
-		
-		if(is_intelligent)
-		{
-			CB_OPERATE_PRECEDENCE_PARRALLEL = PRE_PARRALLEL; 
-			if(cb_operate_state == CB_BAT1_BAT2_SERIES)
-			{
-				if(Battery_Change_Mode(CFG_BAT1_BAT2_PARRALLEL) == CB_BAT1_BAT2_PARRALLEL)
-					CHARG_PROTECT_OPEN(1);
-				
-			}
-			else
-			{
-				CHARG_PROTECT_OPEN(1);
-			}
-		}
-		else
-		{
-			if(cb_operate_state == CB_BAT1_BAT2_SERIES)
-			{
-				;		
-			}
-			else
-				CHARG_PROTECT_OPEN(1);
-		}
-		
-
-		if(IS_CHARGER_ON())
-		{
-			if(sub_bms_info_1.packet_common.charge_flag == 0 && sub_bms_info_2.packet_common.charge_flag == 0)
-			{
-				if(charge_delay.set == 0)
-				{
-					charge_delay.set = 1;
-					charge_delay.count = 0;
-				}
-				else
-				{
-					if(charge_delay.count >= CHARGE_DELAY_TIME_OUT_COUNT)
-					{
-						memset(&charge_delay,0x00,sizeof(charge_delay));						
-						Charger_Out();
-					}
-				}
-			}
-			else
-			{
-				memset(&charge_delay,0x00,sizeof(charge_delay));
-			}
-
-			if(cb_operate_state == CB_BAT1_BAT2_PARRALLEL)
-			{
-				if(sub_bms_info_1.packet_common.charge_flag)
-				{
-					if((sub_bms_info_2.packet_common.work_status&ST_DISCHRG_CUR)!= 0)
-					{
-						if(sub_bms_info_1.packet_common.m_current + sub_bms_info_2.packet_common.m_current\
-							< 5000)
-							Charger_Out();	
-					}
-				}	
-				else if(sub_bms_info_2.packet_common.charge_flag)
-				{
-					if((sub_bms_info_1.packet_common.work_status&ST_DISCHRG_CUR)!= 0)
-					{
-						if(sub_bms_info_1.packet_common.m_current + sub_bms_info_2.packet_common.m_current\
-							< 5000)
-							Charger_Out();	
-					}
-				}
-			}
-			
-	
-		}
-	}	
-	else
-	{
-		CHARG_PROTECT_OPEN(0);
-		if(is_intelligent)
-		{
-			CB_OPERATE_PRECEDENCE_PARRALLEL = CB_OPERATE_PRECEDENCE_Config; 
-		}
-	}
-}
-
 uint8_t Change_Mode_Sub_BMS_1_Normal(void)
 {
 	return Is_Sub_BMS_1_Normal() == SHARK_BATT_EXIT_SUCCESS;
@@ -1547,19 +1391,15 @@ uint8_t Change_Mode_Sub_BMS_2_Normal(void)
 
 uint8_t Change_Mode_Sub_BMS_PARRALLEL(void)
 {
-	//
-	if(cb_operate_state == CB_BAT_NO)
+	if (!shark_battery_parrallel_enabled()) {
 		return 0;
+	}
 
-	if(is_intelligent && CB_OPERATE_PRECEDENCE_PARRALLEL != PRE_PARRALLEL)
-		return 0;
-	//
-	if(Is_Sub_BMS_1_Normal() == SHARK_BATT_EXIT_SUCCESS && Is_Sub_BMS_2_Normal() == SHARK_BATT_EXIT_SUCCESS)
-		;
-	else
+	if(Is_Sub_BMS_1_Normal() != SHARK_BATT_EXIT_SUCCESS || Is_Sub_BMS_2_Normal() != SHARK_BATT_EXIT_SUCCESS) {
 		return 0;
+	}
 
-	if (shark_battery_get_voltage_delta() > PARRALLEL_BL_DELTA_VOL) {
+	if (shark_battery_get_voltage_delta() > SHARK_PARRALLEL_VOL_MIN) {
 		return 0;
 	}
 
@@ -1572,22 +1412,9 @@ uint8_t Change_Mode_Sub_BMS_SERIES(void)
 		return 0;
 	}
 
-#if 0
-	//
-	if(!(cb_operate_state == CB_BAT1 || cb_operate_state == CB_BAT2))
-		return 0;
-#endif
-
-	if(is_intelligent && CB_OPERATE_PRECEDENCE_PARRALLEL != PRE_SERIES)
-		return 0;
-
-#if 0
-	if(IS_CHARGE_IN())
-		return 0;
-#endif
-
-	if(!(Is_Sub_BMS_1_Normal() == SHARK_BATT_EXIT_SUCCESS && Is_Sub_BMS_2_Normal() == SHARK_BATT_EXIT_SUCCESS))
+	if (Is_Sub_BMS_1_Normal() != SHARK_BATT_EXIT_SUCCESS || Is_Sub_BMS_2_Normal() != SHARK_BATT_EXIT_SUCCESS) {
 		return 0;
+	}
 
 	/*if(cb_operate_state == CB_BAT1)
 	{
@@ -1671,7 +1498,7 @@ void Intelligent_Management_Battery(void)
 {
 	if(is_intelligent)
 	{
-		if(CB_OPERATE_PRECEDENCE_PARRALLEL == PRE_PARRALLEL)
+		if(shark_charger_detected)
 		{
 			if(cb_operate_state == CB_BAT1_BAT2_PARRALLEL)
 				return;		
@@ -1698,13 +1525,9 @@ void Intelligent_Management_Battery(void)
 						Battery_Change_Mode(CFG_BAT2);
 					}
 				}
-				else
+				else if (shark_xl_detected == 0 && shark_battery_get_voltage2() > shark_battery_get_voltage1() + SHARK_BATT_SINGLE_DELTA)
 				{
-					if((abs(sub_bms_info_1.packet_common.m_current) <= 1000)\
-						&&(shark_battery_get_voltage2() > shark_battery_get_voltage1()+ONE_BATTERY_DELTA_VOL))
-					{
-						Battery_Change_Mode(CFG_BAT2);
-					}
+					Battery_Change_Mode(CFG_BAT2);
 				}
 				break;
 			case CB_BAT2:
@@ -1715,13 +1538,9 @@ void Intelligent_Management_Battery(void)
 						Battery_Change_Mode(CFG_BAT1);
 					}
 				}
-				else
+				else if (shark_xl_detected == 0 && shark_battery_get_voltage1() > shark_battery_get_voltage2() + SHARK_BATT_SINGLE_DELTA)
 				{
-					if((abs(sub_bms_info_2.packet_common.m_current) <= 1000)\
-						&&(shark_battery_get_voltage1() > shark_battery_get_voltage2()+ONE_BATTERY_DELTA_VOL))
-					{
-						Battery_Change_Mode(CFG_BAT1);
-					}
+					Battery_Change_Mode(CFG_BAT1);
 				}
 				break;	
 			case CB_BAT_NO:

Source/app.h

@@ -1,7 +1,6 @@
 #ifndef APP_H
 #define APP_H
 
-//#define IS_CHARGE_IN()			!gpio_input_bit_get(GPIOC,GPIO_PIN_4)
 #define IS_CHARGER_ON() 		gpio_output_bit_get(GPIOB,GPIO_PIN_12)
 #define CHARG_PROTECT_OPEN(x)   gpio_bit_write(GPIOB,GPIO_PIN_12,(bit_status)(x))
 #define BAT1_IS_OPEN()          (!gpio_input_bit_get(GPIOC,GPIO_PIN_2))
@@ -15,17 +14,20 @@
 
 //#define BATTERY_RESISTANCE_OHM    (0.1F)
 #define PARRALLEL_DELTA_VOL    	  (2500)
-#define PARRALLEL_BL_DELTA_VOL    (500)
 
 #define CHARGE_DELAY_TIME_OUT_COUNT   (10000)
 
-#define ONE_BATTERY_DELTA_VOL    		(500)
-
 #define SHARK_CHARGE_CAPACITY_DELTA		2
 #define SHARK_CHARGER_VOLTAGE_MAX		60000
+
+#define SHARK_PARRALLEL_VOL_MIN			500
+#define SHARK_PARRALLEL_VOL_MAX			1000
+
 #define SHARK_BATT_VOLTAGE_FUZZ			10000
 #define SHARK_SERIES_MAX_TIMES			10
 
+#define SHARK_BATT_SINGLE_DELTA			2000
+
 enum
 {
 	PRE_PARRALLEL,
@@ -184,8 +186,6 @@ uint8_t Is_BAT1_Lock(void);
 
 uint8_t Is_BAT2_Lock(void);
 
-void Check_Charge_In(void);
-
 void Check_CB_Operate_State(void);
 
 uint8_t Battery_Change_Mode(uint8_t cfg_mode);

Source/app_end_ctr.c

@@ -11,6 +11,7 @@
 #include "drv_io.h"
 #include "measure_vol.h"
 #include "shark_xl.h"
+#include "shark_charge.h"
 
 END_CTR_SELF_SEND_STATUS end_ctr_self_ss;
 END_CTR_SELF_SEND_STATUS end_ctr_self_ss_new;
@@ -148,12 +149,14 @@ int8_t Handle_Can_Ctr_CMD(CAN_FRAME*can_ctr_frame)
 			is_intelligent = buf[2];
 			break;
 		case KEY_END_CTR_BAT_INT_PRE:
+#if 0
 			if(buf[2] == 1)
 				CB_OPERATE_PRECEDENCE_Config = PRE_SERIES;
 			else if(buf[2] == 2)
 				CB_OPERATE_PRECEDENCE_Config = PRE_PARRALLEL;
 			else
 				return 0;
+#endif
 			break;
 		case KEY_END_CTR_SOFT_WARE:	
 			break;
@@ -522,7 +525,10 @@ int8_t Rsp_Can_Ctr_CMD(CAN_FRAME*can_ctr_frame)
 				case 5:
 					buf[len++] = sub_bms_info_1.packet_common.bms_status;
 					buf[len++] = sub_bms_info_2.packet_common.bms_status;
-					println("%d %d %d %d", shark_battery_get_capacity1(), shark_battery_get_capacity2(), shark_battery_get_voltage1(), shark_battery_get_voltage2());
+					println("soc: %d %d, vol: %d %d, curr: %d %d",
+						shark_battery_get_capacity1(), shark_battery_get_capacity2(),
+						shark_battery_get_voltage1(), shark_battery_get_voltage2(),
+						shark_battery_get_current1(), shark_battery_get_current2());
 					break;
 				case 6:
 					buf[len++] = cb_operate_state;
@@ -533,7 +539,7 @@ int8_t Rsp_Can_Ctr_CMD(CAN_FRAME*can_ctr_frame)
 				case 7:
 					buf[len++] = end_ctr_self_ss_new.acc12_sta << 4 | ACC2_Dect();
 					buf[len++] = end_ctr_self_ss_new.qd_sta << 4 | QD_Dect();
-					buf[len++] = IS_CHARGE_IN() << 4 | IS_CHARGER_ON();
+					buf[len++] = gpio_input_bit_get(GPIO_PORT_CHG_DET, GPIO_PIN_CHG_DET) << 4 | shark_charger_detected << 1 | shark_charger_enabled;
 					buf[len++] = sub_bms_info_1.packet_common.charge_flag << 4 | sub_bms_info_2.packet_common.charge_flag;
 					break;
 				case 8:
@@ -717,7 +723,7 @@ void Check_End_Ctr_Status(void)
 	}
 
 	//
-	end_ctr_self_ss_new.charger_in = IS_CHARGE_IN();
+	end_ctr_self_ss_new.charger_in = shark_charger_enabled;
 	
 	end_ctr_self_ss_new.moto_temp = ctr_temperature[1];
 

Source/app_rs485_1.c

@@ -7,6 +7,7 @@
 #include "drv_io.h"
 #include "measure_vol.h"
 #include "shark_xl.h"
+#include "shark_charge.h"
 
 SUB_BMS_INFO sub_bms_info_1 = {
 	.uart = USART0,
@@ -215,7 +216,7 @@ shark_bool shark_battery_send_command(SUB_BMS_INFO *info)
 	buf[body->size++] = info->sub_bms_cmd.operate;
 
 	//¶ÔÂë
-	buf[body->size++] = cang_wei;
+	buf[body->size++] = shark_charger_enabled ? CW_CHE_SHANG_CHARGER : CW_CHE_SHANG_NO_CHARGER;
 	buf[body->size++] = 0;
 	buf[body->size++] = 0;
 	buf[body->size++] = 0;

Source/app_rs485_1.h

@@ -411,6 +411,21 @@ static inline u8 shark_battery_get_capacity2(void)
 	return shark_battery_get_capacity(&sub_bms_info_2);
 }
 
+static inline s32 shark_battery_get_current(SUB_BMS_INFO *info)
+{
+	return info->packet_common.m_current;
+}
+
+static inline s32 shark_battery_get_current1(void)
+{
+	return shark_battery_get_current(&sub_bms_info_1);
+}
+
+static inline s32 shark_battery_get_current2(void)
+{
+	return shark_battery_get_current(&sub_bms_info_2);
+}
+
 static inline shark_bool shark_battery_charge_complete(SUB_BMS_INFO *info)
 {
 	return (info->packet_common.bms_status & BMS_STA_C_FULL) != 0;

Source/delay.c

@@ -164,8 +164,6 @@ void SysTick_Handler(void)
 
 	ADAS_Timeout();
 
-	Check_Charger_Timeout();
-
 	Series_Delay_Timeout();
 
 	Enter_Sleep_Delay_Timeout();

Source/drv_io.c

@@ -6,7 +6,6 @@
 #include "app_end_ctr.h"
 #include "shark_xl.h"
 
-CHECK_CHARGER check_charger;
 DELAY_COMMON side_stay_dec_delay;
 DELAY_COMMON sti_dec_delay;
 DELAY_COMMON repair_dec_delay;
@@ -18,8 +17,6 @@ DELAY_COMMON right_light_delay;
 
 DELAY_COMMON shield_xl;
 
-DELAY_COMMON charge_delay;
-
 CTR_DELAY_COMMON soak_dec_delay;
 
 #define ACC2_USE_PWM (1)
@@ -233,16 +230,6 @@ void _CB_Operate_Initial(void)
 	
 }
 
-void Charge_Dec_IRQ_Initial(void)
-{
-	rcu_periph_clock_enable(RCU_AF);
-	
-	nvic_irq_enable(EXTI4_IRQn,1,0);
-	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_4);
-	exti_init(EXTI_4, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
-    exti_interrupt_flag_clear(EXTI_4);
-	
-}
 void GPIO_Initial(void)
 {
 	rcu_periph_clock_enable(RCU_GPIOA);
@@ -277,14 +264,6 @@ void GPIO_Initial(void)
 	gpio_init(GPIOA,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_15);
 	gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_3);
 	Enable_12V(0);
-	
-	//CHARGER
-	
-	gpio_init(GPIOC,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_4);
-	
-	gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_12);
-
-	Charge_Dec_IRQ_Initial();
 
 
 
@@ -295,62 +274,6 @@ void GPIO_Initial(void)
 	
 }
 
-void Set_Charger_In(uint8_t value)
-{
-	if(battery_charged_full == 0)
-	{
-		check_charger.cc_is_charger_in = value;
-		if(value)
-			cang_wei = CW_CHE_SHANG_CHARGER;
-		else
-			cang_wei = CW_CHE_SHANG_NO_CHARGER;
-	}
-}
-uint8_t IS_CHARGE_IN(void)
-{
-	return check_charger.cc_is_charger_in;
-}
-
-void Check_Charger_Timeout(void)
-{
-#if 0
-	if(check_charger.cc_set)
-	{
-		if(++check_charger.cc_time_count >= CC_TIME_OUT_COUNT)
-		{
-			if(check_charger.cc_pulse_count >= CC_PULSE_MIN_COUNT)
-			{
-				check_charger.cc_is_charger_in = 1;	
-			}
-			else if(check_charger.cc_pull_out_set == 0)
-			{
-				check_charger.cc_is_charger_in = 1;	
-			}
-			else 
-			{
-				check_charger.cc_is_charger_in = 0;	
-			}
-			check_charger.cc_set = 0;
-			check_charger.cc_time_count = 0;
-			check_charger.cc_pulse_count = 0;
-		}
-	}
-#endif
-
-	if(charge_delay.set)
-		charge_delay.count++;
-	
-#if 0
-	if(check_charger.cc_pull_out_set)
-	{
-		if(++check_charger.cc_pull_out_time_count >= CC_PULL_OUT_TIME_OUT_COUNT)
-		{
-			memset(&check_charger, 0x00,sizeof(check_charger));	
-		}
-	}
-#endif
-}
-
 void EXTI0_IRQHandler(void)
 {
 	if (RESET != exti_interrupt_flag_get(EXTI_0))
@@ -384,42 +307,6 @@ void EXTI3_IRQHandler(void)
         exti_interrupt_flag_clear(EXTI_3);
     }
 }
-void EXTI4_IRQHandler(void)
-{
-	if (RESET != exti_interrupt_flag_get(EXTI_4))
-	{  
-        exti_interrupt_flag_clear(EXTI_4);
-
-		if(gpio_input_bit_get(GPIOC,GPIO_PIN_4) == 0)
-		{
-#if 0
-			if( check_charger.cc_is_charger_in)
-				return;
-			
-			if(check_charger.cc_set == 0)
-			{
-				check_charger.cc_set = 1;
-				check_charger.cc_time_count = 0;
-				check_charger.cc_pulse_count = 0;
-			}
-			
-			check_charger.cc_pulse_count++;
-#else
-		Set_Charger_In(1);
-#endif
-		}
-#if 0
-		else
-		{
-			if( check_charger.cc_is_charger_in == 0)
-				return;
-
-			check_charger.cc_pull_out_set = 1;
-			check_charger.cc_pull_out_time_count = 0;
-		}
-#endif		
-    }
-}
 
 void EXTI5_9_IRQHandler(void)
 {

Source/drv_io.h

@@ -72,7 +72,6 @@ typedef struct
 	
 }CHECK_CHARGER;
 
-extern CHECK_CHARGER check_charger;
 extern DELAY_COMMON side_stay_dec_delay;
 extern CTR_DELAY_COMMON soak_dec_delay;
 extern DELAY_COMMON sti_dec_delay;
@@ -83,7 +82,6 @@ extern DELAY_COMMON acc2_delay;
 extern DELAY_COMMON left_light_delay;
 extern DELAY_COMMON right_light_delay;
 
-extern DELAY_COMMON charge_delay;
 extern uint8_t battery_charged_full;
 extern uint8_t QD_switch_from;
 
@@ -108,16 +106,8 @@ void ACC2_PWM(void);
 
 void ACC2_Enable(uint8_t on);
 
-void Check_Charger_Timeout(void);
-
-uint8_t IS_CHARGE_IN(void);
-
-void Set_Charger_In(uint8_t value);
-
 void QD_Enable_From(uint8_t on,uint8_t from);
 
-uint8_t IS_CHARGE_IN(void);
-
 uint8_t ACC2_Is_On(void);
 
 void Check_S11_May_Operate(void);

Source/main.c

@@ -17,6 +17,7 @@
 #include "sw_build_info.h"
 #include "shark_xl.h"
 #include "drv_usart.h"
+#include "shark_charge.h"
 
 #ifdef CONFIG_CAN_IAP
 extern void qws_iap_write_magic(uint32_t magic);
@@ -150,6 +151,8 @@ int main(void)
 	systick_config();
 
 	shark_xl_init();
+	shark_charge_init();
+
 	Misc_Initial();
 
 	Sub_BMS_1_Initial();
@@ -201,10 +204,6 @@ int main(void)
 
 		Intelligent_Management_Battery();
 
-		//Check_Battery_Small_Current();
-		
-		Check_Charge_In();
-
 		Check_End_Ctr_Status();
 		
 		Check_Can_Self_Send_Status();
@@ -214,8 +213,9 @@ int main(void)
 		// Check_S11_May_Operate();
 
 		Check_Enable_Test_Info();
-		
+
 		shark_uart_poll();
+		shark_charge_poll();
 		
 		if(g_event & BMS_1_RESEND_CMD_EVENT)
 		{

Source/shark_charge.c

@@ -0,0 +1,106 @@
+#include "shark_charge.h"
+#include "app_rs485_1.h"
+#include "app.h"
+
+shark_bool shark_charger_detected;
+shark_bool shark_charger_enabled;
+shark_bool shark_battery_full;
+
+shark_u16 shark_charger_debounce;
+
+void shark_charge_init(void)
+{
+	rcu_periph_clock_enable(GPIO_RCU_CHG_DET);
+	gpio_init(GPIO_PORT_CHG_DET, GPIO_MODE_IN_FLOATING, GPIO_OSPEED_50MHZ, GPIO_PIN_CHG_DET);
+
+	rcu_periph_clock_enable(GPIO_RCU_CHG_EN);
+	gpio_init(GPIO_PORT_CHG_EN, GPIO_MODE_OUT_PP, GPIO_OSPEED_50MHZ, GPIO_PIN_CHG_EN);
+
+	gpio_exti_source_select(EXTI_PORT_CHG_DET, EXTI_PIN_CHG_DET);
+	exti_init(EXTI_CHG_DET, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
+	exti_interrupt_flag_clear(EXTI_CHG_DET);
+	nvic_irq_enable(EXTI4_IRQn , 1, 0);
+}
+
+void shark_charger_set_enable(shark_bool enable)
+{
+	if (sub_bms_info_1.packet_common.m_percent > 99 && sub_bms_info_2.packet_common.m_percent > 99) {
+		shark_battery_full = shark_true;
+	}
+
+	if (sub_bms_info_1.packet_common.m_percent < 97 || sub_bms_info_2.packet_common.m_percent < 97) {
+		shark_battery_full = shark_false;
+	}
+
+	if (shark_battery_full || cb_operate_state == CB_BAT1_BAT2_SERIES) {
+		enable = shark_false;
+	}
+
+	if (shark_charger_enabled != enable) {
+		shark_charger_enabled = enable;
+
+		if (enable) {
+			gpio_bit_set(GPIO_PORT_CHG_EN, GPIO_PIN_CHG_EN);
+			println("charger enabled");
+		} else {
+			gpio_bit_reset(GPIO_PORT_CHG_EN, GPIO_PIN_CHG_EN);
+			shark_charger_debounce = SHARK_CHG_DEBOUNCE;
+			println("charger disabled");
+		}
+	}
+}
+
+void shark_charge_tick(void)
+{
+	if (shark_charger_debounce > 0) {
+		if (shark_charger_debounce > 1) {
+			shark_charger_debounce--;
+		} else {
+			shark_charger_debounce = 0;
+			shark_charger_detected = shark_charger_detect();
+
+			if (shark_charger_detected)
+			cang_wei = CW_CHE_SHANG_CHARGER;
+		else
+			cang_wei = CW_CHE_SHANG_NO_CHARGER;
+		}
+	}
+}
+
+void shark_charge_poll(void)
+{
+	if (shark_charger_detected) {
+		if (shark_charger_enabled) {
+			switch (cb_operate_state) {
+			case CB_BAT1:
+				if (sub_bms_info_1.packet_common.charge_flag == 0) {
+					shark_charger_set_enable(shark_false);
+				}
+				break;
+
+			case CB_BAT2:
+				if (sub_bms_info_2.packet_common.charge_flag == 0) {
+					shark_charger_set_enable(shark_false);
+				}
+				break;
+
+			case CB_BAT1_BAT2_PARRALLEL:
+				if (sub_bms_info_1.packet_common.charge_flag == 0 && sub_bms_info_2.packet_common.charge_flag == 0) {
+					shark_charger_set_enable(shark_false);
+				}
+				break;
+			}
+		} else {
+			shark_charger_set_enable(shark_true);
+		}
+	}
+}
+
+void EXTI4_IRQHandler(void)
+{
+	if (exti_flag_get(EXTI_4) != RESET) {
+		exti_flag_clear(EXTI_4);
+		shark_charger_debounce = SHARK_CHG_DEBOUNCE;
+	}
+}
+

Source/shark_charge.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "shark_types.h"
+#include "common.h"
+
+#define SHARK_CHG_DEBOUNCE			300
+
+#define GPIO_PORT_CHG_DET			GPIOC
+#define GPIO_PIN_CHG_DET			GPIO_PIN_4
+#define GPIO_RCU_CHG_DET			RCU_GPIOC
+
+#define GPIO_PORT_CHG_EN			GPIOB
+#define GPIO_PIN_CHG_EN				GPIO_PIN_12
+#define GPIO_RCU_CHG_EN				RCU_GPIOB
+
+#define EXTI_PORT_CHG_DET			GPIO_PORT_SOURCE_GPIOC
+#define EXTI_PIN_CHG_DET			GPIO_PIN_SOURCE_4
+#define EXTI_CHG_DET				EXTI_4
+
+extern shark_bool shark_charger_detected;
+extern shark_bool shark_charger_enabled;
+extern shark_bool shark_battery_full;
+
+void shark_charger_set_enable(shark_bool enable);
+void shark_charge_init(void);
+void shark_charge_tick(void);
+void shark_charge_poll(void);
+void shark_charge_isr(void);
+
+static inline shark_bool shark_charger_detect(void)
+{
+	return !gpio_input_bit_get(GPIO_PORT_CHG_DET, GPIO_PIN_CHG_DET);
+}

Source/shark_xl.c

@@ -9,6 +9,8 @@ shark_u16 shark_xl_speed_max;
 shark_u16 shark_xl_speed_tmp;
 shark_u16 shark_xl_speed;
 
+shark_u8 shark_xl_detected;
+
 void shark_xl_init(void)
 {
 	rcu_periph_clock_enable(GPIO_RCU_XL);
@@ -28,6 +30,8 @@ void shark_xl_tick(void)
 			shark_xl_speed_tmp++;
 		}
 	} else {
+		shark_bool state;
+
 		shark_xl_ticks = 0;
 
 		if (shark_xl_skip > 0) {
@@ -37,7 +41,14 @@ void shark_xl_tick(void)
 			shark_xl_speed = shark_xl_speed_tmp;
 		}
 
-		end_ctr_self_ss_new.xl_sta = (shark_xl_speed > CONFIG_XL_MIN);
+		state = (shark_xl_speed > CONFIG_XL_MIN);
+		end_ctr_self_ss_new.xl_sta = state;
+
+		if (state) {
+			shark_xl_detected = SHARK_XL_DEBOUNCE;
+		} else if (shark_xl_detected > 0) {
+			shark_xl_detected--;
+		}
 
 		if (shark_xl_speed_max < shark_xl_speed) {
 			shark_xl_speed_max = shark_xl_speed;

Source/shark_xl.h

@@ -14,6 +14,8 @@
 #define EXTI_PIN_XL			GPIO_PIN_SOURCE_7
 #define EXTI_XL				EXTI_7
 
+#define SHARK_XL_DEBOUNCE	10
+
 extern shark_u16 shark_xl_ticks;
 extern shark_u8 shark_xl_skip;
 
@@ -21,6 +23,8 @@ extern shark_u16 shark_xl_speed_max;
 extern shark_u16 shark_xl_speed_tmp;
 extern shark_u16 shark_xl_speed;
 
+extern shark_u8 shark_xl_detected;
+
 void shark_xl_init(void);
 void shark_xl_tick(void);
 void shark_xl_isr(void);

Source/sw_build_info.h

@@ -1,3 +1,3 @@
 #pragma once
 
-#define CONFIG_VERSION "PS100XX_V11_11151938"
+#define CONFIG_VERSION "PS100XX_V11_11181649"