PS100/Source/drv_io.c

#include "common.h" 
#include "drv_io.h"
#include "hardware_test.h"
#include "app_rs485_1.h"
#include "app.h"

CHECK_CHARGER check_charger;
DELAY_COMMON side_stay_dec_delay;
DELAY_COMMON sti_dec_delay;
DELAY_COMMON repair_dec_delay;
DELAY_COMMON qd_dec_delay;
DELAY_COMMON xl_dec_delay;
DELAY_COMMON acc2_dec_delay;

DELAY_COMMON left_light_delay;
DELAY_COMMON right_light_delay;

DELAY_COMMON shield_xl;

DELAY_COMMON charge_delay;

CTR_DELAY_COMMON soak_dec_delay;

uint32_t xl_count = 0;

#define ACC2_USE_PWM (1)

uint8_t battery_charged_full = 0;
uint8_t QD_switch_from = 0;

static shark_bool shark_bms_acc2_enabled;
static u16 shark_bms_acc2_error_times;
static u16 shark_bms_acc2_work_times;

void QD_Enable_From(uint8_t on,uint8_t from)
{
	if (shark_battery_switch_busy && on) {
		println("qd busy");
		return;
	}

	println("qd: %d %d", on, from);

	// Check_S11(on,FROM_QD);
	QD_Enable(on);
	QD_switch_from = from;
}

uint8_t ACC2_Is_On(void)
{
	return shark_bms_acc2_enabled;
}

void ACC2_PWM(void)
{
#if 0
	if(acc2_delay.set)
	{
		++acc2_delay.count;
		if(acc2_delay.count >= ACC2_ENABLE_TIMEOUT)
		{
			gpio_bit_write(GPIOC,GPIO_PIN_15,(bit_status)0x01);
			memset(&acc2_delay,0x00,sizeof(acc2_delay));
		}
		else
			gpio_bit_write(GPIOC,GPIO_PIN_15,(bit_status)(acc2_delay.count&0x01));
	}
#else
	if (shark_bms_acc2_work_times < 200) {
		if (shark_bms_acc2_enabled == shark_false) {
			shark_bms_acc2_work_times = 0xFFFF;
			QD_Enable_From(0, 9);
		} else if (ACC2_Over_Loader_Dect()) {
			gpio_bit_reset(GPIO_PORT_ACC2_EN, GPIO_PIN_ACC2_EN);
			shark_bms_acc2_work_times = 0;
			shark_bms_acc2_error_times++;

			if (ACC2_Dect()) {
				if (shark_bms_acc2_error_times > 1000) {
					shark_bms_acc2_enabled = shark_false;
					println("acc2 err1");
				}
			} else if (shark_bms_acc2_error_times > 500) {
				shark_bms_acc2_enabled = shark_false;
				println("acc2 err2");
			}
		} else {
			gpio_bit_set(GPIO_PORT_ACC2_EN, GPIO_PIN_ACC2_EN);
			shark_bms_acc2_work_times++;

			if (shark_bms_acc2_work_times == 200) {
				shark_bms_acc2_error_times = 0;
				println("acc2 ready");
			}
		}
	}
#endif
}

void ACC2_Enable(uint8_t on)
{
	if (shark_battery_switch_busy && on) {
		println("acc2 busy");
		return;
	}

	println("acc2: %d", on);

	shark_bms_acc2_enabled = SHARK_BOOL(on);
	shark_bms_acc2_error_times = 0;
	shark_bms_acc2_work_times = 0;

	shark_bms_set_vgs(SHARK_BMS_VGS_ACC2, SHARK_BOOL(on));
	gpio_bit_write(GPIO_PORT_ACC2_EN, GPIO_PIN_ACC2_EN, (bit_status) on);
}

