嵌入式设计编程：事件及事件队列_3(对按键进行读取)

在章节【嵌入式软件开发：非阻塞按键读取_2】中，实现了利用FIFO缓冲区来缓存按键值，在主函数里面进行循环扫描FIFO里面是否有键值。
这里也可以利用事件队列机制来实现。
当按键按下时，产生一个按键事件，包括短按键事件，长按键事件。

想想如何添加一个事件？？（三要素）
（1）静态初始化： static event_t keyPressEvent = EVENT_INIT(keyScanEvent);
（2）按键事件发生时，将其加入到事件队列中
（2）实现事件处理函数： static void keyScanEvent(void *data);
这里参数data 可以用来传递读取到的键值，在回调函数中，可以通过判断键值来确定按键按下的状态。

---

---

列代码：（黄色也新增的代码。）

#include "App_LongShortKey.h"
#include <stdio.h>

 // 添加的代码
#define KEY_EVENT_QUEUE_DEBUG

#ifdef KEY_EVENT_QUEUE_DEBUG
#include "eventQueue.h"

// 初始化按键事件及处理函数
static void keyScanEvent(void *data);
static event_t keyPressEvent = EVENT_INIT(keyScanEvent);
#endif


#define KEY0_INPUT  KEY1

static char key0_Status = 0;
static unsigned int key0_TimeS, key0_TimeL;


/**
 * \brief: 与FIFO相关的变量定义
 */
//#define KEYBUFFSIZE     4
char keyBuff[KEYBUFFSIZE];
char key_indexW = 0;
char key_indexR = 0;
char key_count = 0;

#define ENA_INT() __enable_irq()
#define DIS_INT() __disable_irq()
//#define ENA_INT()
//#define DIS_INT()

/**
 * \brief: 与FIFO相关操作的函数的定义
 */

void key_paraInit(void)
{
    char i = 0;

    for(i =0; i< KEYBUFFSIZE; i++)
        keyBuff[i] = 0;

    key_indexW = 0;
    key_indexR = 0;
    key_count = 0;
}

void key_inBuff(char keyValue)
{
    if(key_count >= KEYBUFFSIZE)
        return;

    DIS_INT();

    key_count ++;

    keyBuff[key_indexW] = keyValue;

    if(++ key_indexW == KEYBUFFSIZE)
        key_indexW = 0;

    ENA_INT();
}

char key_readBuff(void)
{
    char key = 0;

    if(key_count == 0)
        return 0;

    DIS_INT();

    key_count --;

    key = keyBuff[key_indexR];
    if( ++key_indexR == KEYBUFFSIZE)
        key_indexR = 0;

    ENA_INT();
    return key;
}

/**
 * \brief:
 */
uint8_t keyCodeBuff[1];

void keyScan(void)
{


    if(key0_Status == KEY_SHORT_PRESS)
        key0_TimeS ++;
    else
        key0_TimeS = 0;

    if(key0_Status == KEY_LONG_PRESS)
        key0_TimeL ++;
    else
        key0_TimeL = 0;

    switch(key0_Status)
    {
        case KEY_NO_PRESS:
            if(KEY0_INPUT == 0)
                key0_Status = KEY_SHORT_PRESS;
        break;

        case KEY_SHORT_PRESS:

            if(KEY0_INPUT != 0) // 表示按键松开了
            {
                // 保存按键
                //key_inBuff(KEY_SHORT_CODE + KEY0_CODE);

#ifdef KEY_EVENT_QUEUE_DEBUG

                keyCodeBuff[0] = KEY_SHORT_CODE + KEY0_CODE;
                EventQueue_EnqueueWithData(&keyPressEvent, keyCodeBuff);
#endif

                // 返回到按键未按下模式
                key0_Status = KEY_NO_PRESS;
            }
            else
            {
                if(key0_TimeS >= 2000/10) // 2s detect
                {
                    //key_inBuff(KEY_FIRST_LONG_CODE + KEY0_CODE);
#ifdef KEY_EVENT_QUEUE_DEBUG

                   keyCodeBuff[0] = KEY_FIRST_LONG_CODE + KEY0_CODE;
                   EventQueue_EnqueueWithData(&keyPressEvent, keyCodeBuff);
#endif


                    key0_Status = KEY_LONG_PRESS;
                }
            }
        break;

        case KEY_LONG_PRESS:

            if(KEY0_INPUT != 0) // 表示按键松开了
            {
                // 返回到按键未按下模式
                key0_Status = KEY_NO_PRESS;
            }
            else
            {
                if(key0_TimeL >= 100/10) // 250ms
                {
                    //key_inBuff(KEY_AFTER_LONG_CODE + KEY0_CODE);
#ifdef KEY_EVENT_QUEUE_DEBUG

                    keyCodeBuff[0] = KEY_AFTER_LONG_CODE + KEY0_CODE;
                    EventQueue_EnqueueWithData(&keyPressEvent, keyCodeBuff);
#endif

                    key0_TimeL = 0;
                }
            }
        break;
    }
}

// key真正的处理函数 --> 添加的代码：根据键值判断按键的状态
void keyScanEvent(void *data)
{
    uint8_t *keyCode = (uint8_t *)data;  // 通过指针传递进来按键值
    uint8_t key = *keyCode;

    switch(key){

        case (KEY0_CODE + KEY_SHORT_CODE):
            printf("key1 short press \r\n");
        break;

        case (KEY0_CODE + KEY_FIRST_LONG_CODE):
            printf("key1 long press \r\n");
        break;

        case (KEY0_CODE + KEY_AFTER_LONG_CODE):
            printf("key1 after long press \r\n");
        break;

        default:
            break;

    }
}

主函数里，只需扫描按键，以及读取事件队列中是否有事件发生

int main(void)
{
    //static int cnt = 0;
    volatile static event_t* event;
    board_init();

    while(1)
    {
        event = EventQueue_GetPendingEvent();
        if (event)
        {
            event->execute(event->data);
        }

        if(flag) // 10ms中断内，查询按键状态，用来消除按键抖动。
        {
            flag =0;
            keyScan();
        }
    }
 }