STM32F103按键操作的另一种实现——状态机

#ifndef _KEY_H_
#define _KEY_H_

#include "HAL_gpio.h" // 换成STM32F103对应的GPIO库
#include "type.h"     // type.h主要是一些类型的重命名

#define KEY_UP_GRP         GPIOA
#define KEY_UP_IDX         GPIO_Pin_9
#define KEY_UP_IS_DOWN()   GPIO_ReadInputDataBit(KEY_UP_GRP, KEY_UP_IDX)
#define KEY_UP_CONFIG()    GPIOConfig(KEY_UP_GRP, KEY_UP_IDX, GPIO_Mode_IPU) // 这个函数我在之前帖子里面写过

#define KEY_DOWN_GRP       GPIOA
#define KEY_DOWN_IDX       GPIO_Pin_10
#define KEY_DOWN_IS_DOWN() GPIO_ReadInputDataBit(KEY_DOWN_GRP, KEY_DOWN_IDX)
#define KEY_DOWN_CONFIG()  GPIOConfig(KEY_DOWN_GRP, KEY_DOWN_IDX, GPIO_Mode_IPU)

#define KEY_FUNC_GRP       GPIOA
#define KEY_FUNC_IDX       GPIO_Pin_11
#define KEY_FUNC_IS_DOWN() GPIO_ReadInputDataBit(KEY_FUNC_GRP, KEY_FUNC_IDX)
#define KEY_FUNC_CONFIG()  GPIOConfig(KEY_FUNC_GRP, KEY_FUNC_IDX, GPIO_Mode_IPU) 

#define KEY_TURN_GRP       GPIOA
#define KEY_TURN_IDX       GPIO_Pin_12 | GPIO_Pin_13
#define KEY_TURN_IS_DOWN() GPIO_ReadInputDataBit(KEY_TURN_GRP, KEY_TURN_IDX)
#define KEY_TURN_CONFIG()  GPIOConfig(KEY_TURN_GRP, KEY_TURN_IDX, GPIO_Mode_IPU)

//====================================================================================
typedef enum
{
  CONFIRM_KEY = 1,
  FUNC_KEY,
  UP_KEY,
  DOWN_KEY
} key_event_t;

#define state_keyUp         0       //初始状态,未按键
#define state_keyDown       1       //键被按下
#define state_keyLong       2       //长按
#define state_keyTime       3       //按键计时态

#define return_keyUp        0x00    //初始状态
#define return_keyPressed   0x01    //键被按过,普通按键
#define return_keyLong      0x02    //长按
#define return_keyAuto      0x04    //自动连发

#define key_down            0       //按下
#define key_up              0xf0    //未按时的key有效位键值
#define key_longTimes       100     //10ms一次,200次即2秒,定义长按的判定时间
#define key_autoTimes       20      //连发时间定义,20*10=200,200毫秒发一次


#define KEYS1_VALUE         0xe0    //keyS1 按下
#define KEYS2_VALUE         0xd0    //keyS2 按下
#define KEYS3_VALUE         0xb0    //keyS3 按下
#define KEYS4_5_VALUE       0x70    //keyS4_5 按下

//====================================================================================
void KeyProcess(void);  //T0定时器调用的工作函数
void KeyTimerInit(void);

#endif /* _KEY_H_ */

#include#include "key.h"
#include "timer.h" // STM32F103定时器的配置

static uint8_t
key_get(void)       //获取P3口值
{
  if(KEY_UP_IS_DOWN() == key_down)
  {
    return KEYS1_VALUE;
  }
  if(KEY_DOWN_IS_DOWN() == key_down)
  {
    return KEYS2_VALUE;
  }
  if(KEY_FUNC_IS_DOWN() == key_down)
  {
    return KEYS3_VALUE;
  }
  if(KEY_TURN_IS_DOWN() == key_down)
  {
    return KEYS4_5_VALUE;
  }

  return key_up ;    //0xf0  没有任何按键
}

