21ic电子技术开发论坛 › 单片机与嵌入式系统 › 嵌入式操作系统论坛 › 【每周分享】FreeRTOS信号量详讲（代码+介绍） ...
返回列表 发新帖我要提问本帖赏金: 80.00元(功能说明)

[uCOS/RTOS] 【每周分享】FreeRTOS信号量详讲（代码+介绍）

[复制链接]
7320|3
 楼主| 虚幻的是灵魂 发表于 2024-10-19 17:03 | 显示全部楼层 |阅读模式
FreeRTO, RTOS, freeRTOS, Free RTOS, freertos系统
本帖最后由 虚幻的是灵魂 于 2024-10-19 17:11 编辑

#申请原创#  @21小跑堂
概念
在 FreeRTOS中，信号量（Semaphore）是一种用于实现任务之间同步和资源共享的机制。它是一种计数型的同步原语，用于控制对共享资源的访问和保护。
在FreeRTOS中，包含4种类型的信号量：

1. 二进制信号量（Binary Semaphore）：

二进制信号量是最基本的信号量类型。它的计数值要么为0（表示信号量已被获取），要么为1（表示信号量可用）。二进制信号量常用于实现互斥访问共享资源的场景，只允许一个任务访问资源。

在 FreeRTOS 中，你可以使用 xSemaphoreCreateBinary() 函数创建一个二进制信号量。任务可以通过 xSemaphoreTake() 函数获取信号量，通过 xSemaphoreGive() 函数释放信号量。

2. 计数型信号量（Counting Semaphore）：

计数型信号量允许指定初始计数值，并支持多个任务同时获取信号量。计数型信号量的计数值表示可用的资源数量。

在 FreeRTOS 中，你可以使用 xSemaphoreCreateCounting() 函数创建一个计数型信号量。任务可以使用 xSemaphoreTake() 函数获取信号量，使用 xSemaphoreGive() 函数释放信号量。

3. 互斥信号量（Mutex Semaphore）：

互斥信号量也用于实现资源的互斥访问，类似于二进制信号量。但与二进制信号量不同的是，互斥信号量允许同一个任务多次获取信号量，而不会导致死锁。在任务持有互斥信号量时，其他任务无法获取该信号量，必须等待该任务释放信号量。

在 FreeRTOS 中，你可以使用 xSemaphoreCreateMutex() 函数创建一个互斥信号量。任务可以使用 xSemaphoreTake()函数获取信号量，使用 xSemaphoreGive() 函数释放信号量。

4. 递归互斥信号量（Recursive Mutex Semaphore）：

递归互斥信号量是一种特殊的信号量类型，用于解决任务在嵌套调用中对资源的重复获取。它允许同一个任务多次获取信号量而不会导致死锁。

在 FreeRTOS 中，你可以使用 xSemaphoreCreateRecursiveMutex() 函数创建一个递归互斥信号量。任务可以使用 xSemaphoreTakeRecursive() 函数多次获取信号量，并使用 xSemaphoreGiveRecursive() 函数相应地释放信号量。

开发流程
  • 创建信号量
  • 开启一个任务，用来等待信号量
  • 开启一个任务，用来发送信号量



二进制信号量
功能 描述
xSemaphoreCreateBinary 创建二进制信号量
xSemaphoreTake 等待信号
xSemaphoreGive 发送信号


信号量的创建

二进制信号量创建语法

SemaphoreHandle_t xSemaphoreCreateBinary();

返回值为信号量的句柄。


等待信号操作

BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xBlockTime );

1、SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。

2、TickType_t xBlockTime表示要等待的时间。通常我们一直等到有信号到来，这里我们可以填写portMAX_DELAY

3、返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL


发送信号操作

BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);
  • SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。
  • 返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL

案例一
  • 开启两个任务，分别去等待信号。
  • 开启按键扫描任务，当点击按键时，发送信号

