学习FreeRTOS之中断管理_2

计数信号量

例12 演示了一个二值信号量被用于让任务和中断进行同步。整个执行流程可以描述为:

1. 中断产生。
2. 中断服务例程启动，给出信号量以使延迟处理任务解除阻塞。
3. 当中断服务例程退出时，延迟处理任务得到执行。延迟处理任务做的第一件事便是获取信号量。
4. 延迟处理任务完成中断事件处理后，试图再次获取信号量——如果此时信号量无效，任务将切入阻塞待等待事件发生。

在中断以相对较慢的频率发生的情况下，上面描述的流程是足够而完美的。如果在延迟处理任务完成上一个中断事件的处理之前，新的中断事件又发生了，等效于将新的事件锁存在二值信号量中，使得延迟处理任务在处理完上一个事件之后，立即就可以处理新的事件。也就是说，延迟处理任务在两次事件处理之间，不会有进入阻塞态的机会，因为信号量中锁存有一个事件，所以当xSempaphoreTake()调用时，信号量立即有效。这种情形将在下图中进行展现。
（这种情形：中断要优先完成，最多只锁存一个信号量，因为这是个二值信号量，要么是1，要么是0，不能增加为2，3......）

在下图中可以看到，一个二值信号量最多只可以锁存一个中断事件。在锁存的事件还未被处理之前，如果还有中断事件发生，那么后续发生的中断事件将会丢失。如果用计数信号量代替二值信号量，那么，这种丢中断的情形将可以避免。

就如同我们可以把二值信号量看作是只有一个数据单元的队列一样，计数信号量可以看作是深度大于1 的队列。任务其实对队列中存储的具体数据并不感兴趣——其只关心队列是空还是非空。

计数信号量每次被给出(Given)，其队列中的另一个空间将会被使用。队列中的有效数据单元个数就是信号量的”计数(Count)”值。

一个二值信号量最多只能锁存一个中断事件

使用计数信号量对事件 “计数(Count)”

计数信号量有以下两种典型用法：

1．事件计数

在这种用法中，每次事件发生时，中断服务例程都会“给出(Give)”信号量——信号量在每次被给出时其计数值加1。延迟处理任务每处理一个任务都会”获取(Take)”一次信号量——信号量在每次被获取时其计数值减1。信号量的计数值其实就是已发生事件的数目与已处理事件的数目之间的差值。这种机制可以参考上图。
用于事件计数的计数信号量，在被创建时其计数值被初始化为0。

2．资源管理

在这种用法中，信号量的计数值用于表示可用资源的数目。一个任务要获取资源的控制权，其必须先获得信号量——使信号量的计数值减1。当计数值减至0，则表示没有可用资源。当任务利用资源完成工作后，将给出(归还)信号量——使信号量的计数值加1。
用于资源管理的信号量，在创建时其计数值被初始化为可用资源总数。

函数介绍

xSemaphoreCreateCounting() API 函数
FreeRTOS 中所有种类的信号量句柄都由声明为xSemaphoreHandle 类型的变量保存。
信号量在使用前必须先被创建。使用xSemaphoreCreateCounting() API 函数来创建一个计数信号量。

函数原型：
xSemaphoreHandle xSemaphoreCreateCounting( unsigned portBASE_TYPE uxMaxCount, unsigned portBASE_TYPE uxInitialCount );

uxMaxCount 最大计数值。

如果把计数信号量类比于队列的话，uxMaxCount 值就是队列的最大深度。
当此信号量用于对事件计数或锁存事件的话，uxMaxCount 就是可锁存事件的最大数目。
当此信号量用于对一组资源的访问进行管理的话，uxMaxCount 应当设置为所有可用资源的总数。

uxInitialCount 信号量的初始计数值。

当此信号量用于事件计数的话，uxInitialCount 应当设置为0——因为当信号量被创建时，还没有事件发生。当此信号量用于资源管理的话， uxInitialCount 应当等于uxMaxCount——因为当信号量被创建时，所有的资源都是可用的。

返回值

如果返回NULL 值，表示堆上内存空间不足，所以FreeRTOS 无法为信号量结构分配内存导致信号量创建失败。
如果返回非NULL 值，则表示信号量创建成功。此值应当被保存起来作为这个的信号量的句柄。

例子13：
       例13 用计数信号量代替二值信号量对例12 的实现进行了改进。修改main()函数调用xSemaphoreCreateCounting()，以代替对xSemaphoreCreateBinary()的调用。

注意：
只有 configUSE_COUNTING_SEMAPHORES ==1 的时候，才使能可以使用xSemaphoreCreateCounting()函数，所以在FreeRTOS.h中设置

#ifndef configUSE_COUNTING_SEMAPHORES
    #define configUSE_COUNTING_SEMAPHORES    1      // 0 改为 1，使能函数
#endif

代码实现：

#include "led.h"
#include "key.h"
#include "exti.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"
#include "semphr.h"


/* declare a SemaphoreHandle_t variable, using to save queue handler. */
SemaphoreHandle_t xBinarySemaphore = NULL;

SemaphoreHandle_t xCountingSemaphore;


void board_Init(void)
{
    LED_Init();
    KEY_Init();
    //EXTIX_Init();
    uart_init(115200);

    // interrupt initialize
    //NVIC_Configuration();//
}