void E_CTR_Dec_IRQ_Initial(void)
{
	rcu_periph_clock_enable(RCU_AF);
	
	nvic_irq_enable(EXTI10_15_IRQn,1,0);
	
	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_10);
	exti_init(EXTI_10, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
    exti_interrupt_flag_clear(EXTI_10);
	
	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_11);
	exti_init(EXTI_11, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
    exti_interrupt_flag_clear(EXTI_11);
	
	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_12);
	exti_init(EXTI_12, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
    exti_interrupt_flag_clear(EXTI_12);

	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_14);
	exti_init(EXTI_14, EXTI_INTERRUPT, EXTI_TRIG_FALLING);
	exti_interrupt_flag_clear(EXTI_14);

	//QD
	nvic_irq_enable(EXTI5_9_IRQn,1,0);
	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOB, GPIO_PIN_SOURCE_6);
	exti_init(EXTI_6, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
    exti_interrupt_flag_clear(EXTI_6);

	//ACC2
	nvic_irq_enable(EXTI0_IRQn,1,0);
	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOD, GPIO_PIN_SOURCE_0);
	exti_init(EXTI_0, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
    exti_interrupt_flag_clear(EXTI_0);

	//XL
	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOB, GPIO_PIN_SOURCE_7);
	exti_init(EXTI_7, EXTI_INTERRUPT, EXTI_TRIG_FALLING);
    exti_interrupt_flag_clear(EXTI_7);

#if CONFIG_BATT_DET_USE_IRQ
	// BAT1 DET
	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_2);
	exti_init(EXTI_2, EXTI_INTERRUPT, EXTI_TRIG_RISING);
	exti_interrupt_flag_clear(EXTI_2);
	nvic_irq_enable(EXTI2_IRQn, 1, 0);

	// BAT2 DET
	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOC, GPIO_PIN_SOURCE_1);
	exti_init(EXTI_1, EXTI_INTERRUPT, EXTI_TRIG_RISING);
	exti_interrupt_flag_clear(EXTI_1);
	nvic_irq_enable(EXTI1_IRQn, 1, 0);
#endif
}
void E_CTR_Initial(void)
{
	/* enable the clock of peripherals */
    rcu_periph_clock_enable(RCU_GPIOC);
	gpio_init(GPIOC,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_15);
	ACC2_Enable(0);
	
	gpio_init(GPIOC,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_14);

	rcu_periph_clock_enable(RCU_GPIOD);
	rcu_periph_clock_enable(RCU_AF);
	gpio_pin_remap_config(GPIO_PD01_REMAP,ENABLE);
	gpio_init(GPIOD,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_0);
	//
	gpio_init(GPIOC,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_6|GPIO_PIN_7);
	Left_Light_Enable(0);
	Right_Light_Enable(0);

	rcu_periph_clock_enable(RCU_GPIOB);
	gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_0|GPIO_PIN_1);
	Tail_Light_Enable(0);
	Carpet_Light_Enable(0);

	//
	gpio_init(GPIOC,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12|GPIO_PIN_13);

	//
	rcu_periph_clock_enable(RCU_GPIOB);
	//gpio_pin_remap_config(GPIO_SWJ_NONJTRST_REMAP,ENABLE);
	gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_5|GPIO_PIN_4);
	Lock_Enable(0);
	//QD_Enable(0);
	QD_Enable_From(0,5);
	gpio_init(GPIOB,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_6|GPIO_PIN_7);

	E_CTR_Dec_IRQ_Initial();

	side_stay_dec_delay.set = 1;
	side_stay_dec_delay.count = SIDE_STAY_DEC_TIMEOUT;
	soak_dec_delay.enable = 1;
	soak_dec_delay.set = 1;
	soak_dec_delay.count = SOAK_DEC_TIMEOUT;
	sti_dec_delay.set = 1;
	sti_dec_delay.count = STI_DEC_TIMEOUT;
	repair_dec_delay.set = 1;
	repair_dec_delay.count = REPAIR_DEC_TIMEOUT;
	qd_dec_delay.set = 1;
	qd_dec_delay.count = QD_DEC_TIMEOUT;
	xl_dec_delay.set = 1;
	xl_dec_delay.count = XL_DEC_TIMEOUT;
	acc2_dec_delay.set = 1;
	acc2_dec_delay.count = ACC2_DEC_TIMEOUT;
	

	memset(&left_light_delay,0x00,sizeof(DELAY_COMMON));
	memset(&right_light_delay,0x00,sizeof(DELAY_COMMON));

	memset(&shield_xl,0x00,sizeof(DELAY_COMMON));
	
}

void _CB_Operate_Initial(void)
{
	rcu_periph_clock_enable(RCU_GPIOB);
	gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_15|GPIO_PIN_13|GPIO_PIN_14);
	
}

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);
	rcu_periph_clock_enable(RCU_GPIOB);
	rcu_periph_clock_enable(RCU_GPIOC);
	rcu_periph_clock_enable(RCU_AF);
	
	gpio_init(GPIOC,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_0);
	gpio_init(GPIOC,GPIO_MODE_IPU,GPIO_OSPEED_50MHZ,GPIO_PIN_1|GPIO_PIN_2);

	//
	gpio_init(GPIOA,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_12);