main.c
复制
  1. #include "gd32f4xx.h"
    

  2. #include "systick.h"
    

  3. #include <stdio.h>
    

  4. #include "main.h"
    

  5. #include "FreeRTOS.h"
    

  6. #include "task.h"
    

  7. #include "semphr.h"
    

  8. #include "Usart0.h"
    

  9.  
    

  10. TaskHandle_t            task_handler;
    

  11. TaskHandle_t            task_key_handler;
    

  12. TaskHandle_t            task1_handler;
    

  13. TaskHandle_t            task2_handler;
    

  14. SemaphoreHandle_t                         sema_handler;
    

  15.  
    

  16. void task1(void *pvParameters) {
    

  17.     BaseType_t result;
    

  18.     while(1) {
    

  19.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  20.         if(result == pdTRUE) {
    

  21.             printf("task1\n");
    

  22.         } else {
    

  23.             printf("task1 Error\n");
    

  24.         }
    

  25.     }
    

  26. }
    

  27.  
    

  28. void task2(void *pvParameters) {
    

  29.     BaseType_t result;
    

  30.     while(1) {
    

  31.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  32.         if(result == pdTRUE) {
    

  33.             printf("task2\n");
    

  34.         } else {
    

  35.             printf("task2 Error\n");
    

  36.         }
    

  37.     }
    

  38. }
    

  39.  
    

  40. void task_key(void *pvParameters) {
    

  41.     FlagStatus pre_state = RESET;
    

  42.     BaseType_t result;
    

  43.     while(1) {
    

  44.         FlagStatus state = gpio_input_bit_get(GPIOA, GPIO_PIN_0);
    

  45.         if(SET == state && pre_state == RESET) {
    

  46.             // 当前高电平, 上一次为低电平,按下
    

  47.             pre_state = state;
    

  48.  
    

  49.             result = xSemaphoreGive(sema_handler);
    

  50.         } else if(RESET == state && pre_state == SET) {
    

  51.             // 当前高电平, 上一次为低电平,抬起
    

  52.             pre_state = state;
    

  53.         }
    

  54.         vTaskDelay(20);
    

  55.     }
    

  56. }
    

  57.  
    

  58. void start_task(void *pvParameters) {
    

  59.     taskENTER_CRITICAL();
    

  60.  
    

  61.     xTaskCreate(task_key, "task_key", 64, NULL, 2, &task_key_handler);
    

  62.     xTaskCreate(task1, "task1", 64, NULL, 3, &task1_handler);
    

  63.     xTaskCreate(task2, "task2", 64, NULL, 2, &task2_handler);
    

  64.     vTaskDelete(task_handler);
    

  65.  
    

  66.     taskEXIT_CRITICAL();
    

  67. }
    

  68.  
    

  69. void Usart0_recv(uint8_t *data, uint32_t len)
    

  70. {
    

  71.     printf("recv: %s\n", data);
    

  72. }
    

  73.  
    

  74. static void GPIO_config() {
    

  75.     // 时钟初始化
    

  76.     rcu_periph_clock_enable(RCU_GPIOA);
    

  77.     // 配置GPIO模式
    

  78.     gpio_mode_set(GPIOA, GPIO_MODE_INPUT, GPIO_PUPD_PULLDOWN, GPIO_PIN_0);
    

  79. }
    

  80.  
    

  81. int main(void)
    

  82. {
    

  83.     NVIC_SetPriorityGrouping(NVIC_PRIGROUP_PRE4_SUB0);
    

  84.     systick_config();
    

  85.     GPIO_config();
    

  86.     Usart0_init();
    

  87.  
    

  88.     sema_handler = xSemaphoreCreateBinary();
    

  89.     xTaskCreate(start_task, "start_task", 128, NULL, 1, &task_handler);
    

  90.     vTaskStartScheduler();
    

  91.  
    

  92.     while(1) {}
    

  93. }

观察，两个任务是否获得信号。

改变两个任务的优先级，观察两个任务信号的获取情况。

案例二

在案例1的基础上，通过串口接收，来发送信号。

串口发送信号

复制
  1. void Usart0_recv(uint8_t *data, uint32_t len)
    

  2. {
    

  3.     printf("recv: %s\n", data);
    

  4.     xSemaphoreGiveFromISR(sema_handler, NULL);
    

  5. }

xSemaphoreGiveFromISR中断中发送信号



计数型信号量
功能 描述
xSemaphoreCreateCounting 创建计数型信号量
xSemaphoreTake 等待信号
xSemaphoreGive 发送信号


信号量的创建
复制
  1. SemaphoreHandle_t xSemaphoreCreateCounting(        const UBaseType_t uxMaxCount,
    

  2.                                                 const UBaseType_t uxInitialCount);
参数说明:


  • const UBaseType_t uxMaxCount最大计数值。
  • const UBaseType_t uxInitialCount初始化当前计数值。

返回值为信号量的句柄。


等待信号操作

BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xBlockTime );

