信號量和互斥（互斥）是用于同步、資源管理和保護資源免受損壞的內核對象。在本教程的前半部分，我們將了解Semaphore背后的理念，以及如何以及在何處使用它。

什么是信號量？

信號量是一種信號機制，其中處于等待狀態的任務由另一個任務發出信號以執行。換句話說，當一個task1完成它的工作時，它會顯示一個標志或將一個標志加1，然后另一個任務（task2）收到這個標志，表明它現在可以執行它的工作了。當 task2 完成其工作時，標志將減 1。

因此，基本上，它是一種“給予”和“接受”機制，而信號量是一個整數變量，用于同步對資源的訪問。

FreeRTOS 中的信號量類型：

信號量有兩種類型。

二進制信號量

計數信號量

1、Binary Semaphore：它有兩個整數值0和1。有點類似于長度為1的Queue。比如我們有兩個task，task1和task2。task1向task2發送數據，因此task2不斷檢查隊列項，如果有1，那么它可以讀取數據，否則它必須等到它變成1。取完數據后，task2將隊列遞減，使其為0，即task1再次可以將數據發送到task2。

從上面的例子可以說，二進制信號量是用于任務之間或任務與中斷之間的同步。

2. Counting Semaphore：它的值大于0，可以認為是長度大于1的隊列。這個semaphore用于對事件進行計數。在這種使用場景中，事件處理程序將在每次事件發生時“給予”一個信號量（增加信號量計數值），而處理程序任務將在每次處理事件時“獲取”一個信號量（減少信號量計數值） 。

因此，計數值是已發生的事件數與已處理的事件數之差。

現在，讓我們看看如何在我們的 FreeRTOS 代碼中使用 Semaphore。

如何在 FreeRTOS 中使用信號量？

FreeRTOS 支持用于創建信號量、獲取信號量和提供信號量的不同 API。

現在，同一個內核對象可以有兩種類型的 API。如果我們必須從 ISR 提供??信號量，則無法使用正常的信號量 API。您應該使用受中斷保護的 API。

在本教程中，我們將使用二進制信號量，因為它易于理解和實現。由于此處使用了中斷功能，因此您需要在 ISR 功能中使用受中斷保護的 API。當我們說將任務與中斷同步時，這意味著在 ISR 之后立即將任務置于運行狀態。

創建信號量：

要使用任何內核對象，我們必須首先創建它。要創建二進制信號量，請使用vSemaphoreCreateBinary（）。

此 API 不接受任何參數，并返回 SemaphoreHandle_t 類型的變量。創建一個全局變量名sema_v來存儲信號量。

SemaphoreHandle_t sema_v;

sema_v = xSemaphoreCreateBinary（）;

給出信號量：

對于提供信號量，有兩種版本——一種用于中斷，另一種用于正常任務。

xSemaphoreGive（）：這個 API 只接受一個參數，它是信號量的變量名，如上面在創建信號量時給出的 sema_v。它可以從您想要同步的任何正常任務中調用。

xSemaphoreGiveFromISR（）：這是 xSemaphoreGive（） 的受中斷保護的 API 版本。當我們需要同步 ISR 和普通任務時，應該從 ISR 函數中使用 xSemaphoreGiveFromISR（）。

獲取信號量：

要獲取信號量，請使用 API 函數xSemaphoreTake（）。這個 API 有兩個參數。

xSemaphoreTake（SemaphoreHandle_t xSemaphore， TickType_t xTicksToWait）;

xSemaphore：在我們的案例 sema_v 中要采用的信號量的名稱。

xTicksToWait：這是任務在阻塞狀態下等待信號量變為可用的最長時間。在我們的項目中，我們將 xTicksToWait 設置為portMAX_DELAY以使 task_1 無限期地等待阻塞狀態，直到 sema_v 可用。

現在，讓我們使用這些 API 并編寫代碼來執行一些任務。

