/** ##########################################################################
**     Filename  : keyboard_adc_mid.c
**     Project   : RGB LED
**     Module    :
**     Processor : Cypress CY8C4125LQE-S433
**     Version   : V1.0
**     Compiler  : PSoC Creator 4.2
**     Date/Time : 2020/02/26
**     Abstract  :
**
**     Contents  :
**
**
**     (c) Copyright dmdz Co.,Ltd
**  --------------------------------------------------------------------------
**               R E V I S I O N   H I S T O R Y
**  --------------------------------------------------------------------------
**  Date       Ver   Author             Description

**  ---------  ----  -----------------  --------------------------------------
** #########################################################################*/

#include "common_memory.h"
#include "key_adc_mid.h"
#include "adc.h"



/*****************************************************************************
* I N C L U D E   F I L E S
*****************************************************************************/

/*****************************************************************************
* D E F I N E S
*****************************************************************************/
static key_adc_mid_s g_key_adc_mid;
/*****************************************************************************
|Prototype		: void key_adc_drive_init(void)
|Called by		: None
|Preconditions		: None
|Input parameters	: None
|Output parameters	: None
|Return value		: None
|Description		: cycle task
*****************************************************************************/
void key_adc_mid_init(void)
{
	key_adc_driver_init();
	common_memory_clear((u8*)&g_key_adc_mid,(u16)sizeof(g_key_adc_mid));
}



/*****************************************************************************
|Prototype		: void key_adc_drive_task(void)
|Called by		: None
|Preconditions		: None
|Input parameters	: None
|Output parameters	: None
|Return value		: None
|Description		: cycle task
*****************************************************************************/
void key_adc_mid_task(void)
{
	u8 i;
	key_adc_result_e l_temp;
	key_adc_driver_task();
	for(i=0;i<KEY_ADC_ID_MAX;i++)
	{
		l_temp = key_adc_mid_get_drv_state(i);
		if( (l_temp == KEY_ADC_RESULT_IDLE) || (l_temp == KEY_ADC_RESULT_FAULT) || (l_temp == KEY_ADC_RESULT_UNKNOW) )
		{
			g_key_adc_mid.key[i].count=0;
			g_key_adc_mid.key[i].state = l_temp;
			if(l_temp == KEY_ADC_RESULT_UNKNOW)		//未弹起过，也认为idle
			{
				g_key_adc_mid.key[i].state = KEY_ADC_RESULT_IDLE;
			}
			#ifdef KEY_ADC_MID_INIT_INVALID
			if(l_temp == KEY_ADC_RESULT_IDLE)
			{
				g_key_adc_mid.key[i].sub_state = KEY_ADC_SUB_STATE_UP;	//表示己经弹起过
			}
			#endif
		}
		else
		{
			/*code*/
			switch(g_key_adc_mid.key[i].state)
			{
				case KEY_ADC_RESULT_IDLE:
				case KEY_ADC_RESULT_UNKNOW:
				case KEY_ADC_RESULT_FAULT:  //认为在异常电平时，也可以判断有效；不做功能安全的话
					/*if(l_temp == KEY_ADC_RESULT_PRESSS)*/
					{
						g_key_adc_mid.key[i].state = KEY_ADC_RESULT_PRESSS;
					}
				break;
				#if 1
				case KEY_ADC_RESULT_PRESSS:
					/*if(l_temp == KEY_ADC_RESULT_PRESSS)*/
					{
						g_key_adc_mid.key[i].count++;
						if(g_key_adc_mid.key[i].count>=g_key_adc_mid_time_cfg[i].long_press)//g_key_cfg_times[KEY_ADC_LONGPRESS_TIME_ID])
						{
							g_key_adc_mid.key[i].state = KEY_ADC_RESULT_LONG;
						}
					}
				break;
				case KEY_ADC_RESULT_LONG:
					/*if(l_temp == KEY_ADC_RESULT_PRESSS)*/
					{
						g_key_adc_mid.key[i].count++;
						if(g_key_adc_mid.key[i].count>=g_key_adc_mid_time_cfg[i].stick_press)	//g_key_cfg_times[KEY_ADC_STICKPRESS_TIME_ID])  /*g_key_adc_mid_time_cfg[i].stick_press*/
						{
							g_key_adc_mid.key[i].state = KEY_ADC_RESULT_STICK;
						}
					}
				break;
				#else
				case KEY_ADC_RESULT_PRESSS:
					/*if(l_temp == KEY_ADC_RESULT_PRESSS)*/
					{
						g_key_adc_mid.key[i].count++;
						if(g_key_adc_mid.key[i].count>=g_key_cfg_times[KEY_TIME_CFG_AD_STUCK_ID])
						{
							g_key_adc_mid.key[i].state = KEY_ADC_RESULT_STICK;
						}
					}
				break;
				#endif
				#if 0
				case KEY_ADC_RESULT_STICK:
					/*if(l_temp == KEY_ADC_RESULT_PRESSS)*/
					{
						if(g_key_adc_mid.key[i].count<0xffffu)
						{
							g_key_adc_mid.key[i].count++;
						}
					}
				break;
				#endif
				default:
					/*code*/
				break;
			}
		}

		if(g_key_adc_mid.key[i].pre_state != g_key_adc_mid.key[i].state)
		{
			if((g_key_adc_mid.key[i].state == KEY_ADC_RESULT_PRESSS))
			{
				g_key_adc_mid.key[i].event |= KEY_ADC_EVENT_PRESSED;
			}
			else if (g_key_adc_mid.key[i].state == KEY_ADC_RESULT_LONG)
			{
				g_key_adc_mid.key[i].event |= KEY_ADC_EVENT_LONG_DOWN;
			}
			else if((g_key_adc_mid.key[i].pre_state == KEY_ADC_RESULT_PRESSS) && (g_key_adc_mid.key[i].state == KEY_ADC_RESULT_IDLE))
			{
				g_key_adc_mid.key[i].event |= KEY_ADC_EVENT_SHORT_DOWN_RELEASE;
			}
			if(g_key_adc_mid.key[i].state == KEY_ADC_RESULT_IDLE)
			{
				g_key_adc_mid.key[i].count=0;
				g_key_adc_mid.key[i].state = KEY_ADC_RESULT_IDLE;
				if((g_key_adc_mid.key[i].pre_state == KEY_ADC_RESULT_LONG) || (g_key_adc_mid.key[i].pre_state == KEY_ADC_RESULT_FAULT))
				{
					g_key_adc_mid.key[i].event = KEY_ADC_EVENT_RELEASE;
				}
				
			}
			if( (g_key_adc_mid.key[i].state == KEY_ADC_RESULT_IDLE) || (g_key_adc_mid.key[i].state == KEY_ADC_RESULT_PRESSS) )
			{
				g_key_adc_mid.key[i].state_change =1u;
			}
		}
		else
		{
			g_key_adc_mid.key[i].state_change =0u;
		}

		g_key_adc_mid.key[i].pre_state  = g_key_adc_mid.key[i].state;

	}
}