1、SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。

2、TickType_t xBlockTime表示要等待的时间。通常我们一直等到有信号到来，这里我们可以填写portMAX_DELAY

3、返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL


发送信号操作

BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);
  • SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。
  • 返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL

案例一
  • 开启两个任务，等待信号，接收到信号后，处理耗时操作
  • 开启按键扫描，点击按键时发送信号

main.c
复制
  1. #include "gd32f4xx.h"
    

  2. #include "systick.h"
    

  3. #include <stdio.h>
    

  4. #include "main.h"
    

  5. #include "FreeRTOS.h"
    

  6. #include "task.h"
    

  7. #include "semphr.h"
    

  8. #include "Usart0.h"
    

  9.  
    

  10. TaskHandle_t            task_handler;
    

  11. TaskHandle_t            task_key_handler;
    

  12. TaskHandle_t            task1_handler;
    

  13. TaskHandle_t            task2_handler;
    

  14. SemaphoreHandle_t                 sema_handler;
    

  15.  
    

  16. void task1(void *pvParameters) {
    

  17.     BaseType_t result;
    

  18.     while(1) {
    

  19.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  20.         if(result == pdTRUE) {
    

  21.             printf("task1 %ld\n", uxSemaphoreGetCount(sema_handler));
    

  22.         } else {
    

  23.             printf("task1 Error\n");
    

  24.         }
    

  25.         vTaskDelay(2500);
    

  26.     }
    

  27. }
    

  28.  
    

  29. void task2(void *pvParameters) {
    

  30.     BaseType_t result;
    

  31.     while(1) {
    

  32.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  33.         if(result == pdTRUE) {
    

  34.             printf("task2 %ld\n", uxSemaphoreGetCount(sema_handler));
    

  35.         } else {
    

  36.             printf("task2 Error\n");
    

  37.         }
    

  38.         vTaskDelay(2500);
    

  39.     }
    

  40. }
    

  41.  
    

  42. void task_key(void *pvParameters) {
    

  43.     FlagStatus pre_state = RESET;
    

  44.     BaseType_t result;
    

  45.     while(1) {
    

  46.         FlagStatus state = gpio_input_bit_get(GPIOA, GPIO_PIN_0);
    

  47.         if(SET == state && pre_state == RESET) {
    

  48.             // 当前高电平, 上一次为低电平,按下
    

  49.             pre_state = state;
    

  50.  
    

  51.             result = xSemaphoreGive(sema_handler);
    

  52. //                        if(result == pdTRUE) {
    

  53. //                                printf("semaphore give success\n");
    

  54. //                        } else {
    

  55. //                                printf("semaphore give error\n");
    

  56. //                        }
    

  57.         } else if(RESET == state && pre_state == SET) {
    

  58.             // 当前高电平, 上一次为低电平,抬起
    

  59.             pre_state = state;
    

  60.         }
    

  61.         vTaskDelay(20);
    

  62.     }
    

  63. }
    

  64.  
    

  65. void start_task(void *pvParameters) {
    

  66.     taskENTER_CRITICAL();
    

  67.  
    

  68.     xTaskCreate(task_key, "task_key", 64, NULL, 2, &task_key_handler);
    

  69.     xTaskCreate(task1, "task1", 64, NULL, 3, &task1_handler);
    

  70.     xTaskCreate(task2, "task2", 64, NULL, 2, &task2_handler);
    

  71.     vTaskDelete(task_handler);
    

  72.  
    

  73.     taskEXIT_CRITICAL();
    

  74. }
    

  75.  
    

  76. void Usart0_recv(uint8_t *data, uint32_t len)
    

  77. {
    

  78.     printf("recv: %s\n", data);
    

  79. }
    

  80.  
    

  81. static void GPIO_config() {
    

  82.     // 时钟初始化
    

  83.     rcu_periph_clock_enable(RCU_GPIOA);
    

  84.     // 配置GPIO模式
    

  85.     gpio_mode_set(GPIOA, GPIO_MODE_INPUT, GPIO_PUPD_PULLDOWN, GPIO_PIN_0);
    

  86. }
    

  87.  
    

  88. int main(void)
    

  89. {
    

  90.     NVIC_SetPriorityGrouping(NVIC_PRIGROUP_PRE4_SUB0);
    

  91.     systick_config();
    

  92.     GPIO_config();
    

  93.     Usart0_init();
    

  94.  
    

  95.     sema_handler = xSemaphoreCreateCounting(100, 0);
    

  96.     xTaskCreate(start_task, "start_task", 128, NULL, 1, &task_handler);
    

  97.     vTaskStartScheduler();
    

  98.  
    

  99.     while(1) {}
    

  100. }