#if 0
#if 1
	gpio_bit_reset(GPIOA,GPIO_PIN_12);
	gpio_bit_reset(GPIOA,GPIO_PIN_8);

#else	
	gpio_bit_set(GPIOA,GPIO_PIN_12);
	gpio_bit_set(GPIOA,GPIO_PIN_8);
#endif
#else
	//test-start
	Can_Power_Enable(0);
	//test-end
#endif

	
	//
	gpio_pin_remap_config(GPIO_SWJ_SWDPENABLE_REMAP,ENABLE);
	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();



	//
	gpio_init(GPIOB,GPIO_MODE_OUT_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_2);
	shark_bms_set_vgs(SHARK_BMS_VGS_ALL, shark_false);
	
	
}

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))
	{  
        exti_interrupt_flag_clear(EXTI_0);
		acc2_dec_delay.set = 1;
		acc2_dec_delay.count = 0;
    }
}

#if CONFIG_BATT_DET_USE_IRQ
void EXTI1_IRQHandler(void)
{
	if (RESET != exti_flag_get(EXTI_1)) {
		exti_flag_clear(EXTI_1);
	}
}

void EXTI2_IRQHandler(void)
{
	if (RESET != exti_flag_get(EXTI_2)) {
		exti_flag_clear(EXTI_2);
	}
}
#endif

void EXTI3_IRQHandler(void)
{
	if (RESET != exti_interrupt_flag_get(EXTI_3))
	{  
        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)
{
	if (RESET != exti_interrupt_flag_get(EXTI_5))
	{  
        exti_interrupt_flag_clear(EXTI_5);
    }

	if (RESET != exti_interrupt_flag_get(EXTI_6))
	{  
        exti_interrupt_flag_clear(EXTI_6);
		qd_dec_delay.set = 1;
		qd_dec_delay.count = 0;
    }

	if (RESET != exti_interrupt_flag_get(EXTI_7))
	{  
        exti_interrupt_flag_clear(EXTI_7);
		if(shield_xl.set == 0)
			++xl_count;
		else
			xl_count = 0;
    }
	
	if (RESET != exti_interrupt_flag_get(EXTI_8))
	{  
        exti_interrupt_flag_clear(EXTI_8);
		extern void ADAS_Measure_Ju_Li_1(void);
		ADAS_Measure_Ju_Li_1();
    }
	if (RESET != exti_interrupt_flag_get(EXTI_9))
	{  
        exti_interrupt_flag_clear(EXTI_9);
		extern void ADAS_Measure_Ju_Li_2(void);
		ADAS_Measure_Ju_Li_2();
    }

	
}

void EXTI10_15_IRQHandler(void)
{
	if (RESET != exti_interrupt_flag_get(EXTI_10))
	{  
        exti_interrupt_flag_clear(EXTI_10);
		side_stay_dec_delay.set = 1;
		side_stay_dec_delay.count = 0;
    }
	if (RESET != exti_interrupt_flag_get(EXTI_11))
	{  
        exti_interrupt_flag_clear(EXTI_11);
		if(soak_dec_delay.enable)
		{
			soak_dec_delay.set = 1;
			soak_dec_delay.count = 0;
		}
    }
	if (RESET != exti_interrupt_flag_get(EXTI_12))
	{  
        exti_interrupt_flag_clear(EXTI_12);
		sti_dec_delay.set = 1;
		sti_dec_delay.count = 0;
    }

	if (RESET != exti_interrupt_flag_get(EXTI_13))
	{  
        exti_interrupt_flag_clear(EXTI_13);
		
    }
	
	if (RESET != exti_interrupt_flag_get(EXTI_14))
	{  
		exti_interrupt_flag_clear(EXTI_14);
		gpio_bit_reset(GPIO_PORT_ACC2_EN, GPIO_PIN_ACC2_EN);
		shark_bms_acc2_work_times = 0;
		over_12V = 1;
    }
	if (RESET != exti_interrupt_flag_get(EXTI_15))
	{  
        exti_interrupt_flag_clear(EXTI_15);
    }
}