【实现功能】
使用板载的按键，来实现一个按键计数器，每次单击按键时，计数器加1，长按按键，清除计数。
【实现步骤】
1、先确定原理图中按键的引脚：
image.png
因此我们初始化按键：PA_INIT_AS_INPUT(IO_BIT_PIN0);
2、首先我们引入按键的BSP驱动，实现面向对象的管理：
image.png
其中按键管理为：
  1. #ifndef __KEY_MANAGE_H__
  2. #define __KEY_MANAGE_H__

  4. #ifdef __cplusplus
  5. extern "C" {
  6. #endif

  8. #include "key_driver.h"
  9. #include <string.h>

  11. #define __KEY_EVENT_CALL(event)                 \
  12.     do {                                        \
  13.         if (key->event_callback[event]) {       \
  14.             key->event_callback[event](key);    \
  15.         }                                       \
  16.     } while (0U)


  19. #define CHECK_TICK                      5                      // 按键状态机检查间隔时间(ms)
  20. #define DEBOUNCE_TICK                   (15 / CHECK_TICK)      // 消抖时间(ms) [最大40/5且DEBOUNCE_TICK < SHORT_PRESS_START_TICK/2]
  21. #define SHORT_PRESS_START_TICK          (300  / CHECK_TICK)    // 连击态触发间隔时间(ms) [最大40 / 5]
  22. #define LONG_PRESS_START_TICK           (1000 / CHECK_TICK)    // 长按态触发时间(ms)
  23. #define LONG_HOLD_CYCLE_TICK            (500 / CHECK_TICK)     // 长按态保持下连续触发长按事件的间隔(ms)

  25. /**
  26. * @brief   按键对象状态
  27. */
  28. enum key_state {
  29.   Init_None_State = 0,        /* 初始未按下状态 */
  30.   Init_Press_State,           /* 初次按下状态 */
  31.   Press_Check_State,          /* 连击检查状态 */
  32.   Continuous_Press_State,     /* 连续按下状态 */
  33.   Long_Press_State,           /* 长按状态 */
  34. };

  36. /**
  37. * @brief   按键对象事件
  38. */
  39. enum key_event {
  40.   Press_Down = 0,             /* 按键按下，每次按下都触发 */
  41.   Press_Up,                   /* 按键弹起，每次松开都触发 */
  42.   Singe_Click,                /* 单击触发(仅触发一次) */
  43.   Double_Click,               /* 双击触发(仅触发一次) */
  44.   Short_Press_Repeat,         /* 每次短按时都会触发(按下次数>=2) */
  45.   Long_Press_Start,           /* 首次进入长按状态触发(仅触发一次) */
  46.   Long_Press_Hold,            /* 长按保持状态触发(每经过一个循环长按间隔触发一次) */
  47.   Event_Sum,                  /* 事件总数 */
  48.   None_Press                  /* 未按下 */
  49. };

  51. /**
  52. * @brief   按键对象句柄结构体
  53. */
  54. struct key_handle
  55. {
  56.   uint16_t tick;                                                    /* 按键系统时间片 */
  57.   uint8_t repeat_cnt     : 4;                                       /* 按键短按次数 */
  58.   uint8_t event                : 4;                                       /* 触发事件 */
  59.   uint8_t state          : 3;                                       /* 按键状态 */
  60.   uint8_t debounce_tick  : 3;                                       /* 消抖时间片 */
  61.   uint8_t active_level   : 1;                                   /* 按键有效按下电平 */
  62.   uint8_t key_level      : 1;                                       /* 按键引脚当前电平 */
  63.   uint8_t (* pin_read)(void);                                       /* 获取按键引脚电平 */
  64.   void (* event_callback[Event_Sum])(struct key_handle* key);   /* 按键事件回调函数 */
  65.   struct key_handle* next;                                      /* 单向链表next指针 */
  66. };
  67. typedef struct key_handle *key_handle_t;

  69. /* 按键管理函数接口 */
  70. int8_t key_init(struct key_handle *key, uint8_t (*gpio_pin_read)(void), uint8_t active_level);
  71. int8_t key_handle_register(struct key_handle *key);
  72. int8_t key_handle_detach(struct key_handle *key);
  73. int8_t key_event_callback_register(struct key_handle *key, uint8_t event, void (* event_callback)(key_handle_t key));
  74. void key_tick(void);

  76. #ifdef __cplusplus
  77. }
  78. #endif
  79. #endif /* __KEY_MANAGE_H */