观察，两个任务是否获得信号。

频繁点击按键，观察效果。

案例二

在案例一的基础上，通过串口接收，来发送信号。

串口发送信号

复制
  1. void Usart0_recv(uint8_t *data, uint32_t len)
    

  2. {
    

  3.     printf("recv: %s\n", data);
    

  4.     xSemaphoreGiveFromISR(sema_handler, NULL);
    

  5. }

xSemaphoreGiveFromISR中断中发送信号





互斥信号量
功能 描述
xSemaphoreCreateMutex 创建互斥信号量
xSemaphoreTake 等待信号
xSemaphoreGive 发送信号

信号量的创建

互斥信号量创建语法

SemaphoreHandle_t xSemaphoreCreateMutex();

返回值为信号量的句柄。

等待信号操作

BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xBlockTime );

1、SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。

2、TickType_t xBlockTime表示要等待的时间。通常我们一直等到有信号到来，这里我们可以填写portMAX_DELAY

3、返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL


发送信号操作

BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);
  • SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。
  • 返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL

案例一
  • 开启两个任务，分别去等待信号。
  • 开启按键扫描任务，当点击按键时，发送信号

main.c
复制
  1. #include "gd32f4xx.h"
    

  2. #include "systick.h"
    

  3. #include <stdio.h>
    

  4. #include "main.h"
    

  5. #include "FreeRTOS.h"
    

  6. #include "task.h"
    

  7. #include "semphr.h"
    

  8. #include "Usart0.h"
    

  9.  
    

  10. TaskHandle_t            task_handler;
    

  11. TaskHandle_t            task_key_handler;
    

  12. TaskHandle_t            task1_handler;
    

  13. TaskHandle_t            task2_handler;
    

  14. SemaphoreHandle_t                         sema_handler;
    

  15.  
    

  16. void task1(void *pvParameters) {
    

  17.     BaseType_t result;
    

  18.     while(1) {
    

  19.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  20.         if(result == pdTRUE) {
    

  21.             printf("task1\n");
    

  22.         } else {
    

  23.             printf("task1 Error\n");
    

  24.         }
    

  25.     }
    

  26. }
    

  27.  
    

  28. void task2(void *pvParameters) {
    

  29.     BaseType_t result;
    

  30.     while(1) {
    

  31.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  32.         if(result == pdTRUE) {
    

  33.             printf("task2\n");
    

  34.         } else {
    

  35.             printf("task2 Error\n");
    

  36.         }
    

  37.     }
    

  38. }
    

  39.  
    

  40. void task_key(void *pvParameters) {
    

  41.     FlagStatus pre_state = RESET;
    

  42.     BaseType_t result;
    

  43.     while(1) {
    

  44.         FlagStatus state = gpio_input_bit_get(GPIOA, GPIO_PIN_0);
    

  45.         if(SET == state && pre_state == RESET) {
    

  46.             // 当前高电平, 上一次为低电平,按下
    

  47.             pre_state = state;
    

  48.  
    

  49.             result = xSemaphoreGive(sema_handler);
    

  50.         } else if(RESET == state && pre_state == SET) {
    

  51.             // 当前高电平, 上一次为低电平,抬起
    

  52.             pre_state = state;
    

  53.         }
    

  54.         vTaskDelay(20);
    

  55.     }
    

  56. }
    

  57.  
    

  58. void start_task(void *pvParameters) {
    

  59.     taskENTER_CRITICAL();
    

  60.  
    

  61.     xTaskCreate(task_key, "task_key", 64, NULL, 2, &task_key_handler);
    

  62.     xTaskCreate(task1, "task1", 64, NULL, 3, &task1_handler);
    

  63.     xTaskCreate(task2, "task2", 64, NULL, 2, &task2_handler);
    

  64.     vTaskDelete(task_handler);
    

  65.  
    

  66.     taskEXIT_CRITICAL();
    

  67. }
    

  68.  
    

  69. void Usart0_recv(uint8_t *data, uint32_t len)
    

  70. {
    

  71.     printf("recv: %s\n", data);
    

  72. }
    

  73.  
    

  74. static void GPIO_config() {
    

  75.     // 时钟初始化
    

  76.     rcu_periph_clock_enable(RCU_GPIOA);
    

  77.     // 配置GPIO模式
    

  78.     gpio_mode_set(GPIOA, GPIO_MODE_INPUT, GPIO_PUPD_PULLDOWN, GPIO_PIN_0);
    

  79. }
    

  80.  
    

  81. int main(void)
    

  82. {
    

  83.     NVIC_SetPriorityGrouping(NVIC_PRIGROUP_PRE4_SUB0);
    

  84.     systick_config();
    

  85.     GPIO_config();
    

  86.     Usart0_init();
    

  87.  
    

  88.     sema_handler = xSemaphoreCreateBinary();
    

  89.     xTaskCreate(start_task, "start_task", 128, NULL, 1, &task_handler);
    

  90.     vTaskStartScheduler();
    

  91.  
    

  92.     while(1) {}
    

  93. }

