Привет, Хабр!

Это четвертая статья из цикла по ESP-IDF. Как и обещал, сегодня мы рассмотрим мьютексы и семафоры на простых (и не очень) примерах.

А зачем мне они вообще нужны?...

Попробую ответить на вопрос, который может возникнуть у многих - а зачем мне вообще изучать семафоры и мьютексы мне вполне для синхронизации хватит очередей?

Легенда:

Смоделируем ситуацию: вы — стажёр в офисе, у вас есть коллега-стажёр Виталя и начальник Колян. В вашем уютном офисе есть почтовый ящик (очередь): кто-то (producer) бросает туда письмо (данные или команду), а кто‑то другой (consumer) его забирает и обрабатывает. Итог:

• Почтовый ящик (единственный) на офис, куда стажёры кладут письма. [очередь]

• Два стажёра (Вы и Виталя), которые готовят письма и носят их в ящик. [producer]

• Начальник (Колян), который иногда проверяет ящик и забирает письма, чтобы их отправить. [consumer]

1. Мьютекс: «Ключ от почтового ящика»

Почтовый ящик — это механический ящик с замком. У него есть один ключ, и пока кто‑то держит ключ, другие не умеют открыть крышку.

• Когда стажёр (Вы) подходит к ящику, он берёт ключ (вызывает xSemaphoreTake(mutex)), открывает крышку, кладёт письмо, закрывает и возвращает ключ (xSemaphoreGive(mutex)).

• Если в этот момент второй стажёр (Виталя) пытается открыть ящик, ему придётся ждать, пока Вы вернёте ключ.

Зачем?

Без мьютекса оба стажёра яростно пытались бы залезть в этот ящик и как можно быстрее сбросить туда свои письма. Ящик мог бы зависнуть в полузакрытом состоянии. Мьютекс гарантирует, что Виталя дождётся, когда вы отдадите ему ключ, и не будет пытаться опередить вас.

Кроме того, если у Коляна (начальника) очень важная задача по проверке ящика (высокий приоритет), а тут два стажёра «тупят», весь бизнес накрылся бы медным тазом. Здесь вступает ещё одна фича — priority inheritance. Она повысит приоритет стажёра, держащего ключ (мьютекс), чтобы он быстрее освободил ресурс, плюс его не перебил второй стажёр, и начальник (высокоприоритетная задача) не стоял в ожидании.

2. Бинарный семафор: «Сигнал о письме»

Ситуация. После того как стажёр кладёт письмо в ящик, он звонит начальнику (Коляну), чтобы он проверил ящик.

Зачем?

Семафор здесь — простой способ передать событие “готово письмо” из стажёра начальнику. Без семафора Вика бы бесконечно опрашивала ящик (polling), тратя энергию и время.

3. Счётный семафор: «Ограничение по ячейкам»

Ситуация. У вас есть только небольшой ящик, в который может поместиться не более трёх писем. Вы решили, что проверять ящик будет начальник только тогда, когда в нём накопится два и более писем. По факту это работа с обычным счетчиком.

Двоичные семафоры FreeRTOS

Двоичный семафор — это семафор, максимальный счетчик которого равен 1, отсюда и название «двоичный». Задача может «взять» семафор, только если он доступен, а семафор доступен, только если его счетчик равен 1.

в FreeRTOS двоичный семафор реализован как очередь длиной в 1 элемент, размером в 0 байт, где важен только факт — «есть разрешение» или «нет»

• Он может быть только полон (после give) или пуст (после take), как очередь ёмкостью один.

• Все, что вы делаете — либо give, либо take.

• Данные не передаются (размер элемента = 0), передаётся лишь сам факт события: дали — значит событие произошло, взяли — значит событие обработано.

Функции API семафоров позволяют задать время блокировки. Время блокировки определяет максимальное количество тактов, на которые задача должна перейти в состояние «Блокировано» при попытке «занять» семафор, если семафор недоступен немедленно. Если на одном семафоре заблокировано несколько задач, то при следующем освобождении семафора разблокируется задача с наивысшим приоритетом.

Основные API двоичного семафора

