【一】：按键的模型
（1）单击按键： 按键按下到释放的一个过程，t1 如果大于 50ms.

（2）双击按键：如果两个脉冲之间相差时间t2 < 200ms 认为是 双按键
否则 判定为两次不相干的按键行为。
<同样可以判定连续多次按键，但是一般没什么意义>

（3）长按键：如果按下时间t3 >=500ms 判定为长按键

【二】主函数的处理
按键的处理函数： void APP_KEY_Task(void) 。 需要每5ms 调用一次
该函数需要判断上次状态last，以及当前的状态now。

所以主函数就显得比较简单：

void  act0 ( KEY_StateMachine *   pStateMachine);
void  act1 ( KEY_StateMachine *   pStateMachine);
void  act2 ( KEY_StateMachine *   pStateMachine);
void  act3 ( KEY_StateMachine *   pStateMachine);

ActionFunType transition_table[KEY_STATES][KEY_STATES]={
{&act3,&act0,},
{&act2,&act1,},
};

void KEY_GPIO_DEAL(MYKEY_TYPE* mykey)
{
	 KEY_State  State_now= KEY_STATES_RELEASE ;
	 if(GPIO_ReadInputDataBit(mykey->keyset.GPIOx,mykey->keyset.Pin)==KEY_PUSH)State_now= KEY_STATES_PUSH;     //读取当前按键状态
	
   (*transition_table[mykey->Machine.State_last][State_now] )( (KEY_StateMachine *) (&(mykey->Machine))  );  //根据状态 *FUNC【last】【now】 执行对应的处理函数
	
	  mykey->Machine.State_last=State_now;  //保存当前的按键状态
}

这个函数数值中依次对应关系为：

其中act0: 表示 从释放状态到按下，为按下按键的瞬间
其中act1: 表示 从按下状态到按下，为保持按下的状态
其中act2: 表示 从按下状态到释放，为释放按键的瞬间
其中act3: 表示 从释放状态到释放，为保持释放的状态

在这一步中我们不需要关系act0–3回调函数执行了什么，我们关系的是当前状态和上一个状态是否按下，然后执行哪种回调处理即可！

【三】按键的判断的处理。
定义一个结构体：

typedef struct
{
  KEY_State         State_last;       //记录当前的时间
  uint32_t          usTime;        //记录按下的时间
  uint32_t          usTS;          //记录释放的时间
  uint32_t          usKeyDtcNum;	 //记录脉冲数
  KeyDeal           NO_PRO_Deal;
  KeyDeal           SHOURT_Deal;
  KeyDeal           LONG_Deal;
  KeyDeal           DOUBLE_Deal;
}KEY_StateMachine,*KEY_pStateMachine;

依次保存上一次调用时候的状态：State_last，
按下保持时间的计时：usTime
释放保持时间的计时：usTS
满足连续单击按钮的次数：usKeyDtcNum

执行：act0: usTime=0

执行：act1: usTime++
if(usTime== 500ms)
｛
usKeyDtcNum=0； //清空连续单击按钮的次数
LONG_Deal(); //回调长按键处理
｝ //

在长按键处理上 如果==500s 那么一直按只会调用一次（不考虑溢出）如果加上判断可以实现长按快速增加数值的，例如：像SMC表头长按按键快速增减，随着长按的时间的增加，数值增加的速度也会加快。

执行：act2: usTS=0
if( 50ms < usTime< 200ms)
{
usKeyDtcNum++; //连续单击按钮的次数增加
}

执行：act3:
if(usTS<200ms)usTS++
else{
if( usKeyDtcNum == 1)SHOURT_Deal)(); //短按键处理
if(usKeyDtcNum >= 2) DOUBLE_Deal)(); //双击按键处理
usKeyDtcNum=0; usTS=0; //清空标志
}

这里可以判断单击，双击，甚至连续三击。。（双击之上的判断没什么意义）

附：

