#include "bsp/pwm.h"
#include "bsp/adc.h"
#include "libs/task.h"
/*
以下主要是在某一相电路无法采集的时候，需要对这相的pwm挖坑处理
timer 分配:
timer0 -> ch0-2 互补pwm
        ch4 event, update event 触发DMA(ch3,4)实现CCR的自更新
timer1 -> 触发ADC采样，GD32不支持多channel 或方式触发输出，通过timer1的 ch0 compara 配置 TRGO触发ADC，但是需要在一个PWM周期内触发2次（单电阻）
timer0 master --> timer1 slave/master 确保timer0，1同步开始，同频同相位

DMA 分配：
DMA0 ch4 -> timer0 update event
    ch3 -> timer0 chan3 CC event

    ch1 -> timer1 update event，需要更新CCR
*/

static void _init_pwm_timer(void);
static void _init_adc_timer(void);
static void _init_aux_timer(void);
static void _pwm_gpio_config(void);
static void _gpio_brakein_irq_enable(void);

void pwm_3phase_init(void){
	_pwm_gpio_config();
    _init_pwm_timer();
    if (pwm_timer != adc_timer) {
		_init_adc_timer();
		_init_aux_timer();
    }
}

static rcu_periph_enum _rcu_clk(u32 timer) {
    if (timer == TIMER0) {
        return RCU_TIMER0;
    }
    if (timer == TIMER1) {
        return RCU_TIMER1;
    }
    if (timer == TIMER2) {
        return RCU_TIMER2;
    }
    return RCU_TIMER2;      
}

static void _pwm_gpio_config(void)
{
    rcu_periph_clock_enable(RCU_GPIOA);
    rcu_periph_clock_enable(RCU_GPIOB);
    rcu_periph_clock_enable(RCU_AF);

    /*configure PA8 PA9 PA10(TIMER0 CH0 CH1 CH2) as alternate function*/
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_8);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_9);
    gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_10);

    /*configure PB13 PB14 PB15(TIMER0 CH0N CH1N CH2N) as alternate function*/
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_13);
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_14);
    gpio_init(GPIOB,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_15);
	/*configure BRAKE IN*/
#if USER_ITMER_BRAKE==1
	gpio_init(GPIOA,GPIO_MODE_AF_PP,GPIO_OSPEED_50MHZ,GPIO_PIN_6);
#else
	gpio_init(GPIOB,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_4);//高刹车
	gpio_init(GPIOB,GPIO_MODE_IN_FLOATING,GPIO_OSPEED_50MHZ,GPIO_PIN_5);//低刹车
#endif
}


