/*********************************************************************************************************
* 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_1_IO_SOURCE_RCU							EXTI_SOURCE_GPIOC
#define    KEY_TEST_1_IO_SOURCE         				EXTI_SOURCE_PIN14
#define    KEY_TEST_1_IO_EXIT      					  	EXTI_14



#define    KEY_TEST_2_IO												GPIO_PIN_2
#define  	 KEY_TEST_2_IO_SOURCE_RCU							EXTI_SOURCE_GPIOB
#define    KEY_TEST_2_IO_SOURCE         			  EXTI_SOURCE_PIN2
#define    KEY_TEST_2_IO_EXIT      					    EXTI_2



#define    KEY_TEST_3_IO												GPIO_PIN_0
#define  	 KEY_TEST_3_IO_SOURCE_RCU							EXTI_SOURCE_GPIOA
#define    KEY_TEST_3_IO_SOURCE         			  EXTI_SOURCE_PIN0
#define    KEY_TEST_3_IO_EXIT      					    EXTI_0




#define    KEY_TEST_4_IO												GPIO_PIN_1
#define  	 KEY_TEST_4_IO_SOURCE_RCU							EXTI_SOURCE_GPIOA
#define    KEY_TEST_4_IO_SOURCE         			  EXTI_SOURCE_PIN1
#define    KEY_TEST_4_IO_EXIT      					    EXTI_1

#define    KEY_TEST_5_IO												GPIO_PIN_12
#define  	 KEY_TEST_5_IO_SOURCE_RCU							EXTI_SOURCE_GPIOA
#define    KEY_TEST_5_IO_SOURCE         			  EXTI_SOURCE_PIN12
#define    KEY_TEST_5_IO_EXIT      					    EXTI_12

#define    KEY_TEST_1_GPIO          GPIOC
#define    KEY_TEST_2_GPIO					GPIOB
#define 	 KEY_TEST_3_4_5_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);


#if SUPPORT_SELF_LOCK

	static void get_test_1();
	static void get_test_2();
	static void get_test_3();
	static void get_test_4();
	static void get_lock_key(void);
	static void self_lock_opt(void);
#endif




void detection_init(void)
{
	
#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);

#elif SUPPORT_SELF_LOCK
	rcu_periph_clock_enable(RCU_CFGCMP);
	rcu_periph_clock_enable(RCU_GPIOC);
	if(!board)
	{
		board = get_board();
	}
#if (RelaySlaveChaNum >= 1)
	gpio_mode_set(KEY_TEST_1_GPIO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST_1_IO);
#endif

#if (RelaySlaveChaNum >= 2)		
	rcu_periph_clock_enable(RCU_GPIOB);
	gpio_mode_set(KEY_TEST_2_GPIO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST_2_IO);
#endif
	
#if (RelaySlaveChaNum >= 3)
	rcu_periph_clock_enable(RCU_GPIOA);
	gpio_mode_set(KEY_TEST_3_4_GPIO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST_3_IO);	
#endif
#if (RelaySlaveChaNum >= 4)
	gpio_mode_set(KEY_TEST_3_4_GPIO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST_4_IO);
#endif
	board->get_lock_key = get_lock_key;
	board->opt_lock_key = self_lock_opt;
	
#elif SUPPORT_KEY_EXIT
	rcu_periph_clock_enable(RCU_CFGCMP);
	rcu_periph_clock_enable(RCU_GPIOC);
	rcu_periph_clock_enable(RCU_GPIOA);
	rcu_periph_clock_enable(RCU_GPIOB);
	if(!board)
	{
		board = get_board();
	}
#if (RelaySlaveChaNum >= 1)
	gpio_mode_set(KEY_TEST_1_GPIO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST_1_IO);
	nvic_irq_enable(EXTI4_15_IRQn,1);
	syscfg_exti_line_config(KEY_TEST_1_IO_SOURCE_RCU,KEY_TEST_1_IO_SOURCE);
	exti_init(KEY_TEST_1_IO_EXIT,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
	exti_interrupt_flag_clear(KEY_TEST_1_IO_EXIT);	
#endif	
	
#if (RelaySlaveChaNum >= 2)
	gpio_mode_set(KEY_TEST_2_GPIO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST_2_IO);
	nvic_irq_enable(EXTI2_3_IRQn,1);
	syscfg_exti_line_config(KEY_TEST_2_IO_SOURCE_RCU,KEY_TEST_2_IO_SOURCE);
	exti_init(KEY_TEST_2_IO_EXIT,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
	exti_interrupt_flag_clear(KEY_TEST_2_IO_EXIT);	
#endif	
	
	
#if (RelaySlaveChaNum >= 3)
	gpio_mode_set(KEY_TEST_3_4_5_GPIO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST_3_IO);
	nvic_irq_enable(EXTI0_1_IRQn,1);
	syscfg_exti_line_config(KEY_TEST_3_IO_SOURCE_RCU,KEY_TEST_3_IO_SOURCE);
	exti_init(KEY_TEST_3_IO_EXIT,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
	exti_interrupt_flag_clear(KEY_TEST_3_IO_EXIT);	
#endif	
	
#if (RelaySlaveChaNum >= 4)
	gpio_mode_set(KEY_TEST_3_4_5_GPIO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST_4_IO);
	nvic_irq_enable(EXTI0_1_IRQn,1);
	syscfg_exti_line_config(KEY_TEST_4_IO_SOURCE_RCU,KEY_TEST_4_IO_SOURCE);
	exti_init(KEY_TEST_4_IO_EXIT,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
	exti_interrupt_flag_clear(KEY_TEST_4_IO_EXIT);	
#endif	
	
#if (RelaySlaveChaNum >= 5)
	gpio_mode_set(KEY_TEST_3_4_5_GPIO, GPIO_MODE_INPUT, GPIO_PUPD_PULLUP, KEY_TEST_5_IO);
	nvic_irq_enable(EXTI4_15_IRQn,1);
	syscfg_exti_line_config(KEY_TEST_5_IO_SOURCE_RCU,KEY_TEST_5_IO_SOURCE);
	exti_init(KEY_TEST_5_IO_EXIT,EXTI_INTERRUPT,EXTI_TRIG_FALLING);
	exti_interrupt_flag_clear(KEY_TEST_5_IO_EXIT);	
#endif	

#endif
	

	
	
	
}


extern uint8_t relay_flag[RelaySlaveChaNum];
extern uint8_t relay_status[RelaySlaveChaNum];
uint8_t relay_counter_flag[RelaySlaveChaNum];




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);
		for(int i = 0;i < 30;i++);
		if(gpio_input_bit_get(KEY_RST_IO,KEY_RST) != 0)
		{
			return;
		}
		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;
#if SUPPORT_CTRL2_LOCK2
							if(j >= AVALIABLE_RELAY)
							{
								continue;
							}
#endif
						da.channel = 	j;
						da.method = DELAY_CTRL;
						da.reg = &board->relay_staging_staus[j];
						da.status = RELAY_CLOSE;
						set_relay_sta_async(&da);									
					}						
			}
		}
	}
#elif SUPPORT_KEY_EXIT

#if (RelaySlaveChaNum >= 1)
	if(RESET != exti_interrupt_flag_get(KEY_TEST_1_IO_EXIT))
	{
		exti_interrupt_flag_clear(KEY_TEST_1_IO_EXIT);
		for(int i = 0;i <30;i++);
		if(gpio_input_bit_get(KEY_TEST_1_GPIO,KEY_TEST_1_IO) == 0)
		{
				async_data da = {0};
				da.fire_or_zero = _FIRE;
				da.method = PROMPT_CTRL;
				da.w_eep_flag = FLAG_W_EEP;
				da.channel = 0;
				da.reg = &board->relay_staging_staus[0];
				da.status = board->md_data.r_data.state.state[0].state ? 0 : 1;
				set_relay_sta_async(&da);	
		}
	}
#endif
	
#if (RelaySlaveChaNum >= 5)
	if(RESET != exti_interrupt_flag_get(KEY_TEST_5_IO_EXIT))
	{
		exti_interrupt_flag_clear(KEY_TEST_5_IO_EXIT);
		for(int i = 0;i <30;i++);
		if(gpio_input_bit_get(KEY_TEST_3_4_5_GPIO,KEY_TEST_5_IO) == 0)
		{
				async_data da = {0};
				da.fire_or_zero = _FIRE;
				da.method = PROMPT_CTRL;
				da.w_eep_flag = FLAG_W_EEP;
				da.channel = 4;
				da.reg = &board->relay_staging_staus[4];
				da.status = board->md_data.r_data.state.state[4].state ? 0 : 1;
				set_relay_sta_async(&da);	
		}
	}
#endif


#endif

	if(RESET != exti_interrupt_flag_get(DERECTION_IO_1_EXIT))
	{
		exti_interrupt_flag_clear(DERECTION_IO_1_EXIT);
		if(board)
		{
			//for(int i = 0;i <20;i++);
			if(gpio_input_bit_get(DERECTION_GPIO_1,DERECTION_IO_1) == 0)
			{
				board->detection_1_value = 1;
				board->detection_1_count = 0;
			}
		}
		
	}

}
#if SUPPORT_KEY_EXIT
void EXTI0_1_IRQHandler(void)
{
#if SUPPORT_DETECTION
		if(board->md_data.r_data.detection & 0x1)	
#endif
		{
#if (RelaySlaveChaNum >= 3)
			if(RESET != exti_interrupt_flag_get(KEY_TEST_3_IO_EXIT))
			{
				exti_interrupt_flag_clear(KEY_TEST_3_IO_EXIT);
				for(int i = 0;i <30;i++);
				if(gpio_input_bit_get(KEY_TEST_3_4_5_GPIO,KEY_TEST_3_IO) == 0)
				{
						async_data da = {0};
						da.fire_or_zero = _FIRE;
						da.method = PROMPT_CTRL;
						da.w_eep_flag = FLAG_W_EEP;
						da.channel = 2;
						da.reg = &board->relay_staging_staus[2];
						da.status = board->md_data.r_data.state.state[2].state ? 0 : 1;
						set_relay_sta_async(&da);			
				}
			}
#endif
	
	
	
#if (RelaySlaveChaNum >= 4)
		if(RESET != exti_interrupt_flag_get(KEY_TEST_4_IO_EXIT))
		{
			exti_interrupt_flag_clear(KEY_TEST_4_IO_EXIT);
			for(int i = 0;i <30;i++);
			if(gpio_input_bit_get(KEY_TEST_3_4_5_GPIO,KEY_TEST_4_IO) == 0)
			{
					async_data da = {0};
					da.fire_or_zero = _FIRE;
					da.method = PROMPT_CTRL;
					da.w_eep_flag = FLAG_W_EEP;
					da.channel = 3;
					da.reg = &board->relay_staging_staus[3];
					da.status = board->md_data.r_data.state.state[3].state ? 0 : 1;
					set_relay_sta_async(&da);			
			}
		}
#endif	
	}
}

#endif


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);
		for(int i = 0;i < 30;i++);
		if(gpio_input_bit_get(KEY_TEST_IO,KEY_TEST) != 0)
		{
			return;
		}
		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;
#if SUPPORT_CTRL2_LOCK2
							if(k >= AVALIABLE_RELAY)
							{
								continue;
							}
#endif
						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			
			
		}
	}
#elif SUPPORT_KEY_EXIT

#if (RelaySlaveChaNum >= 2)
	if(RESET != exti_interrupt_flag_get(KEY_TEST_2_IO_EXIT))
	{
		exti_interrupt_flag_clear(KEY_TEST_2_IO_EXIT);
#if SUPPORT_DETECTION
		if(board->md_data.r_data.detection & 0x1)	
#endif
		{
			for(int i = 0;i <30;i++);
			if(gpio_input_bit_get(KEY_TEST_2_GPIO,KEY_TEST_2_IO) == 0)
			{
					async_data da = {0};
					da.fire_or_zero = _FIRE;
					da.method = PROMPT_CTRL;
					da.w_eep_flag = FLAG_W_EEP;
					da.channel = 1;
					da.reg = &board->relay_staging_staus[1];
					da.status = board->md_data.r_data.state.state[1].state ? 0 : 1;
					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)
		{
			//for(int i = 0;i <20;i++);
			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)
	{
#if SUPPORT_RELAY_REMENBER
				if(board->md_data.r_data.detection & 0x1)
				{
					if(board->handle_input_pt[0] == 0)
					{
						
						for(uint8_t k = 0; k < PT_SUB_COUNT;k++)
						{
#if SUPPORT_SELF_LOCK
							if(board->val_key[k] == 0)
									continue;
#endif
#if SUPPORT_CTRL2_LOCK2
							if(k >= AVALIABLE_RELAY)
							{
								continue;
							}
#endif
							async_data da = {0};
							da.channel =k;
							da.fire_or_zero = _FIRE;
							da.method = DELAY_CTRL;
							da.reg = &board->relay_staging_staus[k];
							da.status = board->handle_status[k];
							da.w_eep_flag = FLAG_N_W_EEP;
							set_relay_sta_async(&da);
						}
						board->handle_input_pt[0] = 1;
					}
				}else
				{
					if(board->handle_input_pt[0] == 1)
					{
						for(uint8_t k = 0; k < PT_SUB_COUNT;k++)
						{
#if SUPPORT_CTRL2_LOCK2
							if(k >= AVALIABLE_RELAY)
							{
								continue;
							}
#endif
							board->handle_status[k] = board->md_data.r_data.state.state[k].state;
							async_data da = {0};
							da.channel =k;
							da.fire_or_zero = _FIRE;
							da.method = PROMPT_CTRL;
							da.reg = &board->relay_staging_staus[k];
							da.status = RELAY_CLOSE;
							da.w_eep_flag = FLAG_N_W_EEP;
							set_relay_sta_async(&da);
						}
						board->handle_input_pt[0] = 0;
					}
				}
	#if SURPPORT_2_PT
				if(board->md_data.r_data.detection & 0x2)
				{
					if(board->handle_input_pt[1] == 0)
					{
						for(uint8_t k = PT_SUB_COUNT; k < RelaySlaveChaNum;k++)
						{
							async_data da = {0};
							da.channel =k;
							da.fire_or_zero = _FIRE;
							da.method = DELAY_CTRL;
							da.reg = &board->relay_staging_staus[k];
							da.status = board->handle_status[k];
							da.w_eep_flag = FLAG_N_W_EEP;
							set_relay_sta_async(&da);
						}
						board->handle_input_pt[1] = 1;
					}
				}else
				{
					if(board->handle_input_pt[1] == 1)
					{
						for(uint8_t k = PT_SUB_COUNT; k < RelaySlaveChaNum;k++)
						{
							board->handle_status[k] = board->md_data.r_data.state.state[k].state;
							async_data da = {0};
							da.channel =k;
							da.fire_or_zero = _FIRE;
							da.method = PROMPT_CTRL;
							da.reg = &board->relay_staging_staus[k];
							da.status = RELAY_CLOSE;
							da.w_eep_flag = FLAG_N_W_EEP;
							set_relay_sta_async(&da);
						}
						board->handle_input_pt[1] = 0;
					}
				}				
	#endif
#endif		
	}
}


#if SUPPORT_SELF_LOCK

static void get_lock_key(void)
{
#if (RelaySlaveChaNum >= 1)
	if(gpio_input_bit_get(KEY_TEST_1_GPIO,KEY_TEST_1_IO) == RESET)
	{
		board->val_key[0] = 1;
	}else
	{
		board->val_key[0] = 0;
	}
#endif
#if (RelaySlaveChaNum >= 2)
	if(gpio_input_bit_get(KEY_TEST_2_GPIO,KEY_TEST_2_IO) == RESET)
	{
		board->val_key[1] = 1;
	}else
	{
		board->val_key[1] = 0;
	}
#endif
	
#if (RelaySlaveChaNum >= 3)
	if(gpio_input_bit_get(KEY_TEST_3_4_GPIO,KEY_TEST_3_IO) == RESET)
	{
		board->val_key[2] = 1;
	}else
	{
		board->val_key[2] = 0;
	}
#endif
	
#if (RelaySlaveChaNum >= 4)
	if(gpio_input_bit_get(KEY_TEST_3_4_GPIO,KEY_TEST_4_IO) == RESET)
	{
		board->val_key[3] = 1;
	}else
	{
		board->val_key[3] = 0;
	}
#endif
}



//#if (RelaySlaveChaNum >= 1)
//static void get_test_1()
//{
//	uint8_t val = 0;
//	if(gpio_input_bit_get(KEY_TEST_1_GPIO,KEY_TEST_1_IO) == RESET)
//	{
//		val = 1;
//	}
//	board->key_1 = val;
//}
//#endif

//#if (RelaySlaveChaNum >= 2)
//static void get_test_2()
//{
//	uint8_t val = 0;
//		if(gpio_input_bit_get(KEY_TEST_2_GPIO,KEY_TEST_2_IO) == RESET)
//		{
//			val = 1;
//		}
//		board->key_2 = val;
//}
//#endif
//#if (RelaySlaveChaNum >= 3)
//static void get_test_3()
//{
//	uint8_t val = 0;
//		if(gpio_input_bit_get(KEY_TEST_3_4_GPIO,KEY_TEST_3_IO) == RESET)
//		{
//			val = 1;
//		}
//		board->key_3 = val;
//}
//#endif
//#if (RelaySlaveChaNum >= 4)
//static void get_test_4()
//{
//	uint8_t val = 0;
//		if(gpio_input_bit_get(KEY_TEST_3_4_GPIO,KEY_TEST_4_IO) == RESET)
//		{
//			val = 1;
//		}
//		board->key_4 = val;
//}
//#endif

static void self_lock_opt(void)
{
#if (RelaySlaveChaNum <= 4)
	async_data da = {0};
	da.fire_or_zero = _FIRE;
	da.method = PROMPT_CTRL;
	da.w_eep_flag = FLAG_W_EEP;
	for(uint8_t i = 0; i < RelaySlaveChaNum;i++)
	{
		da.channel = i;
		da.reg = &board->relay_staging_staus[i];
		if(board->val_key[i] == 0)
		{
			if(board->handle_k_status[i] == 1)
			{
				da.status = RELAY_CLOSE;
				set_relay_sta_async(&da);
				board->handle_k_status[i] = 0;
			}
		}else
		{
			if(board->handle_k_status[i] == 0)
			{
				if(board->md_data.r_data.detection & 0x1)
				{
					da.status = RELAY_OPEN;
					set_relay_sta_async(&da);
				}
				board->handle_k_status[i] = 1;
			}				
		}
	}
#endif
}





//static void self_lock_opt1(void)
//{
//	async_data da = {0};
//	
//	da.fire_or_zero = _FIRE;
//	da.method = PROMPT_CTRL;
//	da.w_eep_flag = FLAG_W_EEP;
//#if (RelaySlaveChaNum >= 1)
//	if(board->key_1 == 0)
//	{
//		da.channel =0;
//		da.reg = &board->relay_staging_staus[0];
//		if(board->handle_k_1_status == 1)
//		{
//			da.status = RELAY_CLOSE;
//			set_relay_sta_async(&da);
//			board->handle_k_1_status = 0;
//		}
//	}else
//	{
//		da.channel =0;
//		da.reg = &board->relay_staging_staus[0];
//		if(board->handle_k_1_status == 0)
//		{
//			da.status = RELAY_OPEN;
//			set_relay_sta_async(&da);		
//			board->handle_k_1_status = 1;			
//		}
//	}
//#endif
//	
//	
//#if (RelaySlaveChaNum >= 2)
//	if(board->key_2 == 0)
//	{
//		da.channel =1;
//		da.reg = &board->relay_staging_staus[1];
//		if(board->handle_k_2_status == 1)
//		{
//			da.status = RELAY_CLOSE;
//			set_relay_sta_async(&da);
//			board->handle_k_2_status = 0;
//		}
//	}else
//	{
//		da.channel =1;
//		da.reg = &board->relay_staging_staus[1];
//		if(board->handle_k_2_status == 0)
//		{
//			da.status = RELAY_OPEN;
//			set_relay_sta_async(&da);		
//			board->handle_k_2_status = 1;			
//		}
//	}
//#endif
//	
//#if (RelaySlaveChaNum >= 3)
//	if(board->key_3 == 0)
//	{
//		da.channel =2;
//		da.reg = &board->relay_staging_staus[2];
//		if(board->handle_k_3_status == 1)
//		{
//			da.status = RELAY_CLOSE;
//			set_relay_sta_async(&da);
//			board->handle_k_3_status = 0;
//		}
//	}else
//	{
//		da.channel =2;
//		da.reg = &board->relay_staging_staus[2];
//		if(board->handle_k_3_status == 0)
//		{
//			da.status = RELAY_OPEN;
//			set_relay_sta_async(&da);		
//			board->handle_k_3_status = 1;			
//		}
//	}
//#endif
//	
//#if (RelaySlaveChaNum >= 4)
//	if(board->key_4 == 0)
//	{
//		da.channel =3;
//		da.reg = &board->relay_staging_staus[3];
//		if(board->handle_k_4_status == 1)
//		{
//			da.status = RELAY_CLOSE;
//			set_relay_sta_async(&da);
//			board->handle_k_4_status = 0;
//		}
//	}else
//	{
//		da.channel =3;
//		da.reg = &board->relay_staging_staus[3];
//		if(board->handle_k_4_status == 0)
//		{
//			da.status = RELAY_OPEN;
//			set_relay_sta_async(&da);		
//			board->handle_k_4_status = 1;			
//		}
//	}
//#endif	
//}

#endif