void key_adc_mid_quick_task(void)
{
	u8 i;
	#if 0
	for(i=0;i<ADC_KEY_CHANNEL_TOTALS;i++)
	{
		adc_get_value_quick(ADC_CHANNEL_KEY_AD1+i,&g_key_adc_mid.channel[i]);
	}
	#else
		#if 1
		#ifndef RAM_OPTIMIZE_EN
		for(i=0;i<KEY_ADC_CHANNEL_TOTALS;i++)
		{
			g_key_adc_mid.channel[i] = adc_manage_get_voltage(i+ADC0_LOGIC_CHN_NORMAL_KEY_START);  /*PRQA S 2985*/  /*宏暫時為0*/
		}
		#endif
		#else
		for(i=0;i<ADC_KEY_CHANNEL_TOTALS;i++)
		{
			g_key_adc_mid.channel[i] = get_adc_key_org_value(i);
		}
		#endif
	#endif
}


/*****************************************************************************
|Prototype		: void key_adc_mid_get_result(void)
|Called by		: None
|Preconditions		: None
|Input parameters	: channel AD邏輯通道  sub_id 內部的key排序
|Output parameters	: None
|Return value		: None
|Description		:
*****************************************************************************/
key_adc_result_e key_adc_mid_get_result(u8 key_id)
{
	#ifdef KEY_ADC_MID_DEBUG_STATE
	key_adc_result_e l_result=KEY_ADC_RESULT_IDLE;
	l_result = g_key_adc_mid.key[key_id].result;
	#else
	key_adc_result_e l_result=KEY_ADC_RESULT_IDLE;
	if(key_id < KEY_ADC_ID_MAX)
	{
		#ifdef KEY_ADC_MID_INIT_INVALID
		if(g_key_adc_mid.key[key_id].sub_state==KEY_ADC_SUB_STATE_UP)  //弹起过
		{
			l_result = g_key_adc_mid.key[key_id].state;
		}
		else	//未弹起过
		{
			if(g_key_adc_mid.key[key_id].state>=KEY_ADC_RESULT_STICK)  //未弹起过，也要计时卡滞
			{
				l_result = g_key_adc_mid.key[key_id].state;
			}
			else
			{
				l_result = KEY_ADC_RESULT_IDLE;
			}
		}
		#else
		l_result = g_key_adc_mid.key[key_id].state;
		#endif
	}
	#endif
	return l_result;
}