//函数每20ms被调用一次，而我们弹性按键过程时一般都20ms以上
//所以每次按键至少调用本函数2次
static uint8_t
key_read(uint8_t* pKeyValue)
{
  static uint8_t  s_u8keyState = 0;        //未按，普通短按，长按,连发等状态
  static uint16_t s_u16keyTimeCounts = 0;  //在计时状态的计数器
  static uint8_t  s_u8LastKey = key_up ; //保存按键释放时的P3口数据

  uint8_t keyTemp = 0;              //键对应io口的电平
  int8_t key_return = 0;          //函数返回值
  keyTemp = key_up & key_get();  //提取所有的key对应的io口

  switch(s_u8keyState)           //这里检测到的是先前的状态
  {
  case state_keyUp:   //如果先前是初始态，即无动作
  {
    if(key_up != keyTemp) //如果键被按下
    {
      s_u8keyState = state_keyDown; //更新键的状态，普通被按下
    }
  }
  break;

  case state_keyDown: //如果先前是被按着的
  {
    if(key_up != keyTemp) //如果现在还被按着
    {
      s_u8keyState = state_keyTime; //转换到计时态
      s_u16keyTimeCounts = 0;
      s_u8LastKey = keyTemp;     //保存键值
    }
    else
    {
      s_u8keyState = state_keyUp; //键没被按着，回初始态，说明是干扰
    }
  }
  break;

  case state_keyTime:  //如果先前已经转换到计时态(值为3)
  {
    //如果真的是手动按键,必然进入本代码块,并且会多次进入
    if(key_up == keyTemp) //如果未按键
    {
      s_u8keyState = state_keyUp;
      key_return = return_keyPressed;    //返回1,一次完整的普通按键
      //程序进入这个语句块，说明已经有2次以上10ms的中断，等于已经消抖
      //那么此时检测到按键被释放，说明是一次普通短按
    }
    else  //在计时态，检测到键还被按着
    {
      if(++s_u16keyTimeCounts > key_longTimes) //时间达到2秒
      {
        s_u8keyState = state_keyLong;  //进入长按状态
        s_u16keyTimeCounts = 0;      //计数器清空,便于进入连发重新计数
        key_return = return_keyLong;   //返回state_keyLong
      }
      //代码中,在2秒内如果我们一直按着key的话,返回值只会是0,不会识别为短按或长按的
    }
  }
  break;

  case state_keyLong:  //在长按状态检测连发  ,每0.2秒发一次
  {
    if(key_up == keyTemp)
    {
      s_u8keyState = state_keyUp;
    }
    else //按键时间超过2秒时
    {
      if(++s_u16keyTimeCounts > key_autoTimes)//10*20=200ms
      {
        s_u16keyTimeCounts = 0;
        key_return = return_keyAuto;  //每0.2秒返回值的第2位置位(1<<2)
      }//连发的时候,肯定也伴随着长按
    }
    key_return |= return_keyLong;  //0x02是肯定的,0x04|0x02是可能的
  }
  break;

  default:
    break;
  }
  *pKeyValue = s_u8LastKey ; //返回键值
  return key_return;
}

// 这个函数就是要在中断中调用的。主要是使用事件队列的方式。
void
KeyProcess(void)
{
  uint8_t key_stateValue;
  uint8_t keyValue = 0;
  uint8_t* pKeyValue = &keyValue;

  key_stateValue = key_read(pKeyValue);

  if ((return_keyPressed == key_stateValue) && (*pKeyValue == KEYS1_VALUE))
  {
    //短按keyS1时改变对时状态，将其加入队列，队列的基本操作在将队列的时候写过。
    if(QueueEventIsEmpty(g_state_manager.process->key_event) ||
        (!QueueEventIsEmpty(g_state_manager.process->key_event) &&
         !QUEUE_EVENT_IS_EQUEL(g_state_manager.process->key_event, UP_KEY)))
    {
      QueueEventPush(g_state_manager.process->key_event, UP_KEY);
    }
  }
}

//======================================================================================
void
KeyTimerInit(void)
{
  KEY_UP_CONFIG();
  KEY_DOWN_CONFIG();
  KEY_FUNC_CONFIG();
  KEY_TURN_CONFIG();

  // 20ms
  TimerConfig(KEY_TIMER, KEY_TIMER_DIV, KEY_TIMER_PERIOD);
  TimerDisable(KEY_TIMER);
  TimerEnable(KEY_TIMER);
}

主要是描述一下按键状态机的思维，使用定时器中断的方法，按键按下将其加入队列中，在主函数的循环中实现出队。亲测可用。