Создание двоичного семафора

SemaphoreHandle_t sem = xSemaphoreCreateBinary();

— выделяет под семафор очередь ёмкостью в один «слот» (элемент размером 0).

Отдача (Give)

Из задачи:

xSemaphoreGive(sem);

Из ISR:

BaseType_t woken = pdFALSE;
xSemaphoreGiveFromISR(sem, &woken);
portYIELD_FROM_ISR(woken);

Взятие (Take)

if (xSemaphoreTake(sem, portMAX_DELAY) == pdTRUE) {
    // семафор успешно взят
}

— блокирует текущую задачу до тех пор, пока семафор не станет «полным» (Give), после чего возвращает pdTRUE; при этом семафор снова переходит в пустое состояние и требует нового Give перед следующим Take.

Пример

Рассмотрим пример, когда задача используется для обслуживания периферийного устройства. Опрос периферийного устройства будет пустой тратой ресурсов и помешает выполнению других задач. Поэтому предпочтительно, чтобы задача проводила большую часть времени в заблокированном состоянии (позволяя другим задачам выполняться) и выполнялась только тогда, когда ей действительно нужно что-то сделать. Это достигается с помощью двоичного семафора: задача блокируется при попытке «захватить» семафор. Затем для периферийного устройства пишется процедура прерывания, которая просто «выдаёт» семафор, когда периферийному устройству требуется обслуживание.

Немного перепишем наше прерывание, которое мы написали пару уроков назад:

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/gpio.h"
#include "esp_attr.h"
#include "esp_log.h"

#define LED_GPIO    GPIO_NUM_2     // Пин, к которому подключён светодиод
#define BUTTON_GPIO GPIO_NUM_23    // Пин, к которому подключена кнопка

TaskHandle_t Blink_Handle = NULL;  // Дескриптор задачи Blink

static const char *TAG = "binary_sem";

// Бинарный семафор для синхронизации кнопка→задача
static SemaphoreHandle_t button_sem = NULL;

// Задача, которая постоянно устанавливает уровень на LED_GPIO согласно state
void Blink_Task(void *arg) {
    while (1) {
        if(xSemaphoreTake(button_sem, portMAX_DELAY)){
            ESP_LOGI(TAG, "Button pressed!");
            // Включаем LED на 500 мс
            gpio_set_level(LED_GPIO, 1);
            vTaskDelay(pdMS_TO_TICKS(500));
            gpio_set_level(LED_GPIO, 0);
        }
    }
}

/*
    Обработчик прерывания от кнопки.
    Просто инвертирует переменную state.
    IRAM_ATTR — атрибут, гарантирующий, что этот код попадёт в быстрый IRAM,
    а не во флеш (важно для надёжности ISR).
*/
static void IRAM_ATTR gpio_isr_handler(void *arg) {
    BaseType_t woken = pdFALSE;
    xSemaphoreGiveFromISR(button_sem, &woken);
    portYIELD_FROM_ISR(woken);
}

void app_main() {
    // Создаём бинарный семафор (он будет пустым)
    button_sem = xSemaphoreCreateBinary();
    if (button_sem == NULL) {
        ESP_LOGE(TAG, "Failed to create semaphore");
        return;
    }
    esp_rom_gpio_pad_select_gpio(LED_GPIO);          // "Переключение" выбранного физического контакта в режим GPIO
    gpio_set_direction(LED_GPIO, GPIO_MODE_OUTPUT);  // Настройка LED_GPIO как цифровой вывод

    gpio_set_level(LED_GPIO, 0);   // сразу гасим

    esp_rom_gpio_pad_select_gpio(BUTTON_GPIO);          // "Переключение" выбранного физического контакта в режим GPIO
    gpio_set_direction(BUTTON_GPIO, GPIO_MODE_INPUT);   // Настройка BUTTON_GPIO как входа

    gpio_pullup_en(BUTTON_GPIO);    // Подтяжка к VCC

    gpio_set_intr_type(BUTTON_GPIO, GPIO_INTR_POSEDGE); // Прерывание при нажатии (положительный фронт)

    gpio_install_isr_service(ESP_INTR_FLAG_IRAM);       // Устанавливаем сервис ISR 
 
    gpio_isr_handler_add(BUTTON_GPIO, gpio_isr_handler, NULL);  // Регистрируем функцию-обработчик прерывания

    gpio_intr_enable(BUTTON_GPIO);  // Включаем прерывания для кнопки

    // Создаём задачу “мигания” по семафору
    if (xTaskCreate(Blink_Task, "BLINK", 2048, NULL, 5, &Blink_Handle) != pdPASS) {
        ESP_LOGE(TAG, "Failed to create Blink_Task");
    }
}

