FreeRTOS笔记之信号量

ChirsLu

已于 2024-01-29 21:11:11 修改

阅读量866

点赞数 16

分类专栏： FreeRTOS 文章标签： mcu 物联网单片机

于 2024-01-29 21:09:51 首次发布

本文链接：https://blog.csdn.net/m0_73804659/article/details/135917222

版权

FreeRTOS 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

FreeRTOS——信号量

文章目录

FreeRTOS——信号量
前言
一、信号量是什么？
二、二值信号量
三、计数型信号量
四、两种信号量的区别
五、常用的API函数
六、基于STM32，用两个按键进行测试
总结

前言

如果我们不需要传输数据信息而只是传递某种状态的话，我们可以选择使用“信号量（Semaphore）”。

举个通俗的例子吧：
1.想象一家餐厅有限的餐桌，每个餐桌只能容纳一个顾客或家庭。这里的每个餐桌就像一个信号量。当顾客进入餐厅时，他们会尝试获取一个餐桌（获取信号量）。如果所有餐桌都被占用（信号量不可用），他们就需要等待，直到有人用餐完毕离开（释放信号量），这样新的顾客才能使用餐桌。
2.公共卫生间每个厕所位看作一个信号量，当有人要使用时就得检查有没有空闲的位置？如果被占用了那就只能排队等待，当有人用完离开后，等待的人才能使用。

稍微专业一点的表述：
生产者和消费者的关系，生产者负责生产资源（产生信号量，也叫释放信号量）；消费者需要拿走资源（获取信号量）。这时候如果生产者没有提供信号量，此时消费者要么等待（阻塞），要么不等直接走了。生产者生产一个资源，意思就是信号量数值增加1，消费者拿走一个资源，意思就是信号量数值减少1。

一、信号量是什么？

信号量（Semaphore），用来保证两个或多个关键代码段不被并发使用，用于传递一个状态。其中，信号表示起到通知的作用，量表示资源的数量。
按照这个概念我们可以将信号量分为”二值信号量“和”计数型信号量“，它们具体是什么意思？怎么用呢？下面让我们来逐一击破！

二、二值信号量

二值信号量又称作二进制信号量，它的计数值只有0和1，也就是对于某个资源来说只存在被占用和空闲中（允许任务来占用它）两个状态。
如果已经有一个生产者生产了一个信号量，这时信号量的计数值为1，那么这时候如果没有消费者拿走这个信号量使它数值减1的话，别的生产者也不能生产这个信号量。
反过来也是一样的。

这个就像一间单间厕所，当没有人占用时它是空闲的，此时计数值为1，表示可以被占用；当有人进去后它被占用，计数值为0，别人也进不去了。
在这里插入图片描述

三、计数型信号量

它的计数值没有限定，生产者生产一个信号量时它的计数值加1，可以一直叠加；消费者拿走一个信号量时它的计数值减1，一直减到0为止。

这个就像早餐店的包子，店家可以提供很多个包子，每做出来一个包子现有库存（计数值）加1，可以一直生产；当有顾客买走包子，每买走一个包子现有库存减1，当把包子都买光后计数值为0，此时表示没有包子了。

四、两种信号量的区别

1.最大的区别就是它们计数值的上限不同，二值信号量的计数值只能为0和1，而计数型信号量的计数值可以是任意的。
2.还有一个小区别是，当二值信号量被创建时，它的计数值初始值为0，必须要生产者先生产后才能用；而计数型信号量被创建时，它的计数值初始值是自定义的。

五、常用的API函数

1.创建二值信号量（动态）

SemaphoreHandle_t xSemaphoreCreateBinary( void );

2.创建二值信号量（静态）

SemaphoreHandle_t xSemaphoreCreateBinaryStatic( StaticSemaphore_t *pxSemaphoreBuffer );

3.创建计数型信号量（动态）

SemaphoreHandle_t xSemaphoreCreateCounting(UBaseType_t uxMaxCount, UBaseType_t uxInitialCount);

4.创建计数型信号量（静态）

SemaphoreHandle_t xSemaphoreCreateCountingStatic( UBaseType_t        uxMaxCount, 
                                                  UBaseType_t        uxInitialCount, 
                                                  StaticSemaphore_t* pxSemaphoreBuffer );

5.删除信号量（通用）

void vSemaphoreDelete( SemaphoreHandle_t xSemaphore );

6.Give 生产信号量（通用）

任务中：

BaseType_t xSemaphoreGive( SemaphoreHandle_t xSemaphore );

中断中：

BaseType_t xSemaphoreGiveFromISR(
                        SemaphoreHandle_t xSemaphore,
                        BaseType_t*       pxHigherPriorityTaskWoken
                    );

7.Take 拿走信号量（通用）

任务中：

BaseType_t xSemaphoreTake(
                   SemaphoreHandle_t xSemaphore,
                   TickType_t        xTicksToWait
               );

中断中：

BaseType_t xSemaphoreTakeFromISR(
                        SemaphoreHandle_t xSemaphore,
                        BaseType_t *pxHigherPriorityTaskWoken
                    );

8.二值信号量的Give和Take的基本用法（一个简单框架来演示一下give和take的操作而已）

SemaphoreHandle_t xSemaphore = NULL;

void TaskA(void *pvParameters) {
    /* 任务 A 的工作内容
       进行某些功能的实现
       完成工作后，释放信号量（因为二值信号量初始值为0，
       除非有人先进行Give操作，否则谁也用不了它）*/
    xSemaphoreGive(xSemaphore);

    /*
       此后，任务 A 可以继续执行其他工作或者结束
     ...*/
}

