学习FreeRTOS之队列管理_3

这一篇主要讲一个例子吧。

硬件：
1. stm32f103 开发板
2. 有一个按键，一个LED灯。

功能：
1. 按键检测：

可以检测按键按下的状态：短按，长按，并保存键值。
短按键值： 0x01
第一次长按键值： 0x02
后面的长按键值： 0x03

2. LED

LED任务实现LED闪烁，1s时间间隔。

功能实现：

1. 建立一个LED任务，实现LED每1s闪烁一次的功能；
2. 建立一个KEY扫描的任务，每10ms轮询一次，去按键抖动功能；并且检测是否有按键按下，是短按还是长按状态，并把按键值写入到定义的队列当中；
3. 建立一个读取队列的任务，这个任务的优先级大于按键扫描任务。所以队列中最多只有一个数据，当读取完队列数据（也就是按键值），该任务进入阻塞态；KEY扫描任务得到运行，检测是否有按键按下；如果有按键按下，则写键值到队列中；一旦写入，将唤醒读队列任务，打印读取到的键值。LED任务和按键扫描任务为相同的优先级，在读取队列任务进入阻塞态的时候，两者分享时间片，轮询执行。

关键代码：
main.c

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

// FreeRTOS head file, add here.
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "list.h"
#include "portable.h"
#include "FreeRTOSConfig.h"


/* declare a queueHandle variable, using to save queue handler. */
xQueueHandle xQueue;


void vReceiveTask(void *pvParameters)
{
    char key ;

    portBASE_TYPE status;

    while(1)
    {
        if( uxQueueMessagesWaiting( xQueue ) != 0 )
        {
           /* 由于读取队列的优先级最高，则导致queue队列一直为空，使得这句话不会执行。 */
            printf( "Queue should have been empty! \r\n");
        }

        /* 1. 设置成 100/portTICK_RATE_MS，表示超时等待时间，当超过这个时间还没有数据到来，任务同样返回，从阻塞态转变为就绪态。*/
        //status = xQueueReceive( xQueue, &key, 100 / portTICK_RATE_MS );

        /**
         * \brief: 2. 设置成portMAX_DELAY将永久等待，直到queue有数据可以读取。
         */
        status = xQueueReceive( xQueue, &key, portMAX_DELAY );
        if( status == pdPASS )
        {
            printf("Queue received Key pressed msg, key value: %d \r\n", key);
        }
        else
        {
            printf( "Could not receive from the queue.\r\n" );
        }
    }
}

void board_Init(void)
{
    LED_Init();
    KEY_Init();
    uart_init(115200);
}


void keyScan_Task(void *pvParameters)
{
    char key = 0x00;
    portBASE_TYPE status;

    while(1)
    {
        // add your key scan code here.
        keyScan();
        if((key = keyScan_readBuff()) != 0)
        {
            switch(key)
            {
                case ( KEY_CODE + SHORT_KEY):
                    printf("short key pressed \r\n");
                break;

                case ( KEY_CODE+FIRSTLONG_KEY_CODE):
                    printf("long first pressed \r\n");
                break;

                case ( KEY_CODE+AFTERLONG_KEY_CODE):
                    printf("long after pressed \r\n");
                break;
            }

            status = xQueueSendToBack(xQueue, &key, 0);
            if(status != pdPASS)
            {
                printf("could not send to the queue. \r\n");
            }
        }

        vTaskDelay(10/portTICK_RATE_MS);
    }
}

void LED_task(void *pvParameters)
{
    char state = 0;

    while(1)
    {
        ((state = !state) == 1) ? RED_ON() : RED_OFF();
        vTaskDelay(1000 / portTICK_RATE_MS);
    }
}