/*****************************************************************************
|Prototype         :
|Called by         :
|Preconditions     : -
|Input parameters  : None  id 是邏輯id
|Output parameters : None
|Return value      : None
|Description       : 回讀按鍵的變化，注意，要馬上處理，下一周期就無變化了,    一般用于按键从无效到有效。或者从有效到无效，且消抖后。
*****************************************************************************/
u8 key_adc_mid_driver_get_change(u8 id)
{
	u8 l_change;
	if(id<KEY_ADC_ID_MAX)
	{
		l_change = g_key_adc_mid.key[id].state_change;
	}
	else
	{
		l_change = 0u;

	}
	return l_change;
}

/*****************************************************************************
|Prototype         :
|Called by         :
|Preconditions     : -
|Input parameters  : None  id 是邏輯id
|Output parameters : None
|Return value      : None
|Description       : 回讀按鍵的變化，注意，要馬上處理，下一周期就無變化了,    一般用于按键从无效到有效。或者从有效到无效，且消抖后。
*****************************************************************************/
u8 key_adc_mid_driver_get_event(u8 id)
{
	u8 l_change;
	if(id<KEY_ADC_ID_MAX)
	{
		l_change = g_key_adc_mid.key[id].event;
	}
	else
	{
		l_change = KEY_ADC_EVENT_NULL;

	}
	g_key_adc_mid.key[id].event = KEY_ADC_EVENT_NULL;
	return l_change;
}

/*****************************************************************************
|Prototype         :
|Called by         :
|Preconditions     : -
|Input parameters  : None  id 是邏輯id
|Output parameters : None
|Return value      : None
|Description       :  轻量级判斷，是否按鍵有變化； 0表示沒有變化，1表示有變化
*****************************************************************************/
key_adc_mid_driver_diff_e key_adc_mid_judge_diff_wakeup(void)
{
	u8 i;
	key_adc_mid_driver_diff_e l_result =KEY_ADC_MID_DIFF_NULL;
	for(i=0u;i<KEY_ADC_ID_MAX;i++)
	{
		if(g_key_adc_mid.key[i].pre_state != g_key_adc_mid.key[i].state)
		{
			l_result=KEY_ADC_MID_DIFF_SURE;
			break;
		}
	}
	return l_result;
}


/*****************************************************************************
|Prototype         :
|Called by         :
|Preconditions     : -
|Input parameters  : None  id 是邏輯id
|Output parameters : None
|Return value      : None
|Description       :  判斷，是否按鍵有真正的，有效按下
*****************************************************************************/
key_adc_mid_driver_diff_e key_adc_mid_judge_state_wakeup(void)
{
	u8 i;
	key_adc_mid_driver_diff_e l_result =KEY_ADC_MID_DIFF_NULL;
	for(i=0u;i<KEY_ADC_ID_MAX;i++)
	{
		if( (g_key_adc_mid.key[i].state >= KEY_ADC_RESULT_PRESSS)  && (g_key_adc_mid.key[i].state <= KEY_ADC_RESULT_STICK) )
		{
			l_result=KEY_ADC_MID_DIFF_SURE;
			break;
		}
	}
	return l_result;
}


/*****************************************************************************
|Prototype         :
|Called by         :
|Preconditions     : -
|Input parameters  : None  id 是邏輯id
|Output parameters : None
|Return value      : None
|Description       : 进入sleep前，要做的事情;---把数据
*****************************************************************************/
void key_adc_mid_goto_sleep(void)
{
	u8 i;
	key_adc_goto_sleep();
	//再次记录 上次值和当前值，保持一致
	for(i=0u;i<KEY_ADC_ID_MAX;i++)
	{
		g_key_adc_mid.key[i].count = 0x0u;
		g_key_adc_mid.key[i].state_change = 0x0u;
		g_key_adc_mid.key[i].state = KEY_ADC_RESULT_IDLE;
		g_key_adc_mid.key[i].pre_state = g_key_adc_mid.key[i].state ;
	}
}