void TaskB(void *pvParameters) {
    /*等待信号量*/
    if(xSemaphoreTake(xSemaphore, portMAX_DELAY) == pdTRUE) {
        /* 一旦获取到信号量，开始执行任务 B 的工作
           ...*/
    }
}

int main(void) {
    /* 创建信号量*/
    xSemaphore = xSemaphoreCreateBinary();

    /* 创建任务 A 和任务 B*/
    xTaskCreate(TaskA, "Task A", 1000, NULL, 1, NULL);
    xTaskCreate(TaskB, "Task B", 1000, NULL, 1, NULL);

    /* 启动调度器*/
    vTaskStartScheduler();

    for( ;; );
}

9.计数型信号量的Give和Take的基本用法

/*计数型信号量的句柄*/
SemaphoreHandle_t xCountingSemaphore;

void TaskA(void *pvParameters) {
    /*TaskA 用于增加信号量的计数*/
    while(1) {
        /* 给出信号量，增加计数*/
        xSemaphoreGive(xCountingSemaphore);

        /* 做一些其他的工作...*/
        vTaskDelay(1000 / portTICK_PERIOD_MS); // 假设的工作延时
    }
}

void TaskB(void *pvParameters) {
    /* TaskB 用于等待信号量*/
    while(1) {
        if(xSemaphoreTake(xCountingSemaphore, portMAX_DELAY) == pdTRUE) {
            /* 成功获取信号量，计数减一*/

            /* 执行一些需要信号量的工作...*/
        }
    }
}

int main(void) {
    // 创建计数型信号量，初始计数为 0，最大计数为 5
    xCountingSemaphore = xSemaphoreCreateCounting(5, 0);

    // 创建任务
    xTaskCreate(TaskA, "Task A", 1000, NULL, 1, NULL);
    xTaskCreate(TaskB, "Task B", 1000, NULL, 1, NULL);

    // 启动调度器
    vTaskStartScheduler();

    for( ;; );
}

六、基于STM32，用两个按键进行测试

1.二值信号量

#include "stm32f10x.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "stdio.h"

SemaphoreHandle_t xBinarySemaphore;

void KeyScanTask(void *pvParameters) {
    while(1) {
        // 检测 Key1，如果按下
        if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2) == RESET) {
            // 防抖动延时
            vTaskDelay(20 / portTICK_PERIOD_MS);
            if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2) == RESET) {
                // 尝试给出信号量
                if(xSemaphoreGive(xBinarySemaphore) == pdPASS) {
                    printf("Key1 pressed, semaphore given.\n");
                } else {
                    printf("Key1 pressed, but semaphore give failed.\n");
                }

                // 等待释放按键
                while(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2) == RESET);
            }
        }

        // 检测 Key2，如果按下
        if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_3) == RESET) {
            // 防抖动延时
            vTaskDelay(20 / portTICK_PERIOD_MS);
            if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_3) == RESET) {
                // 尝试获取信号量
                if(xSemaphoreTake(xBinarySemaphore, 0) == pdPASS) {
                    printf("Key2 pressed, semaphore taken.\n");
                } else {
                    printf("Key2 pressed, but semaphore take failed.\n");
                }

                // 等待释放按键
                while(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_3) == RESET);
            }
        }

        // 轮询延时
        vTaskDelay(10 / portTICK_PERIOD_MS);
    }
}

int main(void) {
    // ... GPIO 初始化代码（省略）

    // 创建二值信号量
    xBinarySemaphore = xSemaphoreCreateBinary();

    // 创建按键扫描任务
    xTaskCreate(KeyScanTask, "KeyScanTask", 1000, NULL, 1, NULL);

    // 启动调度器
    vTaskStartScheduler();

    for( ;; );
}

2.计数型信号量：

#include "stm32f10x.h"
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
#include "stdio.h"

SemaphoreHandle_t xCountingSemaphore;

void KeyScanTask(void *pvParameters) {
    while(1) {
        // 检测 Key1，如果按下
        if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2) == RESET) {
            // 防抖动延时
            vTaskDelay(20 / portTICK_PERIOD_MS);
            if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2) == RESET) {
                // 尝试给出信号量
                if(xSemaphoreGive(xCountingSemaphore) == pdPASS) {
                    printf("Key1 pressed, semaphore given.\n");
                } else {
                    printf("Key1 pressed, but semaphore give failed.\n");
                }

                // 等待释放按键
                while(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_2) == RESET);
            }
        }

        // 检测 Key2，如果按下
        if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_3) == RESET) {
            // 防抖动延时
            vTaskDelay(20 / portTICK_PERIOD_MS);
            if(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_3) == RESET) {
                // 尝试获取信号量
                if(xSemaphoreTake(xCountingSemaphore, 0) == pdPASS) {
                    printf("Key2 pressed, semaphore taken.\n");
                } else {
                    printf("Key2 pressed, but semaphore take failed.\n");
                }

                // 等待释放按键
                while(GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_3) == RESET);
            }
        }

        // 轮询延时
        vTaskDelay(10 / portTICK_PERIOD_MS);
    }
}

int main(void) {
    // ... GPIO 初始化代码（省略）

    // 创建计数型信号量，初始计数为 0，最大计数为 5
    xCountingSemaphore = xSemaphoreCreateCounting(5, 0);

    // 创建按键扫描任务
    xTaskCreate(KeyScanTask, "KeyScanTask", 1000, NULL, 1, NULL);

    // 启动调度器
    vTaskStartScheduler();

    for( ;; );
}