SmartPDCode/truing_control/PDU-3-ADA/hardware/detection/detection.c

/*********************************************************************************************************
* Module   : detection
* Abstract : 
* Version  : 1.0.0
* Author   : Leopul(COPYRIGHT 2025 ~ 2027 Leopul. All rights reserved.)
* Complete : 2025-04-08
* Content  : None
* Note     : None
*********************************************************************************************************/

#include "detection.h"
#include "gd32e23x.h"
#include "common.h"
#include "board_cfg.h"
#include "relay.h"





#define DERECTION_GPIO_1   										GPIOA
#define DERECTION_IO_1 												GPIO_PIN_11
#define DERECTION_IO_1_RCU										EXTI_SOURCE_GPIOA
#define DERECTION_IO_1_PIN     								DERECTION_IO_11
#define DERECTION_IO_1_SOURCE         				EXTI_SOURCE_PIN11
#define DERECTION_IO_1_EXIT      							EXTI_11


#if (SURPPORT_2_PT)
		#define DERECTION_GPIO_2   		GPIOB
		#define DERECTION_IO_2 			GPIO_PIN_3

		#define DERECTION_IO_2_RCU										EXTI_SOURCE_GPIOB
		#define DERECTION_IO_2_PIN     								DERECTION_IO_3
		#define DERECTION_IO_2_SOURCE         				EXTI_SOURCE_PIN3
		#define DERECTION_IO_2_EXIT      							EXTI_3		

#endif

#define    KEY_TEST_1_IO            GPIO_PIN_14
#define    KEY_TEST_2_IO						GPIO_PIN_2
#define    KEY_TEST_3_IO						GPIO_PIN_0
#define    KEY_TEST_4_IO						GPIO_PIN_1


#define    KEY_TEST_1_GPIO          GPIOC
#define    KEY_TEST_2_GPIO					GPIOB
#define 	 KEY_TEST_3_4_GPIO        GPIOA




static board_t *board = 0;



#define KEY_RST_RCU     		RCU_GPIOC
#define KEY_RST_IO          GPIOC
#define KEY_RST             GPIO_PIN_14

#define KEY_RST_EXTI_SOURCE      			EXTI_SOURCE_GPIOC
#define KEY_RST_EXTI                  EXTI_14
#define KEY_RST_EXTI_IO               EXTI_SOURCE_PIN14


#define KEY_TEST_RCU     			RCU_GPIOB
#define KEY_TEST_IO          	GPIOB
#define KEY_TEST             	GPIO_PIN_2

#define KEY_TEST_EXTI_SOURCE      		 EXTI_SOURCE_GPIOB
#define KEY_TEST_EXTI                  EXTI_2
#define KEY_TEST_EXTI_IO               EXTI_SOURCE_PIN2



static void get_detection(void);
static void detection_opt(void);