按键管理C函数为：
  1. #include "key_manage.h"

  3. static key_handle_t _key_slist_head = NULL;  // 按键管理单链表头结点

  5. /**
  6. * @brief   初始化按键对象
  7. * @param   key             按键对象句柄
  8. * @param   gpio_pin_read   获取按键电平函数指针
  9. * @param   active_level    按键按下有效电平
  10. * @return  0: succeed -1: failed
  11. */
  12. int8_t key_init(struct key_handle *key, uint8_t (*gpio_pin_read)(void), uint8_t active_level)
  13. {
  14.   if (key == NULL)
  15.     return -1;
  16.   memset(key, 0, sizeof(struct key_handle));
  17.   key->event = None_Press;
  18.   key->active_level = active_level;
  19.   key->pin_read = gpio_pin_read;
  20.   key->key_level = key->pin_read();

  22.   return 0;
  23. }

  25. /**
  26. * @brief   注册按键:将按键对象插入到按键管理链表中
  27. * @param   key 按键对象句柄
  28. * @return  0: succeed -1: failed
  29. */
  30. int8_t key_handle_register(struct key_handle *key)
  31. {
  32.   struct key_handle *key_slist_node = _key_slist_head;  // 获取头指针的地址 (无头结点单链表)

  34.   if (key == NULL)
  35.     return -1;

  37.   // 尾插(不带头结点的单链表, 头指针需做特殊判断)
  38.   if (_key_slist_head == NULL) // 头指针为空==表空
  39.   {
  40.     _key_slist_head = key;
  41.     key->next = NULL;
  42.     return 0;
  43.   }

  45.   while(key_slist_node)
  46.   {
  47.     if (key_slist_node == key) return -1;       // 重复注册
  48.     if(key_slist_node->next == NULL) break;     // 已经遍历到最后一个节点,必须在此跳出循环, 否则key_slist_node==NULL
  49.     key_slist_node = key_slist_node->next;
  50.   }
  51.   key_slist_node->next = key;
  52.   key->next = NULL;

  54.   return 0;
  55. }

  57. /**
  58. * @brief   脱离按键:将按键对象从按键管理链表中脱离
  59. * @param   key 按键对象句柄
  60. * @return  0: succeed -1: failed
  61. */
  62. int8_t key_handle_detach(struct key_handle *key)
  63. {
  64.   // 解1级引用指向指针变量, 解2级引用指向指针变量所指向的变量
  65.   struct key_handle **key_slist_node = &_key_slist_head;  // 指向头指针, 直接操作原指针变量(不然最后无法修改头指针)
  66.   struct key_handle *node_temp;
  67.   if (key == NULL || _key_slist_head == NULL)
  68.     return -1;

  70.   while(*key_slist_node && *key_slist_node != key)
  71.   {
  72.     node_temp = *key_slist_node;
  73.     if((*key_slist_node)->next == NULL) break;
  74.     key_slist_node = &node_temp->next;     // 不能直接解1级引用赋值，会破坏原链表
  75.   }

  77.   if (*key_slist_node != key)
  78.     return -1;
  79.   *key_slist_node = (*key_slist_node)->next;

  81.   return 0;
  82. }

  84. /**
  85. * @brief   注册按键事件触发回调函数
  86. * @param   key             按键对象句柄
  87. * @param   event           触发事件类型
  88. * @param   event_callback  事件回调函数
  89. * @return  0: succeed -1: failed
  90. */
  91. int8_t key_event_callback_register(struct key_handle *key, uint8_t event, void (* event_callback)(key_handle_t key))
  92. {
  93.   if (key == NULL || event >= Event_Sum)
  94.     return -1;
  95.   key->event_callback[event] = event_callback;

  97.   return 0;
  98. }

  100. /**
  101. * @brief   处理所有按键对象的状态机
  102. * @param   key 按键对象句柄
  103. * @return  None
  104. */
  105. static void key_handler(struct key_handle *key)
  106. {
  107.   uint8_t key_level_temp = key->pin_read();

  109.   if(key->state != Init_None_State) key->tick++;

  111.   /* 按键消抖(按键状态发生变化保持DEBOUNCE_TICK时间片开始保存按键引脚电平) */
  112.   if(key_level_temp != key->key_level)
  113.   {
  114.     if(++(key->debounce_tick) >= Double_Click)
  115.     {
  116.       key->key_level = key_level_temp;
  117.       key->debounce_tick = 0;
  118.     }
  119.   }
  120.   else
  121.   {
  122.     key->debounce_tick = 0;
  123.   }

  125.   /* 按键状态机 */
  126.   switch (key->state)
  127.   {
  128.   case Init_None_State:
  129.     /* 初始态-> 初始按下态  Press_Down */
  130.     if(key->key_level == key->active_level)
  131.     {
  132.       key->event = (uint8_t)Press_Down;
  133.       __KEY_EVENT_CALL(Press_Down);
  134.       key->tick  = 0;
  135.       key->repeat_cnt = 1;
  136.       key->state  = Init_Press_State;
  137.     }
  138.     else
  139.     {
  140.       key->event = (uint8_t)None_Press;
  141.     }
  142.     break;

  144.   case Init_Press_State:
  145.     /* 第一次按下松开：初始按下态->连击检查态  Press_Up */
  146.     if(key->key_level != key->active_level)
  147.     {
  148.       key->event = (uint8_t)Press_Up;
  149.       __KEY_EVENT_CALL(Press_Up);
  150.       key->tick = 0;
  151.       key->state = Press_Check_State;

  153.     }
  154.     /* 第一次按下后长按(>LONG_PRESS_START_TICK)：初始按下态->长按态  Long_Press_Start */
  155.     else if(key->tick > LONG_PRESS_START_TICK)
  156.     {
  157.       key->event = (uint8_t)Long_Press_Start;
  158.       __KEY_EVENT_CALL(Long_Press_Start);
  159.       key->state = Long_Press_State;
  160.     }
  161.     break;

  163.   case Press_Check_State:
  164.     /* 松开后再次按下：连击检查态->连击态 Press_Down & Short_Press_Repeat */
  165.     if(key->key_level == key->active_level)
  166.     {
  167.       key->event = (uint8_t)Press_Down;
  168.       __KEY_EVENT_CALL(Press_Down);
  169.       key->repeat_cnt++;
  170.       __KEY_EVENT_CALL(Short_Press_Repeat);
  171.       key->tick = 0;
  172.       key->state = Continuous_Press_State;
  173.     }
  174.     /* 松开后再次没有按下(>SHORT_PRESS_START_TICK)：连击检查态->初始态 repeat_cnt=1: Singe_Click; repeat_cnt=2: Double_Click */
  175.     else if(key->tick > SHORT_PRESS_START_TICK)
  176.     {
  177.       if(key->repeat_cnt == 1)
  178.       {
  179.         key->event = (uint8_t)Singe_Click;
  180.         __KEY_EVENT_CALL(Singe_Click);
  181.       }
  182.       /* 连击态松开后会返回此条件下触发  todo: <可以做n连击判断> */
  183.       else if(key->repeat_cnt == 2)
  184.       {
  185.         key->event = (uint8_t)Double_Click;
  186.         __KEY_EVENT_CALL(Double_Click);
  187.       }
  188.       key->state = Init_None_State;
  189.     }
  190.     break;

  192.   case Continuous_Press_State:
  193.     /* 连击后松开：连击态->连击检查态(< SHORT_PRESS_START_TICK)) : 连击态->初始态(>= SHORT_PRESS_START_TICK) */
  194.     if(key->key_level != key->active_level)
  195.     {
  196.       key->event = (uint8_t)Press_Up;
  197.       __KEY_EVENT_CALL(Press_Up);

  199.       if(key->tick < SHORT_PRESS_START_TICK)
  200.       {
  201.         key->tick = 0;
  202.         key->state = Press_Check_State;
  203.       }
  204.       else
  205.       {
  206.         key->state = Init_None_State;
  207.       }
  208.     }
  209.     /* 连击后长按(>SHORT_TICKS): 连击态 -> 初始态 */
  210.     else if(key->tick > SHORT_PRESS_START_TICK)
  211.     {
  212.       key->state = Init_Press_State;  // 可以回到Init_None_State/Init_Press_State
  213.     }
  214.     break;

  216.   case Long_Press_State:
  217.     /* 长按保持  Long_Press_Hold */
  218.     if(key->key_level == key->active_level)
  219.     {
  220.       key->event = (uint8_t)Long_Press_Hold;
  221.       if (key->tick % LONG_HOLD_CYCLE_TICK == 0)
  222.       {
  223.         __KEY_EVENT_CALL(Long_Press_Hold);
  224.       }
  225.     }
  226.     /* 长按松开：长按态-> 初始态 */
  227.     else
  228.     {
  229.       key->event = (uint8_t)Press_Up;
  230.       __KEY_EVENT_CALL(Press_Up);

  232.       key->state = Init_None_State;
  233.     }
  234.     break;
  235.   }
  236. }

  238. /**
  239. * @brief   每经过一个滴答周期调用一次按键处理函数(裸机放1ms中断, OS放线程或中断)
  240. * @param   None
  241. * @return  None
  242. */
  243. void key_tick(void)
  244. {
  245.   struct key_handle *key_slist_node;
  246.   static uint8_t tick_cnt = 0;

  248.   if (++tick_cnt < CHECK_TICK)
  249.     return;

  251.   for (key_slist_node = _key_slist_head; key_slist_node != NULL; key_slist_node = key_slist_node->next)
  252.   {
  253.     key_handler(key_slist_node);
  254.   }
  255.   tick_cnt = 0;
  256. }