這里連接了一個按鈕和兩個 LED。按鈕將充當連接到 Arduino Uno 引腳 2 的中斷按鈕。按下此按鈕時將產生中斷，連接到引腳 8 的 LED 將打開，再次按下時將關閉。

因此，當按下按鈕時，將從 ISR 函數調用xSemaphoreGiveFromISR （），從 TaskLED 函數調用 xSemaphoreTake（） 函數。

為了使系統看起來多任務，將其他 LED 連接到引腳 7，引腳 7 將始終處于閃爍狀態。

信號量代碼說明

讓我們通過打開 Arduino IDE 開始編寫代碼

1. 首先，包含Arduino_FreeRTOS.h頭文件。現在，如果使用任何內核對象，如隊列信號量，則還必須包含一個頭文件。

#include  
#include 

2.聲明一個SemaphoreHandle_t類型的變量來存儲信號量的值。

SemaphoreHandle_t 中斷信號量；

3. 在 void setup() 中，使用 xTaskCreate() API 創建兩個任務（TaskLED 和 TaskBlink），然后使用 xSemaphoreCreateBinary() 創建一個信號量。創建一個具有相同優先級的任務，然后嘗試使用這個數字。此外，將引腳 2 配置為輸入并啟用內部上拉電阻并連接中斷引腳。最后，啟動調度程序，如下所示。

無效設置（）{ 
  pinMode（2，INPUT_PULLUP）；
  xTaskCreate(TaskLed, "Led", 128, NULL, 0, NULL ); 
xTaskCreate(TaskBlink, "LedBlink", 128, NULL, 0, NULL ); 
  中斷信號量 = xSemaphoreCreateBinary(); 
  if (interruptSemaphore != NULL) { 
    attachInterrupt(digitalPinToInterrupt(2), debounceInterrupt, LOW); 
  } 
}

4. 現在，實現 ISR 功能。創建一個函數并將其命名為與attachInterrupt()函數的第二個參數相同。為了使中斷正常工作，您需要使用millis或micros功能并通過調整去抖時間來消除按鈕的去抖問題。從此函數調用interruptHandler()函數，如下所示。

長去抖時間 = 150; 
volatile unsigned long last_micros; 
void debounceInterrupt() { 
if((long)(micros() - last_micros) >= debounce_time * 1000) { 
interruptHandler(); 
last_micros = micros(); 
} 
}

在interruptHandler()函數中，調用xSemaphoreGiveFromISR()API。

void interruptHandler() { 
xSemaphoreGiveFromISR(interruptSemaphore, NULL); 
}

這個函數會給TaskLed一個信號量來打開LED。

5. 創建一個TaskLed函數并在while循環中調用xSemaphoreTake()API 并檢查信號量是否被成功獲取。如果它等于 pdPASS（即 1），則使 LED 切換如下所示。

void TaskLed(void *pvParameters) 
{ 
(void) pvParameters; 
pinMode（8，輸出）；
while(1) { 
if (xSemaphoreTake(interruptSemaphore, portMAX_DELAY) == pdPASS) { 
digitalWrite(8, !digitalRead(8)); 
}   
} 
}

6. 另外，創建一個函數來閃爍連接到引腳 7 的其他 LED。

void TaskLed1(void *pvParameters) 
{ 
(void) pvParameters; 
pinMode（7，輸出）；
而（1）{
數字寫入（7，高）；
vTaskDelay(200 / portTICK_PERIOD_MS); 
數字寫入（7，低）；
vTaskDelay(200 / portTICK_PERIOD_MS); 
} 
}

7. void 循環函數將保持為空。不要忘記它。

無效循環（）{}

就是這樣，完整的代碼可以在本教程的末尾找到。現在，上傳此代碼并根據電路圖將 LED 和按鈕與 Arduino UNO 連接起來。

電路原理圖

