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

在上一章节【嵌入式设计编程：事件及事件队列_3(对按键进行读取)】中，实现了利用事件队列的方式来实现按键状态的读取。
对于按键的抖动，利用10ms中断连续读取消抖，这里也可以利用前面讲的软件定时器来实现同样的功能，非常的方便。

想想，软件定时器如何实现？
（1）设定扫描时间，是否为周期性事件： #define KEY_SCAN_PERIOD_MS     10
（2）静态定义一个软件定时器，并初始化： static softtimer_t  keyScanTask_timer = TIMER_INIT;
（3）定义一个时间到的真正的处理函数： void keyScan(void *data)
（4）启动软件定时器： Timer_StartPeriodic(&keyScanTask_timer,  KEY_SCAN_PERIOD_MS,  keyScan);

---

---

---

列代码

#include "App_LongShortKey.h"
#include <stdio.h>
#include "Timer.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 *data)
{


    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;
    }
}


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;

    }
}


// 软件定时器相关的设置
#define KEY_SCAN_PERIOD_MS     10
static softtimer_t  keyScanTask_timer = TIMER_INIT;


void keyScanTask_init(void)
{
    /* 添加循环打印任务到 Software_timer 链表中 */
    // timer时间到的时候，通知事件发生。
    Timer_StartPeriodic(&keyScanTask_timer, KEY_SCAN_PERIOD_MS, keyScan);
    printf("software time initialize \n");
}

主函数里面

int main(void)
{
    //static int cnt = 0;
    volatile static event_t* event;
    board_init();
    keyScanTask_init(); // 启动软件定时器

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

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

同样实现检测效果。是不是很方便啊