观察，两个任务是否获得信号。

改变两个任务的优先级，观察两个任务信号的获取情况。

案例二

在案例一的基础上，通过串口接收，来发送信号。

串口发送信号

复制
  1. void Usart0_recv(uint8_t *data, uint32_t len)
    

  2. {
    

  3.     printf("recv: %s\n", data);
    

  4.     xSemaphoreGiveFromISR(sema_handler, NULL);
    

  5. }

xSemaphoreGiveFromISR中断中发送信号





计数型信号量
功能 描述
xSemaphoreCreateCounting 创建计数型信号量
xSemaphoreTake 等待信号
xSemaphoreGive 发送信号


信号量的创建

复制
  1. SemaphoreHandle_t xSemaphoreCreateCounting(        const UBaseType_t uxMaxCount,
    

  2.                                                 const UBaseType_t uxInitialCount);

参数说明:

  • const UBaseType_t uxMaxCount最大计数值。
  • const UBaseType_t uxInitialCount初始化当前计数值。

返回值为信号量的句柄。


等待信号操作

BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xBlockTime );

1、SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。

2、TickType_t xBlockTime表示要等待的时间。通常我们一直等到有信号到来，这里我们可以填写portMAX_DELAY

3、返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL


发送信号操作

BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);
  • SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。
  • 返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL

案例一
  • 开启两个任务，等待信号，接收到信号后，处理耗时操作
  • 开启按键扫描，点击按键时发送信号