上傳代碼后，您會看到一個 LED 在 200 毫秒后閃爍，當按下按鈕時，第二個 LED 會立即發光，如最后給出的視頻所示。

通過這種方式，信號量可以在帶有 Arduino 的 FreeRTOS 中使用，它需要將數據從一個任務傳遞到另一個任務而不會造成任何損失。

現在，讓我們看看什么是 Mutex 以及如何使用 FreeRTOS。

什么是互斥鎖？

如上所述，信號量是一種信號機制，類似地，Mutex 是一種鎖定機制，與信號量不同，信號量具有單獨的遞增和遞減函數，但在 Mutex 中，函數本身接受和給出。這是一種避免共享資源損壞的技術。

為了保護共享資源，需要為資源分配一個令牌卡（互斥體）。擁有這張卡的人可以訪問其他資源。其他人應該等到卡歸還。這樣，只有一個資源可以訪問任務，其他資源等待機會。

讓我們通過一個例子來了解FreeRTOS 中的 Mutex 。

這里我們有三個任務，一個用于在 LCD 上打印數據，第二個用于將 LDR 數據發送到 LCD 任務，最后一個任務用于在 LCD 上發送溫度數據。所以這里兩個任務共享相同的資源，即 LCD。如果 LDR 任務和溫度任務同時發送數據，則其中一個數據可能損壞或丟失。

因此，為了防止數據丟失，我們需要鎖定 task1 的 LCD 資源，直到它完成顯示任務。然后 LCD 任務將解鎖，然后 task2 可以執行其工作。

您可以在下圖中觀察互斥量和信號量的工作。

如何在 FreeRTOS 中使用互斥鎖？

互斥量的使用方式也與信號量相同。首先，創建它，然后使用各自的 API 提供和獲取。

創建互斥鎖：

要創建互斥體，請使用xSemaphoreCreateMutex（） API。顧名思義，互斥量是一種二進制信號量。它們用于不同的上下文和目的。二進制信號量用于同步任務，而 Mutex 用于保護共享資源。

此 API 不接受任何參數并返回SemaphoreHandle_t類型的變量。如果無法創建互斥鎖，則xSemaphoreCreateMutex（）返回 NULL。

SemaphoreHandle_t mutex_v;

mutex_v = xSemaphoreCreateMutex（）;

采取互斥鎖：

當任務想要訪問資源時，它將使用xSemaphoreTake（） API 獲取 Mutex。它與二進制信號量相同。它還需要兩個參數。

xSemaphore：在我們的例子中使用的 Mutex 的名稱mutex_v。

xTicksToWait：這是任務在阻塞狀態下等待 Mutex 可用的最長時間。在我們的項目中，我們將 xTicksToWait 設置為portMAX_DELAY以使 task_1 在 Blocked 狀態下無限期等待，直到mutex_v可用。

提供互斥鎖：

訪問共享資源后，任務應該返回 Mutex，以便其他任務可以訪問它。xSemaphoreGive（） API 用于返回 Mutex。

xSemaphoreGive（） 函數只接受一個參數，即在我們的案例 mutex_v 中給出的 Mutex。

使用上述 API，讓我們使用 Arduino IDE 在 FreeRTOS 代碼中實現 Mutex。

互斥代碼說明

這部分的目標是使用串行監視器作為共享資源和兩個不同的任務來訪問串行監視器以打印一些消息。

1. 頭文件將保持與信號量相同。

#include  
#include 

2. 聲明一個SemaphoreHandle_t類型的變量來存儲 Mutex 的值。

SemaphoreHandle_t mutex_v;

3. 在void setup() 中，以 9600 波特率初始化串行監視器，并使用xTaskCreate()API 創建兩個任務（Task1 和 Task2）。然后使用xSemaphoreCreateMutex()創建一個 Mutex 。創建一個具有相同優先級的任務，然后嘗試使用這個數字。