#include "bsp/key/bsp_key.h"



 MYKEY_TYPE  MYKEY1 = {
 	{RCC_APB2Periph_GPIOB,GPIOB,GPIO_Pin_4},
	{0,0,0,0,0,0,0,0, },
 };
 
  MYKEY_TYPE  MYKEY2 = {
 	{RCC_APB2Periph_GPIOB,GPIOB,GPIO_Pin_3},
	{0,0,0,0,0,0,0,0, },
 };


void  act0 ( KEY_StateMachine *   pStateMachine);
void  act1 ( KEY_StateMachine *   pStateMachine);
void  act2 ( KEY_StateMachine *   pStateMachine);
void  act3 ( KEY_StateMachine *   pStateMachine);


ActionFunType transition_table[KEY_STATES][KEY_STATES]={
{&act3,&act0,},
{&act2,&act1,},
};




 
 void KEY_GPIO_Init( MYKEY_TYPE* mykey )
{
  GPIO_InitTypeDef GPIO_InitStructure;
  RCC_APB2PeriphClockCmd(mykey->keyset.RCC_AHB1Periph, ENABLE);	
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;  
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU;   
  GPIO_InitStructure.GPIO_Pin = mykey->keyset.Pin;  
  GPIO_Init(mykey->GPIOx, &GPIO_InitStructure);
  mykey->Machine.State_last=0;
  mykey->Machine.usKeyDtcNum=0;
  mykey->Machine.usTime=0;
  mykey->Machine.usTS=0;
}



void KEY_GPIO_DEAL(MYKEY_TYPE* mykey)
{
	 KEY_State  State_now= KEY_STATES_RELEASE ;
	 if(GPIO_ReadInputDataBit(mykey->keyset.GPIOx,mykey->keyset.Pin)==KEY_PUSH)State_now= KEY_STATES_PUSH;     //读取当前按键状态
	
   (*transition_table[mykey->Machine.State_last][State_now] )( (KEY_StateMachine *) (&(mykey->Machine))  );  //根据状态 *FUNC【last】【now】 执行对应的处理函数
	
	  mykey->Machine.State_last=State_now;  //保存当前的按键状态
}



//释放状态被按下
void  act0 ( KEY_StateMachine *  pStateMachine)
{
   pStateMachine->usTime=0;
}
//按下状态
void  act1 ( KEY_StateMachine *   pStateMachine)
{
	 uint32_t number=0;
   pStateMachine->usTime++;
	 if( pStateMachine->usTime ==  KEY_PUSH_0500MS  )
	 {
		pStateMachine->usKeyDtcNum=0;
	  (*pStateMachine->LONG_Deal)(); //长按键处理
	 }		 
}
//按下状态被释放
void  act2 ( KEY_StateMachine *   pStateMachine)
{
   pStateMachine->usTS=0;
	 if ( ( pStateMachine->usTime >KEY_PUSH_0050MS) && ( pStateMachine->usTime <KEY_PUSH_0200MS) )
	 {
	   pStateMachine->usKeyDtcNum++;
	 }
}
//释放状态
void  act3 ( KEY_StateMachine *   pStateMachine)
{
	 if( pStateMachine->usTS < KEY_PUSH_0200MS )
	 {
	     pStateMachine->usTS++;
	 }else
	 {
	   if(pStateMachine->usKeyDtcNum == 1)
		 {
		   (*pStateMachine->SHOURT_Deal)(); //短按键处理
		 } 
		 if(pStateMachine->usKeyDtcNum >= 2)
		 {
		    (*pStateMachine->DOUBLE_Deal)(); //双击按键处理
		 }
     pStateMachine->usKeyDtcNum=0;
		 pStateMachine->usTS=0;		 
		 
	 }
}
/*********************END OF FILE*********************/

#ifndef __BSP_KEY_H__
#define __BSP_KEY_H__

/* 包含头文件 ----------------------------------------------------------------*/
#include <stm32f10x.h>