void keyScan_Task(void *pvParameters)
{
    char key = 0x00;
    int keycnt;

    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, cnt: %d \r\n", keycnt++);

                    //xSemaphoreGive(xBinarySemaphore);
                xSemaphoreGive(xCountingSemaphore);

                    printf("key pressed, give semaphore \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;
            }
        }

        vTaskDelay(10/portTICK_RATE_MS);
    }
}

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

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




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

    while(1)
    {
        //xSemaphoreTake(xBinarySemaphore, portMAX_DELAY);
        xSemaphoreTake(xCountingSemaphore, portMAX_DELAY);

        printf("take semaphore here \r\n");

        (state =!state) == 1 ? RED_ON() : RED_OFF();
    }
}



int main(void)
{
    // board initialize.
    board_Init();
    printf("board initialize finish. \r\n");

    // create binary semaphore
    //vSemaphoreCreateBinary(xBinarySemaphore);

    /* 创建计数信号量。这里为记录按键按下的次数，所以为计数信号量，设置最大计数值为10，初始计数值为0 */
    xCountingSemaphore = xSemaphoreCreateCounting(10, 0);

    if(xCountingSemaphore != NULL)
    {
        xTaskCreate(Key_HanderFun, "keyHandlerTask", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
        xTaskCreate(keyScan_Task, "keyScanTask", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
        xTaskCreate(LED_task, "LED_task", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
        //xSemaphoreTake(xBinarySemaphore, 0);

        // start scheduler now
        vTaskStartScheduler();
    }
    else
    {
        // semaphore create unsuccessful here. add your code.
        printf("semaphore create failed \r\n");
    }

    return 0;
}

再改进一下代码：
增加一个定时器，定时时间到，进入定时器中断程序，在中断程序里释放计数信号量。

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

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


/* declare a SemaphoreHandle_t variable, using to save queue handler. */
SemaphoreHandle_t xBinarySemaphore = NULL;

SemaphoreHandle_t xCountingSemaphore;


void board_Init(void)
{
    LED_Init();
    KEY_Init();
    //EXTIX_Init();
    uart_init(115200);
    TIM3_Int_Init(10,7200);// 10kHZ, 1ms interrupt.

    // interrupt initialize
    NVIC_Configuration();//
}


void keyScan_Task(void *pvParameters)
{
    char key = 0x00;
    int keyCnt =0;

    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, cnt: %d\r\n", ++keyCnt);

                    //xSemaphoreGive(xBinarySemaphore);

                    xSemaphoreGive(xCountingSemaphore);
                    printf("key pressed, give semaphore \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;
            }
        }

        vTaskDelay(10/portTICK_RATE_MS);
    }
}

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

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


void Key_HanderFun(void *pvParameters)
{
    //char state = 0;

    while(1)
    {
        //xSemaphoreTake(xBinarySemaphore, portMAX_DELAY);
        xSemaphoreTake(xCountingSemaphore, portMAX_DELAY);
        printf("take semaphore here \r\n");

        //(state =!state) == 1 ? RED_ON() : RED_OFF();
    }
}



int main(void)
{
    // board initialize.
    board_Init();
    printf("board initialize finish. \r\n");

    // create binary semaphore
    //vSemaphoreCreateBinary(xBinarySemaphore);

    /* ???????????????°?????¨??±????????¨??????????????????×??ó????????10??????????????0 */
    xCountingSemaphore = xSemaphoreCreateCounting(10, 0);

    if(xCountingSemaphore != NULL)
    {
        xTaskCreate(Key_HanderFun, "keyHandlerTask", configMINIMAL_STACK_SIZE, NULL, 2, NULL);
        xTaskCreate(keyScan_Task, "keyScanTask", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
        xTaskCreate(LED_task, "LED_task", configMINIMAL_STACK_SIZE, NULL, 1, NULL);
        //xSemaphoreTake(xBinarySemaphore, 0);

        // start scheduler now
        vTaskStartScheduler();
    }
    else
    {
        // semaphore create unsuccessful here. add your code.
        printf("semaphore create failed \r\n");
    }

    return 0;
}


void TIM3_IRQHandler(void) //TIM3 interrupt, 1ms
{
    static char state = 0;
    static int cnt = 0;
    static int sempCnt = 0;
    BaseType_t xHigherPriorityTaskWoken = pdFALSE;

    if (TIM_GetITStatus(TIM3, TIM_IT_Update) != RESET) //?ì?é???¨??TIM????·??ú??·?:TIM ??????
    {
        TIM_ClearITPendingBit(TIM3, TIM_IT_Update); //????TIMx???????????í??:TIM ??????

        if(++cnt >= 10)  // 10ms periodical interrupt here.
        {
            cnt = 0;

             // give counting semaphore here.
             xSemaphoreGiveFromISR(xCountingSemaphore, &xHigherPriorityTaskWoken);
             printf("give semaphore, sempCnt: %d \r\n", ++sempCnt);
            ((state = !state) == 1) ? RED_ON() : RED_OFF();
        }
    }
}


void EXTI0_IRQHandler(void)
{
    static BaseType_t xHigherPriorityTaskWoken;
    xHigherPriorityTaskWoken = pdFALSE;

    if(WK_UP == 1)
    {
        // Unblock the task by releasing the semaphore.
        xSemaphoreGiveFromISR(xBinarySemaphore, &xHigherPriorityTaskWoken);
        printf("key pressed, give semaphore \r\n");
    }
    EXTI_ClearITPendingBit(EXTI_Line0);
}

打印结果：非常快的打印频率。