Создаем

// Бинарный семафор для синхронизации кнопка→задача
static SemaphoreHandle_t button_sem = NULL;

button_sem = xSemaphoreCreateBinary();
if (button_sem == NULL) {
    ESP_LOGE(TAG, "Failed to create semaphore");
    return;
}

Даем

// ISR: при спаде кнопки «даём» семафор
static void IRAM_ATTR button_isr(void *arg) {
    BaseType_t woken = pdFALSE;
    xSemaphoreGiveFromISR(button_sem, &woken);
    portYIELD_FROM_ISR(woken);
}

Получаем

// Блокируемся, пока семафор не «дадут»
if (xSemaphoreTake(button_sem, portMAX_DELAY) == pdTRUE) {
    ESP_LOGI(TAG, "Button pressed!");
    // Включаем LED на 500 мс
    gpio_set_level(LED_GPIO, 1);
    vTaskDelay(pdMS_TO_TICKS(500));
    gpio_set_level(LED_GPIO, 0);
}

FreeRTOS Подсчет семафоров

Подобно тому, как двоичные семафоры можно рассматривать как очереди длиной один элемент, счётные семафоры можно рассматривать как очереди длиной больше одного элемента.

Счётный семафор расширяет идею бинарного: вместо одного флага он хранит счетчик от 0 до заданного максимума. Это полезно, когда нужно накопить несколько событий или разрешений и обработать их по одному.

Основные API счетного семафора

Взятие (xSemaphoreTake) и отдача (xSemaphoreGive / xSemaphoreGiveFromISR) у двоичного и счётного семафоров абсолютно одинаковы по API — единственное отличие в том, как вы их создаёте.

Создание счетного семафора

// uxMaxCount = 5, uxInitialCount = 0
SemaphoreHandle_t sem = xSemaphoreCreateCounting(5, 0);

— при создании вы указываете максимальное (uxMaxCount) и начальное (uxInitialCount) значение счётчика:

Пример

Сделаем мини‑игру: если мы успеем нажать на кнопку более трёх раз за 5 секунд, то увидим три быстрых мигания, а если нет — одно.

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "freertos/semphr.h"
#include "driver/gpio.h"
#include "esp_attr.h"
#include "esp_log.h"

#define LED_GPIO    GPIO_NUM_2     // Пин, к которому подключён светодиод
#define BUTTON_GPIO GPIO_NUM_23    // Пин, к которому подключена кнопка

TaskHandle_t Blink_Handle = NULL;  // Дескриптор задачи Blink

static const char *TAG = "counting_sem";

// Семафор
static SemaphoreHandle_t button_sem = NULL;

// Задача
void Blink_Task(void *arg) {
    int count;
    while (1) {
        // Ждём 5 секунд
        vTaskDelay(pdMS_TO_TICKS(5000));

        // Считаем накопленные нажатия
        count = 0;
        while(xSemaphoreTake(button_sem, 0) == pdTRUE){
            count++;
        }
        ESP_LOGI(TAG, "Button pressed %d times in last 5s", count);

            if (count >= 3) {
                // 3 быстрых моргания
                for (int i = 0; i < 3; i++) {
                    gpio_set_level(LED_GPIO, 1);
                    vTaskDelay(pdMS_TO_TICKS(200));
                    gpio_set_level(LED_GPIO, 0);
                    vTaskDelay(pdMS_TO_TICKS(200));
                }
            } else {
                // Одно долгое
                gpio_set_level(LED_GPIO, 1);
                vTaskDelay(pdMS_TO_TICKS(1000));
                gpio_set_level(LED_GPIO, 0);
            }
    }
}