void detection_init(void)
{
board = get_board();
#if SUPPORT_DETECTION
	
	board = get_board();
	rcu_periph_clock_enable(RCU_CFGCMP);
	rcu_periph_clock_enable(RCU_GPIOA);
	#if SURPPORT_2_PT
		rcu_periph_clock_enable(RCU_GPIOB);
	#endif
	gpio_mode_set(DERECTION_GPIO_1, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, DERECTION_IO_1);
	#if SURPPORT_2_PT
		gpio_mode_set(DERECTION_GPIO_2, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, DERECTION_IO_2);
	#endif
	nvic_irq_enable(EXTI4_15_IRQn,2);
	syscfg_exti_line_config(DERECTION_IO_1_RCU,DERECTION_IO_1_SOURCE);
	exti_init(DERECTION_IO_1_EXIT,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
	exti_interrupt_flag_clear(DERECTION_IO_1_EXIT);	

	#if SURPPORT_2_PT
		nvic_irq_enable(EXTI2_3_IRQn,2);
		syscfg_exti_line_config(DERECTION_IO_2_RCU,DERECTION_IO_2_SOURCE);
		exti_init(DERECTION_IO_2_EXIT,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
		exti_interrupt_flag_clear(DERECTION_IO_2_EXIT);
	#endif	
	board->detection = get_detection;
	board->opt_detection = detection_opt;
#endif
}
void key_init(void)
{

#if SUPPORT_ALL_ON_OFF
	rcu_periph_clock_enable(RCU_CFGCMP);
	rcu_periph_clock_enable(KEY_RST_RCU);
	gpio_mode_set(KEY_RST_IO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_RST);
	nvic_irq_enable(EXTI4_15_IRQn,2);
	syscfg_exti_line_config(KEY_RST_EXTI_SOURCE,KEY_RST_EXTI_IO);
	exti_init(KEY_RST_EXTI,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
	exti_interrupt_flag_clear(KEY_RST_EXTI);
	
	rcu_periph_clock_enable(KEY_TEST_RCU);
	gpio_mode_set(KEY_TEST_IO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST);
	nvic_irq_enable(EXTI2_3_IRQn,2);
	syscfg_exti_line_config(KEY_TEST_EXTI_SOURCE,KEY_TEST_EXTI_IO);
	exti_init(KEY_TEST_EXTI,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
	exti_interrupt_flag_clear(KEY_TEST_EXTI);

#endif
	
}



void EXTI4_15_IRQHandler(void){
#if SUPPORT_ALL_ON_OFF
	if(RESET != exti_interrupt_flag_get(KEY_RST_EXTI))
	{
		exti_interrupt_flag_clear(KEY_RST_EXTI);
		if(board)
		{
			if(gpio_input_bit_get(KEY_TEST_IO,KEY_TEST) != 0)
			{
					async_data da = {0};
					da.fire_or_zero = _FIRE;
					da.w_eep_flag = FLAG_W_EEP;
					for(uint8_t j = 0; j < PT_SUB_COUNT;j++)
					{
//						if(board->md_data.r_data.state.state[j].state == RELAY_CLOSE)
//							continue;
						da.channel = 	j;
						da.method = DELAY_CTRL;
						da.reg = &board->relay_staging_staus[j];
						da.status = RELAY_CLOSE;
						set_relay_sta_async(&da);									
					}						
			}
		}
	}
#endif

	if(RESET != exti_interrupt_flag_get(DERECTION_IO_1_EXIT))
	{
		exti_interrupt_flag_clear(DERECTION_IO_1_EXIT);
		if(board)
		{
			if(gpio_input_bit_get(DERECTION_GPIO_1,DERECTION_IO_1) == 0)
			{
				board->detection_1_value = 1;
				board->detection_1_count = 0;
			}
		}
	}

}


void EXTI2_3_IRQHandler(void)
{
#if SUPPORT_ALL_ON_OFF
	if(RESET != exti_interrupt_flag_get(KEY_TEST_EXTI))
	{
		exti_interrupt_flag_clear(KEY_TEST_EXTI);
		if(board)
		{
			if(gpio_input_bit_get(KEY_RST_IO,KEY_RST) != 0)
			{
#if SUPPORT_DETECTION
				if(board->md_data.r_data.detection & 0x1)	
#endif
				{		
					async_data da = {0};
					da.fire_or_zero = _FIRE;
					da.method = DELAY_CTRL;
					da.w_eep_flag = FLAG_W_EEP;
					for(uint8_t k = 0; k < PT_SUB_COUNT;k++)
					{
//						if(board->md_data.r_data.state.state[k].state ==RELAY_OPEN)
//							continue;
						da.channel =k;
						da.reg = &board->relay_staging_staus[k];
						da.status = RELAY_OPEN;
						set_relay_sta_async(&da);
					}		
				}
			}
#if  SURPPORT_2_PT
			
	#if SUPPORT_DETECTION
				if(board->md_data.r_data.detection & 0x2)	
	#endif
				{		
					async_data da = {0};
					da.fire_or_zero = _FIRE;
					da.method = DELAY_CTRL;
					da.w_eep_flag = FLAG_W_EEP;
					for(uint8_t k = PT_SUB_COUNT; k < RelaySlaveChaNum;k++)
					{
						if(board->md_data.r_data.state.state[k].state ==RELAY_OPEN)
							continue;
						da.channel =k;
						da.reg = &board->relay_staging_staus[k];
						da.status = RELAY_OPEN;
						set_relay_sta_async(&da);
					}		
				}
#endif			
			
		}
	}
#endif	
#if SURPPORT_2_PT
	if(RESET != exti_interrupt_flag_get(DERECTION_IO_2_EXIT))
	{
		exti_interrupt_flag_clear(DERECTION_IO_2_EXIT);
		if(board)
		{
			if(gpio_input_bit_get(DERECTION_GPIO_2,DERECTION_IO_2) == 0)
			{
				board->detection_2_value = 1;
				board->detection_2_count = 0;
			}
		}

	}	
#endif
}

static void get_detection()
{
#if SUPPORT_DETECTION
	if(board)
	{
		uint16_t data = 0;
		if(board->detection_1_value > 0)
		{
			data  |= (1 << 0);
		}
#if SURPPORT_2_PT
		if(board->detection_2_value > 0)
		{
			data  |= (1 << 1);
		}		
#endif
		board->md_data.r_data.detection = data;
	}
#endif
}
static void detection_opt(void)
{
	if(board)
	{
				async_data da = {0};
				da.w_eep_flag = FLAG_N_W_EEP;
				da.fire_or_zero = _FIRE;
#if (AC_3_3 || AC_3_4 || AC_3_3_MON)
	#if SUPPORT_RELAY_REMENBER
					if(board->md_data.r_data.detection & 0x1)
					{
						if(board->handle_input_pt[0] == 0)
						{
							board->handle_input_pt[0] = 1;
							for(uint8_t k = 0; k < PT_SUB_COUNT;k++)
							{
								
								da.channel =k;
								da.method = DELAY_CTRL;
								da.reg = &board->relay_staging_staus[k];
								da.status = board->handle_status[k];
								set_relay_sta_async(&da);
							}
#if SUPPORT_ZERO_CRTL
							da.method = DELAY_CTRL;
							da.reg = &board->relay_zero_staging_status;
							da.status = board->handle_status_N;
							set_relay_sta_async(&da);
#endif
						}
					}else
					{
						if(board->handle_input_pt[0] == 1)
						{
							for(uint8_t k = 0; k < PT_SUB_COUNT;k++)
							{
								board->handle_status[k] = board->md_data.r_data.status[k];
								da.channel =k;
								da.method = PROMPT_CTRL;
								da.reg = &board->relay_staging_staus[k];
								da.status = RELAY_CLOSE;
								set_relay_sta_async(&da);
							}
#if SUPPORT_ZERO_CRTL
							board->handle_status_N = board->md_data.r_data.N_status;
							da.method = PROMPT_CTRL;
							da.reg = &board->relay_zero_staging_status;
							da.status = RELAY_CLOSE;
							set_relay_sta_async(&da);
#endif
							board->handle_input_pt[0] = 0;
						}
					}
	#endif
#else
	#if SUPPORT_RELAY_REMENBER
		uint8_t sync_buff[PT_SUB_COUNT] = {0};
		if(board->md_data.r_data.detection != 0x3)
		{
			if((board->md_data.r_data.detection & 0x1) == 0)
			{
				if(board->handle_input_pt[0] == 1)
				{
					da.method = PROMPT_CTRL;
					da.status = RELAY_CLOSE;
					for(int i= 0; i < PT_SUB_COUNT;i++)
					{
						if(board->md_data.rw_data.channel_ctrl[i] == 0 && board->md_data.rw_data.channel_ctrl[i + PT_SUB_COUNT] == 0)
						{
							board->handle_status[i] = board->md_data.r_data.status[i];
							board->handle_status[i + PT_SUB_COUNT] = board->md_data.r_data.status[i + PT_SUB_COUNT];
				
							da.channel =i;
							da.reg = &board->relay_staging_staus[i];							
							set_relay_sta_async(&da);
					
							da.channel = i + PT_SUB_COUNT;
							da.reg = &board->relay_staging_staus[i + PT_SUB_COUNT];
							set_relay_sta_async(&da);
							sync_buff[i] = 1;
						}else
						{
							if(board->md_data.rw_data.channel_ctrl[i] == 0)
							{
								board->handle_status[i] = board->md_data.r_data.status[i];
								da.channel =i;
								da.reg = &board->relay_staging_staus[i];
								set_relay_sta_async(&da);
							}
						}
					}
				}
				board->handle_input_pt[0]  = 0;
			}
			
			if((board->md_data.r_data.detection & 0x2) == 0)
			{
				if(board->handle_input_pt[1] == 1)
				{
					da.method = PROMPT_CTRL;
					da.status = RELAY_CLOSE;
					for(int i= 0; i < PT_SUB_COUNT;i++)
					{
						if(board->md_data.rw_data.channel_ctrl[i] == 0 && board->md_data.rw_data.channel_ctrl[i + PT_SUB_COUNT] == 0)
						{
							if(!sync_buff[i])
							{
								board->handle_status[i] = board->md_data.r_data.status[i];
								board->handle_status[i + PT_SUB_COUNT] = board->md_data.r_data.status[i + PT_SUB_COUNT];
				
								da.channel =i;
								da.reg = &board->relay_staging_staus[i];							
								set_relay_sta_async(&da);
					
								da.channel = i + PT_SUB_COUNT;
								da.reg = &board->relay_staging_staus[i + PT_SUB_COUNT];
								set_relay_sta_async(&da);								
							}
						}else
						{
							if(board->md_data.rw_data.channel_ctrl[i + PT_SUB_COUNT] == 0)
							{
								board->handle_status[i + PT_SUB_COUNT] = board->md_data.r_data.status[i + PT_SUB_COUNT];
								da.channel =i + PT_SUB_COUNT;
								da.reg = &board->relay_staging_staus[i + PT_SUB_COUNT];
								set_relay_sta_async(&da);								
							}
						}
					}
					board->handle_input_pt[1] = 0;
				}
			}
		}else
		{
			if(board->handle_input_pt[0] == 0)
			{
				board->handle_input_pt[0] = 1;
				for(int i= 0; i < PT_SUB_COUNT;i++)
				{
					da.status = 	board->handle_status[i];
					da.method = DELAY_CTRL;
					if(board->md_data.rw_data.channel_ctrl[i] == 0 && board->md_data.rw_data.channel_ctrl[i + PT_SUB_COUNT] == 0)
					{
						if(!sync_buff[i])
						{
							da.channel =i;
							da.reg = &board->relay_staging_staus[i];							
							set_relay_sta_async(&da);
							
							da.status = 	board->handle_status[i + PT_SUB_COUNT];
							da.channel = i + PT_SUB_COUNT;
							da.reg = &board->relay_staging_staus[i + PT_SUB_COUNT];
							set_relay_sta_async(&da);			
						}
					}else
					{
							if(board->md_data.rw_data.channel_ctrl[i] == 0)
							{
								da.channel =i;
								da.reg = &board->relay_staging_staus[i];
								set_relay_sta_async(&da);
							}						
					}
				}
			}
			
			if(board->handle_input_pt[1] == 0)
			{
				board->handle_input_pt[1] = 1;
				for(int i= 0; i < PT_SUB_COUNT;i++)
				{
					da.status = 	board->handle_status[i];
					da.method = DELAY_CTRL;
					if(board->md_data.rw_data.channel_ctrl[i] == 0 && board->md_data.rw_data.channel_ctrl[i + PT_SUB_COUNT] == 0)
					{
							da.channel =i;
							da.reg = &board->relay_staging_staus[i];							
							set_relay_sta_async(&da);
					
							da.status = 	board->handle_status[i + PT_SUB_COUNT];
							da.channel = i + PT_SUB_COUNT;
							da.reg = &board->relay_staging_staus[i + PT_SUB_COUNT];
							set_relay_sta_async(&da);
							sync_buff[i] = 1;					
					}else
					{
							if(board->md_data.rw_data.channel_ctrl[i + PT_SUB_COUNT] == 0)
							{
								da.status = 	board->handle_status[i + PT_SUB_COUNT];
								da.channel =i + PT_SUB_COUNT;
								da.reg = &board->relay_staging_staus[i + PT_SUB_COUNT];
								set_relay_sta_async(&da);
							}						
					}
				}
			}			
		}
	#endif
#endif		
	}
}