/*****************************************************************************
|Prototype         :
|Called by         :
|Preconditions     : -
|Input parameters  : None  id 是邏輯id
|Output parameters : None
|Return value      : None
|Description       : 进入sleep前，要做的事情;---把数据
*****************************************************************************/
void key_adc_mid_goto_wakeup(void)
{

}




#if 0
/*****************************************************************************
|Prototype		: void key_adc_judge_valid(void)
|Called by		: None
|Preconditions		: None
|Input parameters	:
|Output parameters	: None
|Return value		: None
|Description		:   判斷是否有按鍵按下
*****************************************************************************/
/* software detailed  design ID ： SWDD120213 */
u8 key_adc_judge_valid(void)
{
	u8 l_result = 0u;
	u8 i;

	#if 1
	for(i=0;i<KEY_ADC_ID_MAX;i++)
	{
		if(g_key_adc_mid.key[i].state != KEY_ADC_RESULT_IDLE)
		{
			l_result =1;
			break;
		}
	}
	#else
	for(i=0;i<ADC_KEY_CHANNEL_TOTALS;i++)
	{
		if(g_key_adc_mid.channel[i]  <= ADC_ORIGINAL_NO_KEY_MIN )  /*ADC_ORIGINAL_NO_KEY_MIN*/
		{
			l_result =1;
			break;
		}
	}
	#endif

	return l_result;
}


/*****************************************************************************
|Prototype		: void key_adc_judge_wake(void)
|Called by		: None
|Preconditions		: None
|Input parameters	:
|Output parameters	: None
|Return value		: None
|Description		:   判斷通道是否有按下
*****************************************************************************/
/* software detailed  design ID ： SWDD120214 */
u8 key_adc_judge_wake(void)
{
	u8 l_result = 0u;
	u8 i;
	/*adc_result_t l_adc;*/
	/*l_result=0;*/
	#if 0
	for(i=0;i<KEY_ADC_ID_MAX;i++)
	{
		if(g_key_adc_mid.key[i].state != KEY_ADC_RESULT_IDLE)
		{
			l_result =1;
			break;
		}
	}
	#else
	for(i=0;i<ADC_KEY_CHANNEL_TOTALS;i++)
	{
		if(g_key_adc_mid.channel[i]  <= ADC_ORIGINAL_NO_KEY_ORG_MAX )  /*ADC_ORIGINAL_NO_KEY_MIN*/
		{
			l_result =1;
			break;
		}
	}
	#endif
	/*l_result =0;*/
	return l_result;
}




/*****************************************************************************
|Prototype		: void key_adc_judge_pre_wake(void)
|Called by		: None
|Preconditions		: None
|Input parameters	:
|Output parameters	: None
|Return value		: None
|Description		:
*****************************************************************************/
u8 key_adc_judge_pre_wake(void)  /*PRQA S 1503*/
{
	u8 l_result = 0u;

	#ifdef TEST_PIN_WAKEUP

	#endif
	#if 0
	adc_get_value_quick(ADC_CHANNEL_KEY_AD1,&l_adc);
	if( (l_adc <= ADC_ORIGINAL_NO_KEY_ORG_MAX) && (l_adc >= ADC_ORIGINAL_NO_KEY_ORG_MIN) )

	{
		l_result =1;
	}
	#else
	l_result =1;
	#endif

	return l_result;
}


void key_adc_clear_result(void)
{
	u8 i;
	#if 0
	for(i=0;i<KEY_ADC_ID_MAX;i++)
	{
		g_key_adc_mid.key[i].state = KEY_ADC_RESULT_IDLE;

	}
	#endif
	for(i=0;i<ADC_KEY_CHANNEL_TOTALS;i++)
	{
		g_key_adc_mid.channel[i] = ADC_ORIGINAL_NO_KEY_ORG_INIT;

	}
}

#if 0
/*****************************************************************************
|Prototype		: void key_adc_mid_get_org_adc(void)
|Called by		: None
|Preconditions		: None
|Input parameters	: channel AD邏輯通道  sub_id 內部的key排序
|Output parameters	: None
|Return value		: None
|Description		:
*****************************************************************************/
u16 key_adc_mid_get_org_adc(u8 key_id)
{
	u16 l_result=0;
	if(key_id < ADC_KEY_CHANNEL_TOTALS)
	{
		l_result = g_key_adc_mid.channel[key_id];
	}
	return l_result;
}
#endif
#endif

/* [] END OF FILE */
