FreeRTOS信號量的使用與實例
在嵌入式系統中，任務管理是一個重要的部分，它涉及到任務之間的通信和同步，信號量，隊列，互斥鎖和事件標志組等概念。本文將以 FreeRTOS 為例，詳細講解這些內容。
1. 任務間通信與同步概述
在 FreeRTOS 中，任務是由一個或多個函數組成的獨立的執行流，它們可以獨立的運行和調度。任務之間的通信和同步是任務管理的核心內容之一。任務間的通信是指一個任務向另一個任務傳遞信息，而同步則是指多個任務按照一定的順序執行。FreeRTOS 提供了多種任務間通信和同步的機制，包括信號量，隊列，互斥鎖和事件標志組等。
2. 信號量的使用與實例
信號量（Semaphore）是 FreeRTOS 中一種常用的同步機制，主要用于任務間和中斷服務例程（ISR）間的通信。它們被用來保護共享資源，使得只有一個任務或者中斷服務例程可以訪問共享資源，避免了資源沖突的問題。
FreeRTOS 中的信號量主要有兩種類型：計數信號量和二值信號量。
- 計數信號量（Counting Semaphore）：是一種可以持有多個“計數”或者“票”的信號量。例如，如果你有一些共享資源，每個資源都需要獨立的訪問控制，你就可以使用一個初始計數等于資源數量的計數信號量。當一個任務需要訪問一個資源時，它會嘗試“獲取”一個信號量。如果信號量計數大于 0，那么信號量計數減 1，任務繼續執行。如果計數為 0，那么任務就會阻塞，直到信號量計數大于 0。當任務不再需要訪問資源時，它應該“釋放”信號量，信號量計數加 1。
- 二值信號量（Binary Semaphore）：是一種只有兩個值（
0和1）的特殊信號量。它通常被用作任務之間或者任務與中斷服務例程之間的同步機制。當信號量的值為1時，任務可以獲取信號量并繼續執行。當信號量的值為0時，任務嘗試獲取信號量會被阻塞，直到信號量的值變為1。二值信號量也可以被用作互斥量（Mutex），用于保護共享資源的訪問。
在 FreeRTOS 中，信號量的操作主要有創建（xSemaphoreCreateBinary, xSemaphoreCreateCounting等函數）、獲取（xSemaphoreTake函數）和釋放（xSemaphoreGive函數）。在中斷服務例程中，獲取和釋放信號量的函數有所不同，分別為xSemaphoreTakeFromISR和xSemaphoreGiveFromISR。
示例
計數信號量
假設有兩個任務 TaskA 和 TaskB，TaskA 負責發送數據，TaskB 負責接收數據。我們使用計數信號量來實現 TaskA 和 TaskB 之間的同步。
首先，在 FreeRTOS 中創建一個計數信號量：
SemaphoreHandle_t xSemaphore;
xSemaphore = xSemaphoreCreateCounting(10, 0); // 創建一個計數信號量，初始計數值為0，最大計數值為10
接下來，在 TaskA 中發送數據時獲取計數信號量：
void TaskA(void *pvParameters) {
while (1) {
// 發送數據
...
// 獲取計數信號量，如果計數值為0，則任務被阻塞
xSemaphoreTake(xSemaphore, portMAX_DELAY);
}
}
在 TaskB 中接收數據時釋放計數信號量：
void TaskB(void *pvParameters) {
while (1) {
// 接收數據
...
// 釋放計數信號量，增加計數值
xSemaphoreGive(xSemaphore);
}
}
在上述代碼中，當 TaskA 發送數據時，它會獲取計數信號量，如果計數值為 0，則 TaskA 會被阻塞，直到 TaskB 接收數據并釋放計數信號量為止。當 TaskB 釋放計數信號量后，計數值增加，TaskA 可以繼續執行發送數據的操作。
這樣，使用計數信號量可以實現 TaskA 和 TaskB 之間的同步，保證 TaskA 在 TaskB 完成接收數據后才進行發送數據的操作，避免了數據的丟失和沖突。
二值信號量
二值信號量（Binary Semaphore）是一種用于任務間同步和互斥的機制。它只有兩個狀態，可以是空閑或者被占用，類似于互斥鎖。
下面是一個使用二值信號量的示例：
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
// 創建一個二值信號量
SemaphoreHandle_t binarySemaphore;
// 任務1
void task1(void *pvParameters)
{
while (1)
{
// 等待二值信號量
xSemaphoreTake(binarySemaphore, portMAX_DELAY);
// 執行任務1的操作
// ...
// 釋放二值信號量
xSemaphoreGive(binarySemaphore);
// 延時一段時間
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
// 任務2
void task2(void *pvParameters)
{
while (1)
{
// 等待二值信號量
xSemaphoreTake(binarySemaphore, portMAX_DELAY);
// 執行任務2的操作
// ...
// 釋放二值信號量
xSemaphoreGive(binarySemaphore);
// 延時一段時間
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
int main()
{
// 創建二值信號量
binarySemaphore = xSemaphoreCreateBinary();
// 創建任務1
xTaskCreate(task1, "Task 1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
// 創建任務2
xTaskCreate(task2, "Task 2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
// 啟動任務調度器
vTaskStartScheduler();
return 0;
}
在上面的示例中，首先創建了一個二值信號量binarySemaphore，然后創建了兩個任務task1和task2。這兩個任務都會在一個無限循環中執行，首先等待二值信號量，然后執行自己的操作，最后釋放二值信號量。
當一個任務等待二值信號量時，如果二值信號量的狀態是空閑（未被占用），則任務可以獲取到該信號量，繼續執行自己的操作。如果二值信號量的狀態是被占用（已經有任務獲取到了信號量），則任務會一直等待，直到信號量被釋放。
需要注意的是，當一個任務獲取到二值信號量后，其他任務將無法獲取到該信號量，直到該任務釋放信號量。這就保證了任務之間的互斥性。
通過使用二值信號量，可以實現任務間的同步和互斥操作，確保多個任務按照特定的順序執行或者避免資源的競爭。
3. 隊列的使用與實例
隊列是一種數據結構，它允許任務按照先進先出（FIFO）的原則將數據項插入隊列和從隊列中獲取數據項。在 FreeRTOS 中，可以使用 xQueueCreate()函數來創建一個隊列。
示例：
QueueHandle_t xQueue;
void vProducerTask(void pvParameters)
{
int32_t lValueToSend;
BaseType_t xStatus;
lValueToSend = (int32_t) pvParameters;
for(;;)
{
xStatus = xQueueSendToBack(xQueue, &lValueToSend, 0);
if(xStatus != pdPASS)
{
printf("Could not send to the queue.n");
}
}
}
在這個例子中，vProducerTask 任務將數據項發送到隊列的尾部。如果發送成功，xQueueSendToBack()函數將返回 pdPASS，否則，將返回一個錯誤代碼。
4. 互斥鎖的使用與實例
互斥鎖是一種用于保護共享資源的機制。當一個任務需要使用一個共享資源時，它必須首先獲取互斥鎖。如果互斥鎖已經被另一個任務獲取，那么這個任務就需要等待，直到互斥鎖被釋放。在 FreeRTOS 中，可以使用 xSemaphoreCreateMutex()函數來創建一個互斥鎖。
示例：
SemaphoreHandle_t xMutex;
void vTask(void pvParameters)
{
for(;;)
{
if(xSemaphoreTake(xMutex, (TickType_t)10) == pdTRUE)
{
// The mutex was successfully taken, so the shared resource can be accessed.
printf("Task: Mutex taken!n");
// ...
// Access the shared resource.
// ...
// Release the mutex.
xSemaphoreGive(xMutex);
}
else
{
// The mutex could not be taken.
printf("Task: Mutex not taken!n");
}
}
}
在這個例子中，vTask 任務嘗試獲取一個互斥鎖。如果成功，它將訪問一個共享資源，然后釋放互斥鎖。
5. 事件標志組的使用與實例
事件標志組是一種用于表示一組事件發生狀態的數據結構。每一個事件都有一個對應的標志，當事件發生時，標志被設置，當事件被處理時，標志被清除。在 FreeRTOS 中，可以使用 xEventGroupCreate()函數來創建一個事件標志組。
示例：
EventGroupHandle_t xEventGroup;
void vTask(void pvParameters)
{
EventBits_t uxBits;
for(;;)
{
uxBits = xEventGroupWaitBits(
xEventGroup, // The event group being tested.
BIT_0 | BIT_4, // The bits within the event group to wait for.
pdTRUE, // BIT_0 & BIT_4 should be cleared before returning.
pdFALSE, // Don't wait for both bits, either bit will do.
portMAX_DELAY // Wait a maximum for either bit to be set.
);
if((uxBits & (BIT_0 | BIT_4)) == (BIT_0 | BIT_4))
{
// Both bits were set.
printf("Task: Both bits were set!n");
}
else if((uxBits & BIT_0) != 0)
{
// Bit 0 was set.
printf("Task: Bit 0 was set!n");
}
else if((uxBits & BIT_4) != 0)
{
// Bit 4 was set.
printf("Task: Bit 4 was set!n");
}
else
{
// Neither bit was set.
printf("Task: Neither bit was set!n");
}
}
}
在這個例子中，vTask 任務等待事件標志組中的任何一個事件發生。如果兩個事件都發生，它將打印出"Both bits were set!"，如果只有一個事件發生，它將打印出對應的消息。
6. 信號量 vs 互斥鎖
信號量（Semaphore）和互斥鎖（Mutex）都是多任務環境下保護共享資源的一種方法，它們之間存在一些區別：
- 互斥鎖是一種所有權的概念，即一個任務獲取了互斥鎖后，只有它自己可以釋放這個互斥鎖，其他任務不能釋放。而信號量沒有所有權的概念，任何任務都可以釋放信號量。
- 在 FreeRTOS 中，互斥鎖有優先級反轉的解決機制，當一個低優先級的任務獲取了互斥鎖，而高優先級的任務需要這個互斥鎖時，低優先級的任務的優先級會被提升，以減少優先級反轉的問題。而信號量沒有這個機制。
- 互斥鎖通常用于保護共享資源，即在同一時間只能有一個任務訪問某個資源。信號量則更多是用于任務同步，它可以被用來喚醒一個或多個等待的任務。
- 在 FreeRTOS 中，信號量可以有計數的概念，即可以被“給”多次，每次“給”都會增加一個計數，而互斥鎖沒有這個概念，它只有鎖定和解鎖兩種狀態。
- 信號量可以被用作二元信號量（即只有兩種狀態，
0和1，類似互斥鎖），而互斥鎖不能被用作計數信號量。
總結
在 FreeRTOS 中，任務間的通信和同步是一個重要的部分，它涉及到信號量，隊列，互斥鎖和事件標志組等概念。通過理解和掌握這些概念，可以有效地管理和調度任務，提高系統的效率和穩定性。
FreeRTOS 任務間通信與同步
在嵌入式系統中，任務管理是一個重要的部分，它涉及到任務之間的通信和同步，信號量，隊列，互斥鎖和事件標志組等概念。本文將以 FreeRTOS 為例，詳細講解這些內容。
1. 任務間通信與同步概述
在 FreeRTOS 中，任務是由一個或多個函數組成的獨立的執行流，它們可以獨立的運行和調度。任務之間的通信和同步是任務管理的核心內容之一。任務間的通信是指一個任務向另一個任務傳遞信息，而同步則是指多個任務按照一定的順序執行。FreeRTOS 提供了多種任務間通信和同步的機制，包括信號量，隊列，互斥鎖和事件標志組等。
2. 信號量的使用與實例
信號量（Semaphore）是 FreeRTOS 中一種常用的同步機制，主要用于任務間和中斷服務例程（ISR）間的通信。它們被用來保護共享資源，使得只有一個任務或者中斷服務例程可以訪問共享資源，避免了資源沖突的問題。
FreeRTOS 中的信號量主要有兩種類型：計數信號量和二值信號量。
- 計數信號量（Counting Semaphore）：是一種可以持有多個“計數”或者“票”的信號量。例如，如果你有一些共享資源，每個資源都需要獨立的訪問控制，你就可以使用一個初始計數等于資源數量的計數信號量。當一個任務需要訪問一個資源時，它會嘗試“獲取”一個信號量。如果信號量計數大于 0，那么信號量計數減 1，任務繼續執行。如果計數為 0，那么任務就會阻塞，直到信號量計數大于 0。當任務不再需要訪問資源時，它應該“釋放”信號量，信號量計數加 1。
- 二值信號量（Binary Semaphore）：是一種只有兩個值（
0和1）的特殊信號量。它通常被用作任務之間或者任務與中斷服務例程之間的同步機制。當信號量的值為1時，任務可以獲取信號量并繼續執行。當信號量的值為0時，任務嘗試獲取信號量會被阻塞，直到信號量的值變為1。二值信號量也可以被用作互斥量（Mutex），用于保護共享資源的訪問。
在 FreeRTOS 中，信號量的操作主要有創建（xSemaphoreCreateBinary, xSemaphoreCreateCounting等函數）、獲取（xSemaphoreTake函數）和釋放（xSemaphoreGive函數）。在中斷服務例程中，獲取和釋放信號量的函數有所不同，分別為xSemaphoreTakeFromISR和xSemaphoreGiveFromISR。
示例
計數信號量
假設有兩個任務 TaskA 和 TaskB，TaskA 負責發送數據，TaskB 負責接收數據。我們使用計數信號量來實現 TaskA 和 TaskB 之間的同步。
首先，在 FreeRTOS 中創建一個計數信號量：
SemaphoreHandle_t xSemaphore;
xSemaphore = xSemaphoreCreateCounting(10, 0); // 創建一個計數信號量，初始計數值為0，最大計數值為10
接下來，在 TaskA 中發送數據時獲取計數信號量：
void TaskA(void *pvParameters) {
while (1) {
// 發送數據
...
// 獲取計數信號量，如果計數值為0，則任務被阻塞
xSemaphoreTake(xSemaphore, portMAX_DELAY);
}
}
在 TaskB 中接收數據時釋放計數信號量：
void TaskB(void *pvParameters) {
while (1) {
// 接收數據
...
// 釋放計數信號量，增加計數值
xSemaphoreGive(xSemaphore);
}
}
在上述代碼中，當 TaskA 發送數據時，它會獲取計數信號量，如果計數值為 0，則 TaskA 會被阻塞，直到 TaskB 接收數據并釋放計數信號量為止。當 TaskB 釋放計數信號量后，計數值增加，TaskA 可以繼續執行發送數據的操作。
這樣，使用計數信號量可以實現 TaskA 和 TaskB 之間的同步，保證 TaskA 在 TaskB 完成接收數據后才進行發送數據的操作，避免了數據的丟失和沖突。
二值信號量
二值信號量（Binary Semaphore）是一種用于任務間同步和互斥的機制。它只有兩個狀態，可以是空閑或者被占用，類似于互斥鎖。
下面是一個使用二值信號量的示例：
#include "FreeRTOS.h"
#include "task.h"
#include "semphr.h"
// 創建一個二值信號量
SemaphoreHandle_t binarySemaphore;
// 任務1
void task1(void *pvParameters)
{
while (1)
{
// 等待二值信號量
xSemaphoreTake(binarySemaphore, portMAX_DELAY);
// 執行任務1的操作
// ...
// 釋放二值信號量
xSemaphoreGive(binarySemaphore);
// 延時一段時間
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
// 任務2
void task2(void *pvParameters)
{
while (1)
{
// 等待二值信號量
xSemaphoreTake(binarySemaphore, portMAX_DELAY);
// 執行任務2的操作
// ...
// 釋放二值信號量
xSemaphoreGive(binarySemaphore);
// 延時一段時間
vTaskDelay(pdMS_TO_TICKS(1000));
}
}
int main()
{
// 創建二值信號量
binarySemaphore = xSemaphoreCreateBinary();
// 創建任務1
xTaskCreate(task1, "Task 1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
// 創建任務2
xTaskCreate(task2, "Task 2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
// 啟動任務調度器
vTaskStartScheduler();
return 0;
}
在上面的示例中，首先創建了一個二值信號量binarySemaphore，然后創建了兩個任務task1和task2。這兩個任務都會在一個無限循環中執行，首先等待二值信號量，然后執行自己的操作，最后釋放二值信號量。
當一個任務等待二值信號量時，如果二值信號量的狀態是空閑（未被占用），則任務可以獲取到該信號量，繼續執行自己的操作。如果二值信號量的狀態是被占用（已經有任務獲取到了信號量），則任務會一直等待，直到信號量被釋放。
需要注意的是，當一個任務獲取到二值信號量后，其他任務將無法獲取到該信號量，直到該任務釋放信號量。這就保證了任務之間的互斥性。
通過使用二值信號量，可以實現任務間的同步和互斥操作，確保多個任務按照特定的順序執行或者避免資源的競爭。
3. 隊列的使用與實例
隊列是一種數據結構，它允許任務按照先進先出（FIFO）的原則將數據項插入隊列和從隊列中獲取數據項。在 FreeRTOS 中，可以使用 xQueueCreate()函數來創建一個隊列。
示例：
QueueHandle_t xQueue;
void vProducerTask(void pvParameters)
{
int32_t lValueToSend;
BaseType_t xStatus;
lValueToSend = (int32_t) pvParameters;
for(;;)
{
xStatus = xQueueSendToBack(xQueue, &lValueToSend, 0);
if(xStatus != pdPASS)
{
printf("Could not send to the queue.n");
}
}
}
在這個例子中，vProducerTask 任務將數據項發送到隊列的尾部。如果發送成功，xQueueSendToBack()函數將返回 pdPASS，否則，將返回一個錯誤代碼。
4. 互斥鎖的使用與實例
互斥鎖是一種用于保護共享資源的機制。當一個任務需要使用一個共享資源時，它必須首先獲取互斥鎖。如果互斥鎖已經被另一個任務獲取，那么這個任務就需要等待，直到互斥鎖被釋放。在 FreeRTOS 中，可以使用 xSemaphoreCreateMutex()函數來創建一個互斥鎖。
示例：
SemaphoreHandle_t xMutex;
void vTask(void pvParameters)
{
for(;;)
{
if(xSemaphoreTake(xMutex, (TickType_t)10) == pdTRUE)
{
// The mutex was successfully taken, so the shared resource can be accessed.
printf("Task: Mutex taken!n");
// ...
// Access the shared resource.
// ...
// Release the mutex.
xSemaphoreGive(xMutex);
}
else
{
// The mutex could not be taken.
printf("Task: Mutex not taken!n");
}
}
}
在這個例子中，vTask 任務嘗試獲取一個互斥鎖。如果成功，它將訪問一個共享資源，然后釋放互斥鎖。
5. 事件標志組的使用與實例
事件標志組是一種用于表示一組事件發生狀態的數據結構。每一個事件都有一個對應的標志，當事件發生時，標志被設置，當事件被處理時，標志被清除。在 FreeRTOS 中，可以使用 xEventGroupCreate()函數來創建一個事件標志組。
示例：
EventGroupHandle_t xEventGroup;
void vTask(void pvParameters)
{
EventBits_t uxBits;
for(;;)
{
uxBits = xEventGroupWaitBits(
xEventGroup, // The event group being tested.
BIT_0 | BIT_4, // The bits within the event group to wait for.
pdTRUE, // BIT_0 & BIT_4 should be cleared before returning.
pdFALSE, // Don't wait for both bits, either bit will do.
portMAX_DELAY // Wait a maximum for either bit to be set.
);
if((uxBits & (BIT_0 | BIT_4)) == (BIT_0 | BIT_4))
{
// Both bits were set.
printf("Task: Both bits were set!n");
}
else if((uxBits & BIT_0) != 0)
{
// Bit 0 was set.
printf("Task: Bit 0 was set!n");
}
else if((uxBits & BIT_4) != 0)
{
// Bit 4 was set.
printf("Task: Bit 4 was set!n");
}
else
{
// Neither bit was set.
printf("Task: Neither bit was set!n");
}
}
}
在這個例子中，vTask 任務等待事件標志組中的任何一個事件發生。如果兩個事件都發生，它將打印出"Both bits were set!"，如果只有一個事件發生，它將打印出對應的消息。
6. 信號量 vs 互斥鎖
信號量（Semaphore）和互斥鎖（Mutex）都是多任務環境下保護共享資源的一種方法，它們之間存在一些區別：
- 互斥鎖是一種所有權的概念，即一個任務獲取了互斥鎖后，只有它自己可以釋放這個互斥鎖，其他任務不能釋放。而信號量沒有所有權的概念，任何任務都可以釋放信號量。
- 在 FreeRTOS 中，互斥鎖有優先級反轉的解決機制，當一個低優先級的任務獲取了互斥鎖，而高優先級的任務需要這個互斥鎖時，低優先級的任務的優先級會被提升，以減少優先級反轉的問題。而信號量沒有這個機制。
- 互斥鎖通常用于保護共享資源，即在同一時間只能有一個任務訪問某個資源。信號量則更多是用于任務同步，它可以被用來喚醒一個或多個等待的任務。
- 在 FreeRTOS 中，信號量可以有計數的概念，即可以被“給”多次，每次“給”都會增加一個計數，而互斥鎖沒有這個概念，它只有鎖定和解鎖兩種狀態。
- 信號量可以被用作二元信號量（即只有兩種狀態，
0和1，類似互斥鎖），而互斥鎖不能被用作計數信號量。
總結
在 FreeRTOS 中，任務間的通信和同步是一個重要的部分，它涉及到信號量，隊列，互斥鎖和事件標志組等概念。通過理解和掌握這些概念，可以有效地管理和調度任務，提高系統的效率和穩定性。
-
嵌入式系統
+關注
關注
41文章
3593瀏覽量
129473 -
中斷
+關注
關注
5文章
898瀏覽量
41497 -
FreeRTOS
+關注
關注
12文章
484瀏覽量
62178 -
信號量
+關注
關注
0文章
53瀏覽量
8344
發布評論請先 登錄
相關推薦
實時操作系統FreeRTOS信號量應用
FreeRTOS信號量使用教程
轉：freeRTOS信號量學習
轉：第21章 FreeRTOS計數信號量
Linux信號量（2）：POSIX 信號量
FreeRTOS信號量 & ESP32實戰
FreeRTOS 隊列 信號量 互斥量
FreeRTOS系列第20篇---FreeRTOS信號量API函數
freeRTOS中最常用到的信號量有哪些
工商網監
評論