main.c
复制
  1. #include "gd32f4xx.h"
    

  2. #include "systick.h"
    

  3. #include <stdio.h>
    

  4. #include "main.h"
    

  5. #include "FreeRTOS.h"
    

  6. #include "task.h"
    

  7. #include "semphr.h"
    

  8. #include "Usart0.h"
    

  9.  
    

  10. TaskHandle_t            task_handler;
    

  11. TaskHandle_t            task_key_handler;
    

  12. TaskHandle_t            task1_handler;
    

  13. TaskHandle_t            task2_handler;
    

  14. SemaphoreHandle_t                 sema_handler;
    

  15.  
    

  16. void task1(void *pvParameters) {
    

  17.     BaseType_t result;
    

  18.     while(1) {
    

  19.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  20.         if(result == pdTRUE) {
    

  21.             printf("task1 %ld\n", uxSemaphoreGetCount(sema_handler));
    

  22.         } else {
    

  23.             printf("task1 Error\n");
    

  24.         }
    

  25.         vTaskDelay(2500);
    

  26.     }
    

  27. }
    

  28.  
    

  29. void task2(void *pvParameters) {
    

  30.     BaseType_t result;
    

  31.     while(1) {
    

  32.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  33.         if(result == pdTRUE) {
    

  34.             printf("task2 %ld\n", uxSemaphoreGetCount(sema_handler));
    

  35.         } else {
    

  36.             printf("task2 Error\n");
    

  37.         }
    

  38.         vTaskDelay(2500);
    

  39.     }
    

  40. }
    

  41.  
    

  42. void task_key(void *pvParameters) {
    

  43.     FlagStatus pre_state = RESET;
    

  44.     BaseType_t result;
    

  45.     while(1) {
    

  46.         FlagStatus state = gpio_input_bit_get(GPIOA, GPIO_PIN_0);
    

  47.         if(SET == state && pre_state == RESET) {
    

  48.             // 当前高电平, 上一次为低电平,按下
    

  49.             pre_state = state;
    

  50.  
    

  51.             result = xSemaphoreGive(sema_handler);
    

  52. //                        if(result == pdTRUE) {
    

  53. //                                printf("semaphore give success\n");
    

  54. //                        } else {
    

  55. //                                printf("semaphore give error\n");
    

  56. //                        }
    

  57.         } else if(RESET == state && pre_state == SET) {
    

  58.             // 当前高电平, 上一次为低电平,抬起
    

  59.             pre_state = state;
    

  60.         }
    

  61.         vTaskDelay(20);
    

  62.     }
    

  63. }
    

  64.  
    

  65. void start_task(void *pvParameters) {
    

  66.     taskENTER_CRITICAL();
    

  67.  
    

  68.     xTaskCreate(task_key, "task_key", 64, NULL, 2, &task_key_handler);
    

  69.     xTaskCreate(task1, "task1", 64, NULL, 3, &task1_handler);
    

  70.     xTaskCreate(task2, "task2", 64, NULL, 2, &task2_handler);
    

  71.     vTaskDelete(task_handler);
    

  72.  
    

  73.     taskEXIT_CRITICAL();
    

  74. }
    

  75.  
    

  76. void Usart0_recv(uint8_t *data, uint32_t len)
    

  77. {
    

  78.     printf("recv: %s\n", data);
    

  79. }
    

  80.  
    

  81. static void GPIO_config() {
    

  82.     // 时钟初始化
    

  83.     rcu_periph_clock_enable(RCU_GPIOA);
    

  84.     // 配置GPIO模式
    

  85.     gpio_mode_set(GPIOA, GPIO_MODE_INPUT, GPIO_PUPD_PULLDOWN, GPIO_PIN_0);
    

  86. }
    

  87.  
    

  88. int main(void)
    

  89. {
    

  90.     NVIC_SetPriorityGrouping(NVIC_PRIGROUP_PRE4_SUB0);
    

  91.     systick_config();
    

  92.     GPIO_config();
    

  93.     Usart0_init();
    

  94.  
    

  95.     sema_handler = xSemaphoreCreateCounting(100, 0);
    

  96.     xTaskCreate(start_task, "start_task", 128, NULL, 1, &task_handler);
    

  97.     vTaskStartScheduler();
    

  98.  
    

  99.     while(1) {}
    

  100. }

观察，两个任务是否获得信号。

频繁点击按键，观察效果。

案例二

在案例一的基础上，通过串口接收，来发送信号。

串口发送信号

复制
  1. void Usart0_recv(uint8_t *data, uint32_t len)
    

  2. {
    

  3.     printf("recv: %s\n", data);
    

  4.     xSemaphoreGiveFromISR(sema_handler, NULL);
    

  5. }

xSemaphoreGiveFromISR中断中发送信号




互斥信号量
功能 描述
xSemaphoreCreateMutex 创建互斥信号量
xSemaphoreTake 等待信号
xSemaphoreGive 发送信号


信号量的创建


互斥信号量创建语法

SemaphoreHandle_t xSemaphoreCreateMutex();

返回值为信号量的句柄。

等待信号操作

BaseType_t xSemaphoreTake(SemaphoreHandle_t xSemaphore, TickType_t xBlockTime );

1、SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。

2、TickType_t xBlockTime表示要等待的时间。通常我们一直等到有信号到来，这里我们可以填写portMAX_DELAY

3、返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL


发送信号操作

BaseType_t xSemaphoreGive(SemaphoreHandle_t xSemaphore);
  • SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。
  • 返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL

案例一

开启两个任务，同时等待和发送信号，观察任务调用

main.c

