#include "key.h"
#include "timer.h"
#include "usart.h"
#include "pro_phy.h"
#include "pro_memory.h"
#include "esp8266.h"
#include "connect.h"
#include "led.h"
#include "bsp.h"

key_obj Key;
static u8 led_flag=0,learn_flag=0;

//初始化KEY1-->GPIOA.5  上拉输入
void KEY_Init(void) //IO初始化
{ 
 	GPIO_InitTypeDef GPIO_InitStructure;
	
 	RCC_APB2PeriphClockCmd(RCC_KEY,ENABLE);//使能时钟
	RCC_APB2PeriphClockCmd(RCC_KEY_A,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_KEY_B,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_KEY_C,ENABLE);
	RCC_APB2PeriphClockCmd(RCC_KEY_D,ENABLE);

	GPIO_InitStructure.GPIO_Pin  = PIN_KEY;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;//设置成上拉输入
 	GPIO_Init(PORT_KEY, &GPIO_InitStructure);//初始化

	GPIO_InitStructure.GPIO_Pin  = PIN_KEY_A;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;//设置成下拉输入
 	GPIO_Init(PORT_KEY_A, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin  = PIN_KEY_B;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
 	GPIO_Init(PORT_KEY_B, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin  = PIN_KEY_C;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
 	GPIO_Init(PORT_KEY_C, &GPIO_InitStructure);

	GPIO_InitStructure.GPIO_Pin  = PIN_KEY_D;
	GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD;
 	GPIO_Init(PORT_KEY_D, &GPIO_InitStructure);

	MemSet((BYTE *)&Key,0,sizeof(key_obj));
}

//void Key_Flag(u8 flag_x,u32 time_x,u32 scan_time)
//{
//	if(!flag_x)//Key键,松开状态下,检测到按下
//	{
//		flag_x=1;
//		time_x=scan_time;//记录当前时间
//	}
//}

//void Key_IsFlag(u8 flag_x,u32 time_x,u32 scan_time)
//{
//	if(flag_x)
//	{
//		if(!led_flag)
//		{
//			if(scan_time - time_x > LEARN_TIME)//大于3秒
//			{
//				led_flag=1;
//				SetLed(0xff,18,18);
//				printf("\r\nkey time > 3000ms\r\n");
//			}
//		}
//	}
//}

//void Key_Handle(u8 flag_x,u8 addr_x,u8 learn_x,u32 time_x,u32 interval_time_x,u32 scan_time)
//{
//	if(flag_x)//按下状态下,检测到松开
//	{
//		flag_x=0;//清除按下标记
//		led_flag=0;
//		printf("\r\nkey time %d ms\r\n",(scan_time-Key.time_x)*10);
//		if(scan_time - time_x > CLEAR_TIME)//大于8秒,清除地址
//		{
//			addr_x = 0;//地址清零
//			NRF_WriteDataToStore(PRO_STORE_FLAG,PRO_STORE_FLASH_ADDRESS,(u8 *)&Store_Data,sizeof(Store_obj));//数据写入FLASH
//			esp8266.state=LINK;
//			SetLed(0xff,10,500);
//		}
//		else if(scan_time - time_x > LEARN_TIME)//大于3秒,进入学习模式
//		{
//			learn_x=1;//学习模式标记
//			learn_flag=1;
//			time_x=scan_time;//记录时间
//			SetLed(0xff,30,30);
//		}
//		else if(scan_time - time_x > FILTER_TIME && scan_time - time_x < LEARN_TIME)//大于50豪秒,小于3秒,NRF发送数据包
//		{
//			if(Store_Data.addr_a>=30&&Store_Data.addr_a<0xFF&&!learn_x)//不是学习模式和地址合法
//			{
//				if(scan_time - interval_time_x > NEXT_WAIT_INTERVAL)//下次间隔800毫秒
//				{
//					u8 sid,nid;
//					
//					sid=Store_Data.addr_a/10;//计算sid
//					nid=Get_Nid(addr_x);
//					interval_time_x=scan_time;//记录时间
//					NRF_SendData(addr_x,WAY_KEY_DATA,(u8 *)"",nid,sid,0,NRF_SendCallBack);//NRF发送数据包
//				}
//			}
//			if(learn_x)//学习模式
//			{
//				learn_x=0;
//			}
//			esp8266.state=LINK;
//			SetLed(0xff,10,500);
//		}
//	}
//}

void Key_Scan(void)
{
	/*
	*按键功能：
	*时间大于3秒,esp8266设置为服务器模式
	*时间小于3秒,如果esp8266是服务器模式,关闭服务器
	*/
	u32 scan_time=Get_RunTime();
	
//	if(KEY_A)//A键按下
//	{
//		Key_Flag(Key.flag_a,Key.time_a,scan_time);
//	}	
//	Key_IsFlag(Key.flag_a,Key.time_a,scan_time);
//	if(!KEY_A)//A键松开时的处理
//	{
//		Key_Handle(Key.flag_a,Store_Data.addr_a,Key.learn_a,Key.time_a,Key.interval_time_a,scan_time);
//	}
//	
//	if(KEY_B)//B键按下
//	{
//		Key_Flag(Key.flag_b,Key.time_b,scan_time);
//	}	
//	Key_IsFlag(Key.flag_b,Key.time_b,scan_time);
//	if(!KEY_B)//B键松开时的处理
//	{
//		Key_Handle(Key.flag_b,Store_Data.addr_b,Key.learn_b,Key.time_b,Key.interval_time_b,scan_time);
//	}
//	
//	if(KEY_C)//C键按下
//	{
//		Key_Flag(Key.flag_c,Key.time_c,scan_time);
//	}	
//	Key_IsFlag(Key.flag_c,Key.time_c,scan_time);
//	if(!KEY_C)//C键松开时的处理
//	{
//		Key_Handle(Key.flag_c,Store_Data.addr_c,Key.learn_c,Key.time_c,Key.interval_time_c,scan_time);
//	}
//	
//	if(KEY_D)//D键按下
//	{
//		Key_Flag(Key.flag_d,Key.time_d,scan_time);
//	}	
//	Key_IsFlag(Key.flag_d,Key.time_d,scan_time);
//	if(!KEY_D)//D键松开时的处理
//	{
//		Key_Handle(Key.flag_d,Store_Data.addr_d,Key.learn_d,Key.time_d,Key.interval_time_d,scan_time);
//	}
	
	if(!KEY0)//Key键按下Key
	{
		if(!Key.flag_x)//Key键,松开状态下,检测到按下
		{
			Key.flag_x=1;
			Key.time_x=scan_time;//记录当前时间
		}
	}	
	if(Key.flag_x)
	{
		if(!led_flag)
		{
			if(scan_time - Key.time_x > LEARN_TIME)//大于3秒
			{
				led_flag=1;
				SetLed(0xff,80,20);
				printf("\r\nkey time > 3000ms\r\n");
			}
		}
	}
	if(KEY0)//Key键松开时的处理
	{
		if(Key.flag_x)//Key键,按下状态下,检测到松开
		{
			Key.flag_x=0;
			led_flag=0;
			SetLed(2,10,10);
			printf("\r\nkey time %d ms\r\n",(scan_time-Key.time_x)*10);
			if(scan_time - Key.time_x > LEARN_TIME)//大于3秒
			{
				if(esp8266.mode==ESP_CLIENT)
				{
					if(ESP_StartServer(esp8266.port))
					{
						esp8266.login=FALSE;
						esp8266.link=FALSE;
						esp8266.bind=FALSE;
						esp8266.mode=ESP_SERVER;
						esp8266.state=SERVER;
						esp8266.ser_time=scan_time;
						SetLed(0xff,100,100);
					}
				}
				else
				{
					esp8266.ser_time=scan_time;
				}
					
			}
			else if(scan_time - Key.time_x > FILTER_TIME && scan_time - Key.time_x < LEARN_TIME)
			{
				if(esp8266.mode==ESP_SERVER)
				{
					if(ESP_CloseServer())
					{
						esp8266.mode=ESP_CLIENT;
						if(!esp8266.login)
							esp8266.state=WAIT_LOGIN;
						else if(!esp8266.link||!esp8266.bind)
							esp8266.state=LINK;
						else
						{
							esp8266.state=LIVE;
							SetLed(0xff,10,500);
						}
					}
					else
					{
						ESP_HardReset();
						esp8266.state=WAIT_LOGIN;
					}
				}
				else
				{
					esp8266.state=LINK;
				}
			}
		}
	}
	
	if(KEY_A)//A键按下
	{
		if(!Key.flag_a)//松开状态下,检测到按下
		{
			Key.flag_a=1;//按下标记
			Key.time_a=scan_time;//记录当前时间
		}
	}	
	if(Key.flag_a)
	{
		if(!led_flag)
		{
			if(scan_time - Key.time_a > LEARN_TIME)//大于3秒
			{
				led_flag=1;
				SetLed(0xff,18,18);
				printf("\r\nkey time > 3000ms\r\n");
			}
		}
	}
	if(!KEY_A)//A键松开时的处理
	{
		if(Key.flag_a)//按下状态下,检测到松开
		{
			Key.flag_a=0;//清除按下标记
			led_flag = 0;
			SetLed(2,10,10);
			if(scan_time - Key.time_a > CLEAR_TIME)//大于8秒,清除地址
			{
				Store_Data.addr_a = 0;//地址清零
				NRF_WriteDataToStore(PRO_STORE_FLAG,PRO_STORE_FLASH_ADDRESS,(u8 *)&Store_Data,sizeof(Store_obj));//数据写入FLASH
				if(esp8266.state==LIVE) esp8266.state=LINK;//为设LED状态
			}
			else if(scan_time - Key.time_a > LEARN_TIME)//大于3秒,进入学习模式
			{
				Key.time_a=scan_time;//记录时间
				Key.learn_a=1;//学习模式标记,4选1
				Key.learn_d=0;
				Key.learn_b=0;
				Key.learn_c=0;
				learn_flag=1;
				SetLed(0xff,30,30);
			}
			else if(scan_time - Key.time_a > FILTER_TIME && scan_time - Key.time_a < LEARN_TIME)//大于50豪秒,小于3秒,NRF发送数据包
			{
				if(Store_Data.addr_a>=30&&Store_Data.addr_a<0xFF&&!Key.learn_a)//不是学习模式和地址合法
				{
					if(scan_time - Key.interval_time_a > NEXT_WAIT_INTERVAL)//下次间隔800毫秒
					{
						Key.interval_time_a=scan_time;//记录时间
						NRF_SendData(Store_Data.addr_a,WAY_KEY_DATA,(u8 *)"",NRF_SendCallBack);//NRF发送数据包
					}
				}
				if(Key.learn_a)//学习模式
				{
					Key.learn_a=0;
				}
				if(esp8266.state==LIVE) esp8266.state=LINK;
			}
		}
	}
	if(KEY_B)//B键按下
	{
		if(!Key.flag_b)//松开状态下,检测到按下
		{
			Key.flag_b=1;
			Key.time_b=scan_time;//记录当前时间
		}
	}	
	if(Key.flag_b)
	{
		if(!led_flag)
		{
			if(scan_time - Key.time_b > LEARN_TIME)//大于3秒
			{
				led_flag=1;
				SetLed(0xff,18,18);
				printf("\r\nkey time > 3000ms\r\n");
			}
		}
	}
	if(!KEY_B)//B键松开时的处理
	{
		if(Key.flag_b)//按下状态下,检测到松开
		{
			Key.flag_b=0;
			led_flag = 0;
			SetLed(2,10,10);
			if(scan_time - Key.time_b > CLEAR_TIME)//大于8秒,清除地址
			{
				Store_Data.addr_b = 0;
				NRF_WriteDataToStore(PRO_STORE_FLAG,PRO_STORE_FLASH_ADDRESS,(u8 *)&Store_Data,sizeof(Store_obj));
				if(esp8266.state==LIVE) esp8266.state=LINK;
			}
			else if(scan_time - Key.time_b > LEARN_TIME)//大于3秒,进入学习模式
			{
				Key.time_b=scan_time;
				Key.learn_b=1;
				Key.learn_a=0;
				Key.learn_d=0;
				Key.learn_c=0;
				learn_flag=1;
				SetLed(0xff,30,30);
			}
			else if(scan_time - Key.time_b > FILTER_TIME && scan_time - Key.time_b < LEARN_TIME)
			{
				if(Store_Data.addr_b>=30&&Store_Data.addr_b<0xFF&&!Key.learn_b)
				{
					if(scan_time - Key.interval_time_b > NEXT_WAIT_INTERVAL)
					{
						Key.interval_time_b=scan_time;
						NRF_SendData(Store_Data.addr_b,WAY_KEY_DATA,(u8 *)"",NRF_SendCallBack);
					}
				}
				if(Key.learn_b)
				{
					Key.learn_b=0;
				}
				if(esp8266.state==LIVE) esp8266.state=LINK;
			}
		}
	}
	if(KEY_C)//C键按下
	{
		if(!Key.flag_c)//松开状态下,检测到按下
		{
			Key.flag_c=1;
			Key.time_c=scan_time;//记录当前时间
		}
	}	
	if(Key.flag_c)
	{
		if(!led_flag)
		{
			if(scan_time - Key.time_c > LEARN_TIME)//大于3秒
			{
				led_flag=1;
				SetLed(0xff,18,18);
				printf("\r\nkey time > 3000ms\r\n");
			}
		}
	}
	if(!KEY_C)//C键松开时的处理
	{
		if(Key.flag_c)//按下状态下,检测到松开
		{
			Key.flag_c=0;
			led_flag = 0;
			SetLed(2,10,10);
			if(scan_time - Key.time_c > CLEAR_TIME)//大于8秒,清除地址
			{
				Store_Data.addr_c = 0;
				NRF_WriteDataToStore(PRO_STORE_FLAG,PRO_STORE_FLASH_ADDRESS,(u8 *)&Store_Data,sizeof(Store_obj));
				if(esp8266.state==LIVE) esp8266.state=LINK;
			}
			else if(scan_time - Key.time_c > LEARN_TIME)//大于3秒,进入学习模式
			{
				Key.time_c=scan_time;
				Key.learn_c=1;
				Key.learn_a=0;
				Key.learn_b=0;
				Key.learn_d=0;
				learn_flag=1;
				SetLed(0xff,30,30);
			}
			else if(scan_time - Key.time_c > FILTER_TIME && scan_time - Key.time_c < LEARN_TIME)
			{
				if(Store_Data.addr_c>=30&&Store_Data.addr_c<0xFF&&!Key.learn_c)
				{
					if(scan_time - Key.interval_time_c > NEXT_WAIT_INTERVAL)
					{
						Key.interval_time_c=scan_time;
						NRF_SendData(Store_Data.addr_c,WAY_KEY_DATA,(u8 *)"",NRF_SendCallBack);
					}
				}
				if(Key.learn_c)
				{
					Key.learn_c=0;
				}
				if(esp8266.state==LIVE) esp8266.state=LINK;
			}
		}
	}
	if(KEY_D)//D键按下
	{
		if(!Key.flag_d)//松开状态下,检测到按下
		{
			Key.flag_d=1;
			Key.time_d=scan_time;//记录当前时间
		}
	}	
	if(Key.flag_d)
	{
		if(!led_flag)
		{
			if(scan_time - Key.time_d > LEARN_TIME)//大于3秒
			{
				led_flag=1;
				SetLed(0xff,18,18);
				printf("\r\nkey time > 3000ms\r\n");
			}
		}
	}
	if(!KEY_D)//D键松开时的处理
	{
		if(Key.flag_d)//按下状态下,检测到松开
		{
			Key.flag_d=0;
			led_flag = 0;
			SetLed(2,10,10);
			if(scan_time - Key.time_d > CLEAR_TIME)//大于8秒,清除地址
			{
				Store_Data.addr_d = 0;
				NRF_WriteDataToStore(PRO_STORE_FLAG,PRO_STORE_FLASH_ADDRESS,(u8 *)&Store_Data,sizeof(Store_obj));
				if(esp8266.state==LIVE) esp8266.state=LINK;
			}
			else if(scan_time - Key.time_d > LEARN_TIME)//大于3秒,进入学习模式
			{
				Key.time_d=scan_time;
				Key.learn_d=1;
				Key.learn_a=0;
				Key.learn_b=0;
				Key.learn_c=0;
				learn_flag=1;
				SetLed(0xff,30,30);
			}
			else if(scan_time - Key.time_d > FILTER_TIME && scan_time - Key.time_d < LEARN_TIME)
			{
				if(Store_Data.addr_d>=30&&Store_Data.addr_d<0xFF&&!Key.learn_d)
				{
					if(scan_time - Key.interval_time_d > NEXT_WAIT_INTERVAL)
					{
						Key.interval_time_d=scan_time;
						NRF_SendData(Store_Data.addr_d,WAY_KEY_DATA,(u8 *)"",NRF_SendCallBack);
					}
				}
				if(Key.learn_d)
				{
					Key.learn_d=0;
				}
				if(esp8266.state==LIVE) esp8266.state=LINK;
			}
		}
	}
	
	if(Key.learn_a)
	{
		if(scan_time - Key.time_a > LEARN_WAIT_INTERVAL)//大于10秒,退出学习模式
		{
			Key.learn_a=0;
		}
	}
	if(Key.learn_b)
	{
		if(scan_time - Key.time_b > LEARN_WAIT_INTERVAL)
		{
			Key.learn_b=0;
		}
	}
	if(Key.learn_c)
	{
		if(scan_time - Key.time_c > LEARN_WAIT_INTERVAL)
		{
			Key.learn_c=0;
		}
	}
	if(Key.learn_d)
	{
		if(scan_time - Key.time_d > LEARN_WAIT_INTERVAL)
		{
			Key.learn_d=0;
		}
	}
	if(learn_flag)
	{
		if(!Key.learn_a&&!Key.learn_b&&!Key.learn_c&&!Key.learn_d)
		{
			learn_flag=0;
			if(esp8266.state==LIVE) esp8266.state=LINK;
		}
	}
}