static void _init_pwm_timer(void) {
	timer_oc_parameter_struct timer_ocintpara;
	timer_parameter_struct timer_initpara;
	
	u32 timer = pwm_timer;
	u32 half_period = FOC_PWM_Half_Period;
	rcu_periph_clock_enable(_rcu_clk(timer));

	timer_deinit(timer);

    /* TIMER0 configuration */
	memset(&timer_initpara, 0, sizeof(timer_initpara));
	memset(&timer_ocintpara, 0, sizeof(timer_ocintpara));
    timer_initpara.prescaler        = 0;
    timer_initpara.alignedmode      = TIMER_COUNTER_CENTER_BOTH;
    timer_initpara.period          = half_period;
    timer_initpara.clockdivision    = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(timer,&timer_initpara);

    /* CH1,CH2 and CH3 configuration in PWM mode */
    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_ENABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocnpolarity  = TIMER_OCN_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;
    timer_ocintpara.ocnidlestate = TIMER_OCN_IDLE_STATE_LOW;

    timer_channel_output_config(timer,TIMER_CH_0,&timer_ocintpara);
    timer_channel_output_pulse_value_config(timer,TIMER_CH_0,half_period);
    timer_channel_output_mode_config(timer,TIMER_CH_0,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(timer,TIMER_CH_0,TIMER_OC_SHADOW_ENABLE);

    timer_channel_output_config(timer,TIMER_CH_1,&timer_ocintpara);
    timer_channel_output_pulse_value_config(timer,TIMER_CH_1,half_period);
    timer_channel_output_mode_config(timer,TIMER_CH_1,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(timer,TIMER_CH_1,TIMER_OC_SHADOW_ENABLE);

    timer_channel_output_config(timer,TIMER_CH_2,&timer_ocintpara);
    timer_channel_output_pulse_value_config(timer,TIMER_CH_2,half_period);
    timer_channel_output_mode_config(timer,TIMER_CH_2,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(timer,TIMER_CH_2,TIMER_OC_SHADOW_ENABLE);
    

    /* chan3 trigger adc O3CPRE is alwary active high, adc trigger is falling */
    timer_channel_output_config(timer,TIMER_CH_3,&timer_ocintpara);
    timer_channel_output_pulse_value_config(timer,TIMER_CH_3,half_period);
    timer_channel_output_mode_config(timer,TIMER_CH_3,TIMER_OC_MODE_PWM0);
    timer_channel_output_shadow_config(timer,TIMER_CH_3,TIMER_OC_SHADOW_ENABLE);

#if USER_ITMER_BRAKE==1
	timer_break_parameter_struct timer_breakpara;
    /* automatic output enable, break, dead time and lock configuration*/
    timer_breakpara.runoffstate     = TIMER_ROS_STATE_DISABLE;
    timer_breakpara.ideloffstate    = TIMER_IOS_STATE_DISABLE ;
    timer_breakpara.deadtime        = 1; // one Time of DTS, abort deadtime
    timer_breakpara.breakpolarity    = TIMER_BREAK_POLARITY_LOW;
    timer_breakpara.outputautostate  = TIMER_OUTAUTO_ENABLE;
    timer_breakpara.protectmode     = TIMER_CCHP_PROT_0;
    timer_breakpara.breakstate      = TIMER_BREAK_ENABLE;
    timer_break_config(TIMER0,&timer_breakpara);
	timer_interrupt_enable(timer, TIMER_INT_BRK);
	timer_interrupt_flag_clear(timer, TIMER_INT_FLAG_BRK);
	nvic_irq_enable(TIMER0_BRK_IRQn, 1, 0);		
#else
	_gpio_brakein_irq_enable();
#endif
	if (pwm_timer != adc_timer){
    	/* select the master slave mode */
    	timer_master_slave_mode_config(timer,TIMER_MASTER_SLAVE_MODE_ENABLE);
    	/* slave mode selection: enabled when time2 is enable*/
    	timer_slave_mode_select(timer,TIMER_SLAVE_MODE_EVENT);
    	timer_input_trigger_source_select(timer,TIMER_SMCFG_TRGSEL_ITI2);
	}else {
		timer_master_slave_mode_config(timer,TIMER_MASTER_SLAVE_MODE_DISABLE);
	}
    timer_primary_output_config(timer,ENABLE);
    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(timer);

	timer_interrupt_enable(timer, TIMER_INT_UP);
	timer_interrupt_flag_clear(timer, TIMER_INT_FLAG_UP);
	nvic_irq_enable(TIMER0_UP_IRQn, 1, 0);	
	
    timer_enable(timer);
}

static void _init_adc_timer(void) {
    timer_oc_parameter_struct timer_ocintpara;
    timer_parameter_struct timer_initpara;
    u32 timer = adc_timer;
    u32 half_period = FOC_PWM_Half_Period;

    rcu_periph_clock_enable(_rcu_clk(timer));

    timer_deinit(timer);
	memset(&timer_initpara, 0, sizeof(timer_initpara));
	memset(&timer_ocintpara, 0, sizeof(timer_ocintpara));

    timer_initpara.prescaler        = 0;
    timer_initpara.alignedmode      = TIMER_COUNTER_CENTER_UP;
    timer_initpara.period          = FOC_PWM_period;
    timer_initpara.clockdivision    = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;
    timer_init(timer,&timer_initpara);


    timer_ocintpara.outputstate  = TIMER_CCX_ENABLE;
    timer_ocintpara.outputnstate = TIMER_CCXN_DISABLE;
    timer_ocintpara.ocpolarity   = TIMER_OC_POLARITY_HIGH;
    timer_ocintpara.ocidlestate  = TIMER_OC_IDLE_STATE_LOW;

    timer_channel_output_config(timer,TIMER_CH_0,&timer_ocintpara);


    timer_channel_output_pulse_value_config(timer,TIMER_CH_0,half_period);
    timer_channel_output_mode_config(timer,TIMER_CH_0,TIMER_OC_MODE_PWM1);
    timer_channel_output_shadow_config(timer,TIMER_CH_0,TIMER_OC_SHADOW_DISABLE);

    /* select the master slave mode */
    timer_master_slave_mode_config(timer,TIMER_MASTER_SLAVE_MODE_ENABLE);
    /* slave mode selection: enabled when time2 is enable*/
    timer_slave_mode_select(timer,TIMER_SLAVE_MODE_EVENT);
    timer_input_trigger_source_select(timer,TIMER_SMCFG_TRGSEL_ITI2);
	
    timer_primary_output_config(timer,ENABLE);

    /* auto-reload preload enable */
    timer_auto_reload_shadow_enable(timer);

	pwm_disable_channel();
	
    timer_enable(timer);
}

static void _gpio_brakein_irq_enable(void){
	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOB, GPIO_PIN_SOURCE_4);
	exti_init(EXTI_4, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
	nvic_irq_enable(EXTI4_IRQn, 4U, 0U);
	exti_interrupt_flag_clear(EXTI_4);
	exti_interrupt_enable(EXTI_4);

	gpio_exti_source_select(GPIO_PORT_SOURCE_GPIOB, GPIO_PIN_SOURCE_5);
	exti_init(EXTI_5, EXTI_INTERRUPT, EXTI_TRIG_BOTH);
	nvic_irq_enable(EXTI5_9_IRQn, 4U, 0U);
	exti_interrupt_flag_clear(EXTI_5);
	exti_interrupt_enable(EXTI_5);	
}

static void _init_aux_timer(void) {
    timer_parameter_struct timer_initpara;
    u32 timer = aux_timer;
    rcu_periph_clock_enable(_rcu_clk(timer));

    timer_deinit(timer);
	memset(&timer_initpara, 0, sizeof(timer_initpara));

    timer_initpara.prescaler        = 0;
    timer_initpara.alignedmode      = TIMER_COUNTER_CENTER_UP;
    timer_initpara.period          = FOC_PWM_period;
    timer_initpara.clockdivision    = TIMER_CKDIV_DIV1;
    timer_initpara.repetitioncounter = 0;

    timer_init(timer,&timer_initpara);

    /* select the master slave mode */
    timer_master_slave_mode_config(timer,TIMER_MASTER_SLAVE_MODE_ENABLE);
    /* timer update event is used as trigger output */
    timer_master_output_trigger_source_select(timer,TIMER_TRI_OUT_SRC_ENABLE);    
}


void pwm_start(void){
	pwm_update_duty(FOC_PWM_Half_Period/2, FOC_PWM_Half_Period/2, FOC_PWM_Half_Period/2, FOC_PWM_Half_Period-5);
	/* wait for a new PWM period to flush last HF task */
	timer_flag_clear(pwm_timer, TIMER_FLAG_UP);
	while ( timer_flag_get(pwm_timer, TIMER_FLAG_UP) == RESET )
	{}
	/* Clear Update Flag */
	timer_flag_clear(pwm_timer, TIMER_FLAG_UP);
	timer_primary_output_config(pwm_timer,ENABLE);
	timer_flag_clear(pwm_timer, TIMER_FLAG_UP);
	timer_interrupt_enable(pwm_timer, TIMER_INT_UP);
}

void pwm_stop(void){
	timer_primary_output_config(pwm_timer,DISABLE);
	timer_interrupt_disable(pwm_timer, TIMER_INT_UP);
	/* wait for a new PWM period to flush last HF task */
	timer_flag_clear(pwm_timer, TIMER_FLAG_UP);
	while ( timer_flag_get(pwm_timer, TIMER_FLAG_UP) == RESET )
	{}
	/* Clear Update Flag */
	timer_flag_clear(pwm_timer, TIMER_FLAG_UP);
}

/*open low side of the mosfet*/
void pwm_turn_on_low_side(void)
{  
	pwm_update_duty(0, 0, 0, FOC_PWM_Half_Period);
	timer_flag_clear(pwm_timer,TIMER_FLAG_UP);
  	while (timer_flag_get(pwm_timer,TIMER_FLAG_UP) == RESET );
  	/* Main PWM Output Enable */
  	pwm_enable_channel(); 
}


__weak void foc_brake_handler(bool brake) {
	//dumy function, must implemented in FOC controller
}

/*do 50 times filter*/
static void brake_timer_handler(timer_t *t) {
	int count = 50;
	int settimes = 0;
	while(count-- >= 0) {
		bool b1 = gpio_input_bit_get(GPIOB, GPIO_PIN_4) == SET;
		bool b2 = gpio_input_bit_get(GPIOB, GPIO_PIN_5) == SET;
		if (b1 && b2) {
			settimes++;
		}		
	}
	if (settimes == 0) {
		foc_brake_handler(true);
	}else if (settimes == 50) {
		foc_brake_handler(false);
	}else {
		//有干扰，do nothing
	}
}

static timer_t _brake_timer = TIMER_INIT(_brake_timer, brake_timer_handler);
void mc_brake_irq(void) {
	timer_post(&_brake_timer, 0);
}