嵌入式软件开发：非阻塞按键读取_1

实现目标：

1. 能实现非阻塞按键读取，比方那个键按下了，保存键值。
2. 能保存4次按键的值，如果按键太快了，超过4次按键，则后面的按键值会丢失。当然这个4次，可以自己定义。
3. 不涉及到长按键等状态检测。

---

---

---

贴代码吧

App_KeyNonblock.c

#include "App_KeyNonblock.h"


#define KEY_RELEASE 1
#define KEY_PRESS   0




/**
 * \brief:按键状态值，用来保存按键上一次和当前的按键状态值，利用两者对比就可以知道按键是否被按下。
 */
char p_key0_status = 0xff;
char n_key0_status = 0xff;
char p_key1_status = 0xff;
char n_key1_status = 0xff;
char p_key2_status = 0xff;
char n_key2_status = 0xff;


void key_inBuff(char keyValue);

/**
 * \brief: 该函数在10ms定时中断中被调用。除掉按键抖动。
 *
 */
void keyScanIO(void)
{
    p_key0_status = n_key0_status;
    n_key0_status = KEY0_IN;
    p_key1_status = n_key1_status;
    n_key1_status = KEY1_IN;
    p_key2_status = n_key2_status;
    n_key2_status = KEY2_IN;

    if((p_key0_status != KEY_PRESS) && (n_key0_status == KEY_PRESS)){
        key_inBuff(KEY0_CODE);
    }

    if((p_key1_status != KEY_PRESS) && (n_key1_status == KEY_PRESS)){
        key_inBuff(KEY1_CODE);
    }

    if((p_key2_status != KEY_PRESS) && (n_key2_status == KEY_PRESS)){
        key_inBuff(KEY2_CODE);
    }
}



/**
 * 以下的代码很重要，实现按键的非阻塞功能。
**/
//#define KEYBUFFSIZE     4
static char keyBuff[KEYBUFFSIZE] = {0};
char key_indexW = 0;
char key_indexR = 0;
char key_count = 0;

// 进入临界区的宏定义，可以根据不同的平台进行添加。
#define DISABLE_INT()  xxx（添加具体的代码）
#define ENABLE_INT()   xxx (添加具体)

// 初始化函数：
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;
}

/**
 * \brief: 写buffer，将键值存入BUFFER中
 *
 */
void key_inBuff(char keyValue)
{
    if(key_count >= KEYBUFFSIZE)
        return;

    DISABLE_INT();

    key_count ++;
    keyBuff[key_indexW] = keyValue;

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

    ENABLE_INT();
}

/*** \brief: 读Buffer, 将键值从buffer中读出  */

char key_readBuff(void)
{
    char key =0;

    if(key_count == 0)
        return 0;

    DISABLE_INT();

    key_count --;

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

    ENABLE_INT();

    return key;
}

App_KeyNonblock.h

#ifndef _KEYNONBLOCK_H_
#define _KEYNONBLOCK_H_


#include "key.h"


#define     KEY0_IN     KEY0
#define     KEY1_IN     KEY1
#define     KEY2_IN     WK_UP

#define     KEY0_CODE   0x80
#define     KEY1_CODE   0x81
#define     KEY2_CODE   0x82


#define KEYBUFFSIZE     4



void keyScanIO(void);
char key_readBuff(void);
void key_paraInit(void);


#endif

主函数中，只需要去读取buffer的函数就可以了。
这个是基于STM32平台的测试。

#include "led.h"
#include "delay.h"
#include "sys.h"
#include "usart.h"
#include "App_KeyNonblock.h"



char keyValue = 0;
uint8_t flag = 0;



void SysTick_Init(void)
{
    if(SysTick_Config( SystemCoreClock / 100)) // 10ms
    {
        while(1);
    }

    SysTick->CTRL |= SysTick_CTRL_ENABLE_Msk;
}



void SysTick_Handler(void)
{
    flag = 1;
}



 int main(void)
 {
    char i =0;
    LED_Init();
    KEY_Init();
    SysTick_Init();
    uart_init(9600);
    NVIC_Configuration();

    key_paraInit();

    while(1)
    {
        if(flag) // 10ms timer interrupt
        {
            flag =0;
            keyScanIO();
        }


        keyValue= key_readBuff(); /* read key value from buffer. */
        if(keyValue != 0x00)
        {
            switch(keyValue)
            {
                case KEY0_CODE:
                    printf("key0 pressed now \r\n");
                break;

                case KEY1_CODE:
                    printf("key1 pressed now \r\n");
                break;

                case KEY2_CODE:
                    printf("key2 pressed now \r\n");
                break;

                default:
                    break;
            }
            keyValue = 0x00;
        }
    }
}

实现方法：

１.　构造了一个具有4BYTE的队列，当队列中保存的key值超过4个的时候，后面的数据将不会再保存到队列中，就等于将按键值丢失了。
２.　构造了两个类似于读和写的指针，这里只是类似于数组的下标，这里为什么不构造两个指针呢？？因为对于单片机，资源比较小的嵌入式芯片来说，指针操作相对来说需要消耗大量的内存空间。