复制
  1. #include "gd32f4xx.h"
    

  2. #include "systick.h"
    

  3. #include <stdio.h>
    

  4. #include "main.h"
    

  5. #include "FreeRTOS.h"
    

  6. #include "task.h"
    

  7. #include "semphr.h"
    

  8. #include "Usart0.h"
    

  9.  
    

  10. TaskHandle_t            task_handler;
    

  11. TaskHandle_t            task1_handler;
    

  12. TaskHandle_t            task2_handler;
    

  13. SemaphoreHandle_t                 sema_handler;
    

  14.  
    

  15. void task1(void *pvParameters) {
    

  16.     BaseType_t result;
    

  17.     while(1) {
    

  18.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  19.         if(result == pdTRUE) {
    

  20.             printf("task1\n");
    

  21.         } else {
    

  22.             printf("task1 Error\n");
    

  23.         }
    

  24.         xSemaphoreGive(sema_handler);
    

  25.         vTaskDelay(2000);
    

  26.     }
    

  27. }
    

  28.  
    

  29. void task2(void *pvParameters) {
    

  30.     BaseType_t result;
    

  31.     while(1) {
    

  32.         result = xSemaphoreTake(sema_handler, portMAX_DELAY);
    

  33.         if(result == pdTRUE) {
    

  34.             printf("task2\n");
    

  35.         } else {
    

  36.             printf("task2 Error\n");
    

  37.         }
    

  38.         xSemaphoreGive(sema_handler);
    

  39.         vTaskDelay(2000);
    

  40.     }
    

  41. }
    

  42.  
    

  43. void start_task(void *pvParameters) {
    

  44.     taskENTER_CRITICAL();
    

  45.     
    

  46.     xTaskCreate(task1, "task1", 64, NULL, 2, &task1_handler);
    

  47.     xTaskCreate(task2, "task2", 64, NULL, 2, &task2_handler);
    

  48.     vTaskDelete(task_handler);
    

  49.  
    

  50.     taskEXIT_CRITICAL();
    

  51. }
    

  52.  
    

  53. void Usart0_recv(uint8_t *data, uint32_t len)
    

  54. {
    

  55.     printf("recv: %s\n", data);
    

  56. }
    

  57.  
    

  58.  
    

  59. int main(void)
    

  60. {
    

  61.     NVIC_SetPriorityGrouping(NVIC_PRIGROUP_PRE4_SUB0);
    

  62.     systick_config();
    

  63.     Usart0_init();
    

  64.  
    

  65.     sema_handler = xSemaphoreCreateMutex();
    

  66.     xTaskCreate(start_task, "start_task", 128, NULL, 1, &task_handler);
    

  67.     vTaskStartScheduler();
    

  68.  
    

  69.     while(1) {}
    

  70. }



递归互斥信号量
功能 描述
xSemaphoreCreateRecursiveMutex 创建递归互斥信号量
xSemaphoreTakeRecursive 等待信号
xSemaphoreGiveRecursive 发送信号


信号量的创建

互斥信号量创建语法

SemaphoreHandle_t xSemaphoreCreateRecursiveMutex();

返回值为信号量的句柄。


等待信号操作

BaseType_t xSemaphoreTakeRecursive(SemaphoreHandle_t xSemaphore, TickType_t xBlockTime );

1、SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。

2、TickType_t xBlockTime表示要等待的时间。通常我们一直等到有信号到来，这里我们可以填写portMAX_DELAY

3、返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL


发送信号操作

BaseType_t xSemaphoreGiveRecursive(SemaphoreHandle_t xSemaphore);
  • SemaphoreHandle_t xSemaphore表示要等待的哪个信号量句柄。
  • 返回值类型为BaseType_t，表示成功或者失败，取值为pdPASS和pdFAIL

示例代码：

main.c