int main(void)
{
    // board initialize.
    board_Init();

    // create queue, can store 3 value which data type is data_type
    xQueue = xQueueCreate(3, sizeof(char));

    if(xQueue != NULL) // adjust the return value, to confirm whether create queue successful.
    {
        xTaskCreate(vReceiveTask, "RecTask", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
        xTaskCreate(keyScan_Task, "KeyScanTask", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
        xTaskCreate(LED_task, "LEDTask", configMINIMAL_STACK_SIZE, NULL, 1, NULL);

        // start scheduler now
        vTaskStartScheduler();
    }
    else
    {
        // queue create unsuccessful here. add your code.
    }

    return 0;
}

key.c

#include "key.h"


#define KEYBUFFSIZE 4
char keybuff[KEYBUFFSIZE] = {0};
char key_indexW = 0;
char key_indexR = 0;
char length = 0;
static uint32_t keyCounterL = 0, keyCounterS = 0;
char keyState = 0;

#define KEY_IN() KEY0




extern void vPortEnterCritical( void );
extern void vPortExitCritical( void );



void keyScan_writeBuff(char keyValue)
{
    if(length >= KEYBUFFSIZE )
        return;

    vPortEnterCritical();

    length ++;
    keybuff[key_indexW] = keyValue;
    if(++key_indexW >= KEYBUFFSIZE)
        key_indexW = 0;

    vPortExitCritical();
}


char keyScan_readBuff(void)
{
    char key;
    if(length == 0) return 0;

    vPortEnterCritical();

    length --;
    key = keybuff[key_indexR];
    if(++key_indexR >= KEYBUFFSIZE)
        key_indexR = 0;

    vPortExitCritical();

    return key;
}


void keyScan(void)
{
    // scan key and write key code to buffer.
    if(keyState == LONG_KEY)
        keyCounterL++;
    else
        keyCounterL =0;

    if(keyState == SHORT_KEY)
        keyCounterS++;
    else
        keyCounterS =0;


    switch(keyState)
    {
        case NO_KEY:
            if(KEY_IN() == 0) keyState = SHORT_KEY;
            else keyState = NO_KEY;
        break;

        case SHORT_KEY:
            if(KEY_IN() != 0) // release key, short key
            {
                keyScan_writeBuff(KEY_CODE + SHORT_KEY_CODE);
                keyState = NO_KEY;
            }
            else
            {
                if(keyCounterS >= 2000/10)
                {
                    keyCounterS = 0;
                    keyScan_writeBuff(KEY_CODE + FIRSTLONG_KEY_CODE);
                    keyState = LONG_KEY;
                }
            }
        break;

        case LONG_KEY:
            if(KEY_IN() != 0) // release key, short key
            {
                keyState = NO_KEY;
            }
            else
            {
                if(keyCounterL >= 250/10)
                {
                    keyCounterL = 0;
                    keyScan_writeBuff(KEY_CODE + AFTERLONG_KEY_CODE);
                }
            }
        break;
    }
}



void KEY_Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;

     RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA|RCC_APB2Periph_GPIOC,ENABLE);//????PORTA,PORTC?±??

    GPIO_PinRemapConfig(GPIO_Remap_SWJ_JTAGDisable, ENABLE);//??±?jtag??????SWD????????SWD?????÷??

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_15;//PA15
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //?è????????????
     GPIO_Init(GPIOA, &GPIO_InitStructure);//??????GPIOA15

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;//PC5
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPU; //?è????????????
     GPIO_Init(GPIOC, &GPIO_InitStructure);//??????GPIOC5

    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0;//PA0
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IPD; //PA0?è??????????????????
    GPIO_Init(GPIOA, &GPIO_InitStructure);//??????GPIOA.0
}

key.h

#ifndef __KEY_H
#define __KEY_H


#include "sys.h"

#define KEY0    GPIO_ReadInputDataBit(GPIOC,GPIO_Pin_5)

#define NO_KEY          0
#define SHORT_KEY       1
#define LONG_KEY        2

#define KEY_CODE (unsigned char)0x00
#define SHORT_KEY_CODE (unsigned char)0x01
#define FIRSTLONG_KEY_CODE (unsigned char)0x02
#define AFTERLONG_KEY_CODE (unsigned char)0x03


void KEY_Init(void);
void keyScan(void);
char keyScan_readBuff(void);



#endif

打印结果：
短按，长按结果，板子上LED也开始闪烁。