無效設置（）{
序列.開始（9600）；
mutex_v = xSemaphoreCreateMutex(); 
if (mutex_v == NULL) { 
Serial.println("無法創建互斥鎖"); 
} 
xTaskCreate(Task1, "任務 1", 128, NULL, 1, NULL); 
xTaskCreate(Task2, "任務 2", 128, NULL, 1, NULL); 
}

4. 現在，為Task1 和Task2 制作任務函數。在任務函數的while循環中，在串行監視器上打印消息之前，我們必須使用xSemaphoreTake()獲取 Mutex ，然后打印消息，然后使用xSemaphoreGive() 返回 Mutex。然后再拖延一些時間。

void Task1(void *pvParameters) { 
while(1) { 
xSemaphoreTake(mutex_v, portMAX_DELAY); 
Serial.println("來自 Task1 的您好"); 
xSemaphoreGive(mutex_v); 
vTaskDelay(pdMS_TO_TICKS(1000)); 
} 
}

同理，實現延遲500ms的Task2函數。

5. void loop()將保持為空。

現在，將此代碼上傳到 Arduino UNO 并打開串行監視器。

您將看到正在從 task1 和 task2 打印消息。

要測試 Mutex 的工作，只需注釋xSemaphoreGive（mutex_v）; 從任何任務。您可以看到程序掛在最后一條打印消息上。

這就是使用 Arduino 在 FreeRTOS 中實現信號量和互斥量的方式。

信號量代碼：

#include
#include
長去抖時間 = 150;
volatile unsigned long last_micros;

SemaphoreHandle_t 中斷信號量；

無效設置（）{
pinMode(2, INPUT_PULLUP);
xTaskCreate(TaskLed, "Led", 128, NULL, 0, NULL );
xTaskCreate(TaskBlink, "LedBlink", 128, NULL, 0, NULL );
中斷信號量 = xSemaphoreCreateBinary();
如果（中斷信號量！= NULL）{
attachInterrupt(digitalPinToInterrupt(2), debounceInterrupt, LOW);
}
}

無效循環（）{}

無效中斷處理程序（）{
xSemaphoreGiveFromISR(interruptSemaphore, NULL);
}

void TaskLed(void *pvParameters)
{
(void) pvParameters；
pinMode（8，輸出）；
為了 （;;） {
if (xSemaphoreTake(interruptSemaphore, portMAX_DELAY) == pdPASS) {
數字寫入（8，！數字讀取（8））；
}
}
}
void TaskBlink(void *pvParameters)
{
(void) pvParameters；
pinMode（7，輸出）；
為了 （;;） {
數字寫入（7，高）；
vTaskDelay(200 / portTICK_PERIOD_MS);
數字寫入（7，低）；
vTaskDelay(200 / portTICK_PERIOD_MS);
}
}
無效去抖中斷（）{
if((long)(micros() - last_micros) >= debouncing_time * 1000) {
中斷處理程序（）；
last_micros = micros();
}
}

互斥體代碼：
#include
#include

SemaphoreHandle_t mutex_v;
無效設置（）{
序列號.開始（9600）；
mutex_v = xSemaphoreCreateMutex();
if (mutex_v == NULL) {
Serial.println("無法創建互斥鎖");
}
xTaskCreate(Task1, "Task1", 128, NULL, 1, NULL);
xTaskCreate(Task2, "Task2", 128, NULL, 1, NULL);
}

無效任務1（無效* pvParameters）{
而（1）{
xSemaphoreTake(mutex_v, portMAX_DELAY);
Serial.println("來自 Task1 的您好");
xSemaphoreGive(mutex_v);
vTaskDelay(pdMS_TO_TICKS(1000));
}
}

void Task2(void *pvParameters) {
而（1）{
xSemaphoreTake(mutex_v, portMAX_DELAY);
Serial.println("來自 Task2 的您好");
xSemaphoreGive(mutex_v);
vTaskDelay(pdMS_TO_TICKS(500));
}
}

無效循環（）{
}