复制
  1. #include "gd32f4xx.h"
    

  2. #include "systick.h"
    

  3. #include <stdio.h>
    

  4. #include "main.h"
    

  5. #include "FreeRTOS.h"
    

  6. #include "task.h"
    

  7. #include "semphr.h"
    

  8. #include "Usart0.h"
    

  9.  
    

  10. TaskHandle_t            task_Handler;
    

  11. TaskHandle_t            task1_Handler;
    

  12. TaskHandle_t            task2_Handler;
    

  13. SemaphoreHandle_t                 sema_handler;
    

  14.  
    

  15. void task1(void *pvParameters) {
    

  16.         BaseType_t result;
    

  17.     while(1) {
    

  18.         printf("task1        take 0\n");
    

  19.                                 xSemaphoreTakeRecursive(sema_handler, portMAX_DELAY);
    

  20.                         
    

  21.                                 printf("task1        take 1\n");
    

  22.                                 xSemaphoreTakeRecursive(sema_handler, portMAX_DELAY);
    

  23.                                 
    

  24.                                 printf("task1        give\n");
    

  25.                                 xSemaphoreGiveRecursive(sema_handler);
    

  26.                                 vTaskDelay(1000);
    

  27.     }
    

  28. }
    

  29.  
    

  30. void task2(void *pvParameters) {
    

  31.         BaseType_t result;
    

  32.     while(1) {
    

  33.                                 printf("task2        take 0\n");
    

  34.                                 xSemaphoreTakeRecursive(sema_handler, portMAX_DELAY);
    

  35.                         
    

  36.                                 printf("task2        take 1\n");
    

  37.                                 xSemaphoreTakeRecursive(sema_handler, portMAX_DELAY);
    

  38.                                 
    

  39.                                 printf("task2        give\n");
    

  40.                                 xSemaphoreGiveRecursive(sema_handler);
    

  41.                                 
    

  42.                                 vTaskDelay(1000);
    

  43.     }
    

  44. }
    

  45.  
    

  46. void start_task(void *pvParameters) {
    

  47.     taskENTER_CRITICAL();
    

  48.  
    

  49.     xTaskCreate(task1, "task1", 128, NULL, 2, &task1_Handler);
    

  50.         xTaskCreate(task2, "task2", 128, NULL, 2, &task2_Handler);
    

  51.     vTaskDelete(task_Handler);
    

  52.  
    

  53.     taskEXIT_CRITICAL();
    

  54. }
    

  55.  
    

  56. void Usart0_recv(uint8_t *data, uint32_t len)
    

  57. {
    

  58.     printf("recv: %s\n", data);
    

  59. }
    

  60.  
    

  61. static void GPIO_config() {
    

  62.     // 时钟初始化
    

  63.     rcu_periph_clock_enable(RCU_GPIOA);
    

  64.     // 配置GPIO模式
    

  65.     gpio_mode_set(GPIOA, GPIO_MODE_INPUT, GPIO_PUPD_PULLDOWN, GPIO_PIN_0);
    

  66. }
    

  67.  
    

  68. int main(void)
    

  69. {
    

  70.     systick_config();
    

  71.     GPIO_config();
    

  72.     Usart0_init();
    

  73.                 
    

  74.         sema_handler = xSemaphoreCreateRecursiveMutex();
    

  75.         if(sema_handler == NULL) {
    

  76.                 printf("create error\r\n");
    

  77.         }
    

  78.     xTaskCreate(start_task, "start_task", 128, NULL, 1, &task_Handler);
    

  79.     vTaskStartScheduler();
    

  80.  
    

  81.     while(1) {}
    

  82. }

比较

四种信号量类型的常见应用场景的比较：

1. 二进制信号量：

应用场景：二进制信号量适用于任务间的互斥、同步和事件通知。例如，当多个任务需要共享一个资源时，可以使用二进制信号量来保证同一时间只有一个任务访问该资源。

示例应用：多个任务竞争访问共享打印机资源。


2. 计数信号量：

应用场景：计数信号量适用于任务间的资源共享和限制、任务同步和事件通知。它可以表示一组可用资源的数量，任务可以通过获取计数信号量来申请和释放这些资源。

示例应用：限制同时执行的任务数量、任务间的生产者-消费者模式。


3. 互斥信号量：

应用场景：互斥信号量用于互斥访问共享资源的场景。它确保在任意给定时间只有一个任务可以访问共享资源，避免了数据竞争和不一致性。

示例应用：多个任务竞争访问共享数据结构、临界区保护。


4. 递归互斥信号量：

应用场景：递归互斥信号量适用于同一任务需要多次获取互斥资源的场景。它允许同一任务在获取资源后再次获取，而不会引起死锁。

示例应用：任务递归调用、嵌套临界区保护。


需要根据具体的应用需求选择合适的信号量类型。如果需要简单的互斥访问，互斥信号量可能是最合适的选择。如果需要限制资源数量或任务同步，计数信号量可以派上用场。而对于同一任务需要多次获取资源的情况，递归互斥信号量提供了便利。











本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复

收藏1 举报

打赏榜单

21小跑堂 打赏了 80.00 元 2024-10-25
理由：恭喜通过原创审核！期待您更多的原创作品~

评论

21小跑堂
详解FreeRTOS中信号量的概念，内容整理完整，开发流程介绍详细，步骤清晰，段落设计合理，可读性较高  发表于 2024-10-25 17:44

相关帖子
聪聪哥哥 发表于 2024-10-26 14:37 | 显示全部楼层
这个帖子的源代码能分享一下吗？
回复

收藏1 举报

博创欧阳 发表于 2024-10-27 19:44 | 显示全部楼层
讲的很清楚，期待下周的更新
回复

收藏1 举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

虚幻的是灵魂

15

主题

118

帖子

2

粉丝
快速回复 在线客服 返回列表 返回顶部