2、引入驱动层函数：
  1. #include "key_driver.h"
  2. #include "me32f103_gpio.h"
  3. uint8_t key_sw1_read_pin(void)
  4. {
  5.   return GPIO_GetPinState(PA, IO_BIT_PIN0);
  6. }
3、在Main.c中初始化对象，并实现按键中断回调函数：
  1. static void key1_sw2_callback(key_handle_t key)
  2. {
  3.   switch (key->event) {
  4.                 case Singe_Click:
  5.                         tick++;
  6.                         flag = 1;
  7.                         break;
  8.                 case Long_Press_Hold:
  9.                         tick = 0;
  10.                         flag = 1;
  11.                         break;
  12.         }
  13. }

4、注册按键：
  1. LED_Init (COM0_3,CATHODE,0);
  2.         key_init(&_key1_sw2, key_sw1_read_pin, 0);

  4.     key_event_callback_register(&_key1_sw2, Singe_Click,           key1_sw2_callback);

  6.     key_event_callback_register(&_key1_sw2, Long_Press_Hold,    key1_sw2_callback);
  7.   key_handle_register(&_key1_sw2);

5、为了实现按键检测，我这里使用了一个定时器，每1ms进入中断一次，实现代码如下：
  1. CTIM_Init(CTIM0, 100000); //timer counter clk as 10khz,
  2.        
  3.         CTIM_ConfigMatch0(CTIM0, 100, TIM_MATCH_TRIGGER_INT|TIM_MATCH_RESET_COUNTER,TIM_MATCH_OUT_DO_NOTHING); //trigger int at ever 10ms
  4.        
  5.         NVIC_EnableIRQ(CTIM0_IRQn);

  7.         TIM_START(CTIM0);
6、中断回调函数如下，在中断中对计数按键进行检测：

  2. void CTIM0_IRQHandler(void)
  3. {
  4.         key_tick();
  5.         return;
  6. }
工程编译后，即中实现功能，详细结果见视频。