// ISR: при каждом нажатии ++счётчик
static void IRAM_ATTR gpio_isr_handler(void *arg) {
    BaseType_t woken = pdFALSE;
    xSemaphoreGiveFromISR(button_sem, &woken);
    portYIELD_FROM_ISR(woken);
}

void app_main() {
    // Создаём счётный семафор (максимум 10, изначально 0)
    button_sem = xSemaphoreCreateCounting(10, 0);
    if (button_sem == NULL) {
        ESP_LOGE(TAG, "Failed to create semaphore");
        return;
    }
    esp_rom_gpio_pad_select_gpio(LED_GPIO);          // "Переключение" выбранного физического контакта в режим GPIO
    gpio_set_direction(LED_GPIO, GPIO_MODE_OUTPUT);  // Настройка LED_GPIO как цифровой вывод

    gpio_set_level(LED_GPIO, 0);   // сразу гасим

    esp_rom_gpio_pad_select_gpio(BUTTON_GPIO);          // "Переключение" выбранного физического контакта в режим GPIO
    gpio_set_direction(BUTTON_GPIO, GPIO_MODE_INPUT);   // Настройка BUTTON_GPIO как входа

    gpio_pullup_en(BUTTON_GPIO);    // Подтяжка к VCC

    gpio_set_intr_type(BUTTON_GPIO, GPIO_INTR_POSEDGE); // Прерывание при нажатии (положительный фронт)

    gpio_install_isr_service(ESP_INTR_FLAG_IRAM);       // Устанавливаем сервис ISR 
 
    gpio_isr_handler_add(BUTTON_GPIO, gpio_isr_handler, NULL);  // Регистрируем функцию-обработчик прерывания

    gpio_intr_enable(BUTTON_GPIO);  // Включаем прерывания для кнопки

    // Создаём задачу “мигания” по семафору
    if (xTaskCreate(Blink_Task, "BLINK", 2048, NULL, 5, &Blink_Handle) != pdPASS) {
        ESP_LOGE(TAG, "Failed to create Blink_Task");
    }
}

Мьютексы FreeRTOS

Двоичные семафоры и мьютексы очень похожи, но имеют некоторые тонкие различия: мьютексы включают механизм наследования приоритетов (priority inheritance), а двоичные семафоры — нет. Мьютексы отлично подходят для взаимного исключения.

Немного подробно про priority inheritance

Когда несколько задач разного приоритета борются за один и тот же ресурс (мьютекс), может возникнуть классическая проблема priority inversion:

• Задача L (Low‑prio) берёт мьютекс и входит в критическую секцию.

• Задача H (High‑prio) просыпается и пытается взять тот же мьютекс → блокируется, потому что L ещё не вернула мьютекс.

• Задача M (Med‑prio) с приоритетом между L и H может встать на выполнение и «перекрыть» L, потому что H в очереди ждёт мьютекс и не может выполнить свою работу и вернуть управление.

В результате H простаивает, а L не получает CPU, чтобы освободить мьютекс — и весь алгоритм может «зависнуть» на задаче среднего приоритета, даже если H гораздо важнее.

Как работает priority inheritance

FreeRTOS при захвате мьютекса автоматически сравнивает приоритеты владельца и ожидающей задачи:

• Если владелец мьютекса (L) имеет приоритет ниже, чем ожидающая задача (H), то у L временно повышается приоритет до уровня H.

• Это даёт L право продолжить выполняться даже в присутствии средних задач M, чтобы как можно скорее выйти из критической секции и вернуть мьютекс.

• Как только L делает xSemaphoreGive(mutex), его приоритет возвращается к исходному значению, и планировщик снова сможет запустить H (или M, если H уже выполнена).

Спасибо, что дочитали до конца! Прошу прощения за долгое затишье — в ближайшее время выйдет новая статья, в которой мы продолжим изучать esp-idf. Буду рад вашим вопросам и пожеланиям в комментариях — пишите, о чём вам было бы интересно узнать в следующих материалах!