/* 类型定义 --------------------------------------------------------------*/
typedef enum
{
  KEY_UP   = 0,
  KEY_DOWN = 1,
}KEYState_TypeDef;

#define KEY_PUSH               0
#define KEY_PUSH_0050MS        10    //定义按键判断时间  10X5ms= 50MS
#define KEY_PUSH_0200MS        40    //定义按键判断时间   40X5ms=200MS
#define KEY_PUSH_0500MS        100   //定义按键判断时间   100X5ms=500MS


typedef int KEY_State;
typedef int KEY_Condition;

//状态
#define KEY_STATES            2
#define KEY_STATES_RELEASE    0
#define KEY_STATES_PUSH       1



typedef void  (*KeyDeal)( void);

typedef struct
{
  KEY_State         State_last;       //记录当前的状态
	uint32_t          usTime;        //记录按下的时间
  uint32_t          usTS;          //记录释放的时间
  uint32_t          usKeyDtcNum;	 //记录脉冲数
	KeyDeal           NO_PRO_Deal;
	KeyDeal           SHOURT_Deal;
	KeyDeal           LONG_Deal;
	KeyDeal           DOUBLE_Deal;
	
}KEY_StateMachine,*KEY_pStateMachine;
 
typedef void  (*ActionFunType)( KEY_pStateMachine  pStateMachine);
typedef struct
{
	uint32_t   RCC_AHB1Periph;
	GPIO_TypeDef*   GPIOx;
	uint16_t        Pin;
}MYKEY_SET_TYPE;
typedef struct
{
	MYKEY_SET_TYPE    keyset;
	KEY_StateMachine  Machine;
}MYKEY_TYPE;




//PB3 PB6 PB8
/* 宏定义 --------------------------------------------------------------------*/
#define KEY1_RCC_CLOCKGPIO            RCC_APB2Periph_GPIOB
#define KEY1_GPIO_PIN                 GPIO_Pin_3
#define KEY1_GPIO                     GPIOB
#define KEY1_DOWN_LEVEL               0  /* 根据原理图设计，KEY1按下时引脚为低电平，所以这里设置为0 */

#define KEY2_RCC_CLOCKGPIO            RCC_APB2Periph_GPIOB
#define KEY2_GPIO_PIN                 GPIO_Pin_6
#define KEY2_GPIO                     GPIOB
#define KEY2_DOWN_LEVEL               0  /* 根据原理图设计，KEY1按下时引脚为低电平，所以这里设置为0 */

extern  MYKEY_TYPE  MYKEY1;
extern  MYKEY_TYPE  MYKEY2;
void KEY_GPIO_Init( MYKEY_TYPE* mykey );
void KEY_GPIO_DEAL(MYKEY_TYPE* mykey);



#endif  // __BSP_KEY_H__

/*****END OF FILE****/

调用：如果使用的不是操作系统的话，可以让主函数每5ms调用一次即可。本函数的回调函数尽量不要搞成阻塞的。如果使用操作系统，阻塞一些也没啥毛病。。。

void led0_task(void *pvParameters)
{  
	  MYKEY1.Machine.NO_PRO_Deal=callback10;
	  MYKEY1.Machine.SHOURT_Deal=callback11;
	  MYKEY1.Machine.DOUBLE_Deal=callback12;
	  MYKEY1.Machine.LONG_Deal  =callback13;
	  KEY_GPIO_Init( &MYKEY1 );	
	  MYKEY2.Machine.NO_PRO_Deal=callback20;
	  MYKEY2.Machine.SHOURT_Deal=callback21;
	  MYKEY2.Machine.DOUBLE_Deal=callback22;
	  MYKEY2.Machine.LONG_Deal  =callback23;
	  KEY_GPIO_Init( &MYKEY2 );	
    while(1)
    {	 
		   KEY_GPIO_DEAL(&MYKEY1);
		   KEY_GPIO_DEAL(&MYKEY2);
            vTaskDelay(5);
    }
}