Руководства · 11 мин чтения

ESP32 FreeRTOS: два ядра, задачи, очереди и семафоры

ESP32 FreeRTOS: xTaskCreatePinnedToCore, приоритеты, delay и vTaskDelay, очереди, семафоры, стек и сторожевой таймер. Запусти светодиод, датчик и веб-сервер одновременно.

ESP32 FreeRTOS — операционная система реального времени, которая уже работает внутри ESP32 и позволяет выполнять несколько дел одновременно. Каждый скетч для ESP32, который ты пишешь в Arduino IDE, на самом деле работает поверх FreeRTOS: функции setup() и loop() выполняются внутри задачи loopTask на одном из двух ядер ESP32. Создавая собственные задачи, ты можешь одновременно мигать светодиодом, считывать датчик и отвечать на запросы веб-сервера, причём ни одна задача не задерживает остальные. Подход «несколько дел одновременно», который на Arduino Uno приходится строить с помощью millis(), на ESP32 получает гораздо более понятную структуру.

В этом руководстве ты узнаешь, как распределяется работа между двумя ядрами ESP32 и на каком ядре работает Wi-Fi. Затем мы создадим задачи с помощью xTaskCreatePinnedToCore, привяжем их к определённому ядру, зададим приоритеты и разберём разницу между delay() и vTaskDelay(). Мы используем очередь для безопасной передачи данных между задачами, семафор для пробуждения задачи из прерывания кнопки и мьютекс для защиты общего монитора порта. Разобрав размер стека и ошибки сторожевого таймера, соберём полный пример с одновременной работой светодиода, датчика и веб-сервера. В конце кратко сравним этот подход с двумя ядрами Raspberry Pi Pico.

Отладочная плата ESP32
Классическая ESP32 имеет два ядра Xtensa LX6 и с помощью FreeRTOS может выполнять отдельные задачи на каждом из них.

Что такое ESP32 FreeRTOS и как работают два ядра?

В FreeRTOS каждое дело — это задача. Задача представляет собой обычную функцию C с собственным стеком и приоритетом, обычно содержащую бесконечный цикл. На каждом ядре планировщик FreeRTOS выбирает задачу с наивысшим приоритетом среди готовых к выполнению. Когда задача ожидает с помощью vTaskDelay(), ждёт данных из очереди или семафора, ядро сразу передаётся другой задаче. Задачи с одинаковым приоритетом выполняются по очереди, сменяя друг друга на каждом тике. В ядре ESP32 для Arduino тик длится 1 мс (1 000 тиков в секунду), поэтому vTaskDelay(100) ждёт примерно 100 мс. У классической ESP32 два ядра: ядро 0 (PRO_CPU) и ядро 1 (APP_CPU). Espressif размещает беспроводную связь на ядре 0, а твой код — на ядре 1, поэтому работа Wi-Fi не прерывает твой цикл. При стандартных настройках Arduino на ядрах выполняется следующее:

ЗадачаЯдроПриоритетНазначение
loopTask (setup и loop)11Твой код Arduino, стек 8 192 байта
Драйвер Wi-Fi023Радиосвязь и протокол Wi-Fi
lwIP (tcpip)018Стек TCP/IP, пакеты веб-сервера и MQTT
Bluetooth (BT/BLE)0ВысокийКонтроллер Bluetooth и Bluedroid
esp_timer022Программные таймеры
IDLE0 и IDLE10 и 10Задачи простоя; обслуживают сторожевой таймер и освобождают память удалённых задач

Из этой таблицы следуют два важных вывода. Во-первых, у задач Wi-Fi и TCP/IP очень высокий приоритет: если разместить собственную тяжёлую задачу на ядре 0, они будут прерывать её при поступлении сетевого трафика, а если твоя задача надолго займёт ядро, работа Wi-Fi ухудшится. Во-вторых, приоритет loopTask равен всего 1: если на ядре 1 разместить задачу с более высоким приоритетом, которая никогда не переходит в ожидание, loop() не выполнится ни разу. ESP32-S3 тоже двухъядерная. ESP32-S2, ESP32-C3 и ESP32-C6 — одноядерные; на этих платах тоже можно создавать задачи, но все они делят одно ядро.

Подключение

Для примеров из этой статьи тебе понадобятся ESP32 DevKit, два светодиода, потенциометр и тактовая кнопка. Синий светодиод на плате подключён к GPIO 2; второй светодиод подключи к GPIO 4 через резистор 220 Ω. Потенциометр подключаем к GPIO 34, каналу ADC1, поскольку при включённом Wi-Fi считывать пины ADC2 нельзя.

ДетальПин ESP32Примечание
Встроенный светодиодGPIO 2Есть на большинстве плат DevKit
Второй светодиодGPIO 4Последовательный резистор 220 Ω, короткая ножка к GND
Движок потенциометраGPIO 34Только вход, ADC1; крайние выводы к 3V3 и GND
КнопкаGPIO 27Другая ножка к GND, используется INPUT_PULLUP
Подключай крайний вывод потенциометра к 3V3, а не к 5V. Пины ESP32 работают при 3,3 V и не допускают 5 V. В проектах с Wi-Fi подключай аналоговые датчики к пинам ADC1 GPIO 32–39; пины ADC2 (GPIO 0, 2, 4, 12–15, 25–27) нельзя считывать через analogRead() при включённом Wi-Fi. Проверить выбор пина можно в утилите распиновки.

Первые задачи с xTaskCreatePinnedToCore

В первом примере два светодиода мигают с разной скоростью под управлением двух отдельных задач на разных ядрах. Каждая функция задачи имеет вид void function(void *parameter) и содержит бесконечный цикл. Функция xTaskCreatePinnedToCore(), запускающая задачу, также указывает, на каком ядре её выполнять. Обрати внимание: мы дважды используем одну функцию задачи и каждый раз передаём разную структуру настроек; благодаря параметру одна функция независимо управляет двумя светодиодами.

C++ (Arduino IDE)
1// İki LED, iki görev, iki çekirdek / two LEDs, two tasks, two cores
2struct LedAyari {
3  int pin;          // LED pini / LED pin
4  int beklemeMs;    // yarım periyot / half period
5};
6
7LedAyari led1 = {2, 250};   // dahili LED, hızlı / onboard LED, fast
8LedAyari led2 = {4, 700};   // harici LED, yavaş / external LED, slow
9
10void ledGorevi(void *parametre) {
11  LedAyari *ayar = (LedAyari *)parametre;
12  pinMode(ayar->pin, OUTPUT);
13  for (;;) {                                         // görev asla bitmez / a task never returns
14    digitalWrite(ayar->pin, !digitalRead(ayar->pin));
15    vTaskDelay(pdMS_TO_TICKS(ayar->beklemeMs));      // çekirdeği bırak / give the core away
16  }
17}
18
19void setup() {
20  Serial.begin(115200);
21  // fonksiyon, ad, yığın (bayt), parametre, öncelik, tutamaç, çekirdek
22  // function, name, stack (bytes), parameter, priority, handle, core
23  xTaskCreatePinnedToCore(ledGorevi, "LED1", 2048, &led1, 1, NULL, 0);
24  xTaskCreatePinnedToCore(ledGorevi, "LED2", 2048, &led2, 1, NULL, 1);
25}
26
27void loop() {
28  Serial.printf("loop() cekirdek / core: %d\n", xPortGetCoreID());
29  delay(1000);                                       // ESP32'de delay de çekirdeği bırakır / delay yields on ESP32 too
30}

После загрузки кода два светодиода мигают независимо, а монитор порта показывает, что loop() работает на ядре 1. Вот параметры функции:

ПараметрЗначение в примереЗначение параметра
pvTaskCodeledGoreviФункция, которую выполняет задача
pcName"LED1"Имя, отображаемое при отладке, до 16 символов
usStackDepth2048Размер стека; на ESP32 задаётся в байтах
pvParameters&led1Указатель, передаваемый задаче; должен указывать на глобальную или статическую переменную
uxPriority1Приоритет от 0 (самый низкий) до 24
pvCreatedTaskNULLДескриптор для последующей остановки или наблюдения за задачей
xCoreID0 или 1Ядро для выполнения; с tskNO_AFFINITY задача работает на любом свободном ядре
Функция задачи никогда не должна завершаться через return; иначе ESP32 сообщит об ошибке и перезапустится. Если задача закончила работу, удали её вызовом vTaskDelete(NULL) в последней строке. Также не передавай в качестве параметра задачи адрес локальной переменной из setup(): после завершения setup() эта переменная исчезает, и задача читает недействительный адрес. На одноядерных ESP32-C3, S2 и C6 в качестве номера ядра можно использовать только 0 или tskNO_AFFINITY; наиболее переносимый вариант — xTaskCreate(), который не выбирает ядро.

Сравнение delay(), vTaskDelay() и vTaskDelayUntil()

На Arduino Uno delay() полностью занимает процессор; во время ожидания больше ничего не выполняется. На ESP32 всё иначе: delay() в ядре Arduino на самом деле вызывает vTaskDelay(). Поэтому при delay(100) твоя задача засыпает на 100 мс, а ядро в это время выполняет другие задачи. Именно поэтому delay() работает и внутри задач; всё же запись vTaskDelay(pdMS_TO_TICKS(100)) в коде FreeRTOS яснее показывает намерение. Настоящая разница — в способах ожидания, которые занимают процессор: delayMicroseconds() и пустые циклы вроде while (millis() - t < 500) {} никогда не освобождают ядро. Подход с millis() на Arduino подробно разобран в статье millis() и delay().

СпособОсвобождает ядро?Когда использовать
delay(ms)Да (на ESP32 вызывает vTaskDelay)Простые задержки внутри loop()
vTaskDelay(pdMS_TO_TICKS(ms))ДаОжидание в задачах; задержка прибавляется ко времени работы
vTaskDelayUntil(&last, period)ДаИзмерения с постоянной частотой; точный период независимо от времени работы
delayMicroseconds(us)НетМикросекундные задержки в протоколах датчиков
while (millis() - t < ms) {}НетНе используй в задачах FreeRTOS: другие задачи не получают процессорного времени

Если в цикле используется vTaskDelay(100), а работа занимает 15 мс, цикл повторяется каждые 115 мс и погрешность со временем накапливается. Если нужно считывать датчик ровно каждые 100 мс, используй vTaskDelayUntil(): функция запоминает время предыдущего пробуждения и каждый раз будит задачу ровно через один период. В следующем разделе задача датчика использует этот способ.

Приоритеты задач: какая задача выполняется первой?

Если на ядре несколько задач готовы к выполнению, всегда выполняется задача с наивысшим приоритетом. Задача с меньшим приоритетом получает ядро только тогда, когда более приоритетные задачи ожидают. Это называется вытесняющим планированием по приоритетам: как только поступают данные, которых ждёт высокоприоритетная задача, задача с меньшим приоритетом прерывается. Так можно назначить высокий приоритет работе, требующей быстрой реакции, но есть ловушка: если высокоприоритетная задача никогда не ждёт, задачи с меньшим приоритетом вообще не выполняются. На практике хорошо работает такая схема:

  • Приоритет 1: Неспешная работа: обновление дисплея, вывод в монитор порта или веб-сервер. loop() тоже находится на этом уровне.
  • Приоритет 2–3: Работа, которую нужно выполнять вовремя: регулярное считывание датчиков, циклы управления и обработка кнопок.
  • Приоритет 4–5: Короткие задачи, пробуждаемые прерыванием и требующие немедленной реакции.
  • Избегай: Не назначай своим задачам приоритет 18 или выше; эти уровни принадлежат Wi-Fi, TCP/IP и системным таймерам.

Безопасная передача данных между задачами через очередь

Первое, что приходит в голову для передачи данных между задачами, — глобальная переменная, но две задачи могут обращаться к ней одновременно. Если одна задача читает многобайтовую структуру, пока другая её записывает, получается значение, наполовину старое, наполовину новое; такие ошибки появляются редко и случайно, поэтому их очень трудно найти. Решение FreeRTOS — очередь. Это последовательность элементов фиксированного размера, в которой данные передаются копированием: отправляющая задача оставляет копию через xQueueSend(), а принимающая забирает её через xQueueReceive(). Если очередь пуста, принимающая задача спит и не расходует процессорное время; она просыпается сразу после поступления данных. В примере ниже одна задача считывает потенциометр ровно каждые 100 мс и помещает показание в очередь вместе с меткой времени; вторая обрабатывает каждое показание, полученное из очереди.

C++ (Arduino IDE)
1// Sensör görevi -> kuyruk -> işleyici görev / sensor task -> queue -> consumer task
2const int POT_PIN = 34;                 // ADC1 pini / ADC1 pin
3
4struct Olcum {
5  uint16_t ham;                         // 0-4095 ham değer / raw value
6  float volt;                           // gerilim / voltage
7  uint32_t zaman;                       // ms cinsinden zaman / timestamp in ms
8};
9
10QueueHandle_t olcumKuyrugu;
11
12void sensorGorevi(void *parametre) {
13  TickType_t sonUyanma = xTaskGetTickCount();
14  for (;;) {
15    Olcum o;
16    o.ham = analogRead(POT_PIN);
17    o.volt = analogReadMilliVolts(POT_PIN) / 1000.0f;
18    o.zaman = millis();
19    if (xQueueSend(olcumKuyrugu, &o, 0) != pdPASS) {   // kuyruk doluysa bekleme / don't wait if full
20      Serial.println("Kuyruk dolu / Queue full");
21    }
22    vTaskDelayUntil(&sonUyanma, pdMS_TO_TICKS(100));   // tam 100 ms periyot / exact 100 ms period
23  }
24}
25
26void isleyiciGorev(void *parametre) {
27  Olcum o;
28  for (;;) {
29    // veri gelene kadar uyu / sleep until data arrives
30    if (xQueueReceive(olcumKuyrugu, &o, portMAX_DELAY) == pdPASS) {
31      Serial.printf("%lu ms  ham/raw: %4u  %.2f V  bekleyen/waiting: %u\n",
32                    (unsigned long)o.zaman, o.ham, o.volt,
33                    (unsigned)uxQueueMessagesWaiting(olcumKuyrugu));
34    }
35  }
36}
37
38void setup() {
39  Serial.begin(115200);
40  olcumKuyrugu = xQueueCreate(10, sizeof(Olcum));      // 10 ölçümlük kuyruk / queue of 10 readings
41  if (olcumKuyrugu == NULL) {
42    Serial.println("Kuyruk olusturulamadi / Queue creation failed");
43    return;
44  }
45  xTaskCreatePinnedToCore(sensorGorevi, "Sensor", 3072, NULL, 2, NULL, 1);
46  xTaskCreatePinnedToCore(isleyiciGorev, "Isleyici", 3072, NULL, 1, NULL, 1);
47}
48
49void loop() {
50  vTaskDelay(pdMS_TO_TICKS(1000));     // loop'un burada işi yok / loop has nothing to do here
51}

Поскольку приоритет задачи датчика (2) выше приоритета задачи-потребителя (1), измерения всегда выполняются вовремя. Даже если потребитель ненадолго замедлится, например при записи на SD-карту, показания не потеряются: они ждут своей очереди в очереди на 10 элементов. Если очередь заполнится, xQueueSend() вернёт ошибку без ожидания, и ты это заметишь. Если нужно только последнее значение, например для отображения текущей температуры на дисплее, можно создать очередь на один элемент, записывать в неё через xQueueOverwrite() и читать значение без удаления через xQueuePeek(). Этот способ мы используем в последнем примере.

Семафоры и мьютексы: пробуждение задачи из прерывания и защита общего ресурса

Двоичный семафор похож на флаг, который позволяет задаче ждать события. Чаще всего его используют с прерываниями: обработчик прерывания кнопки (ISR) должен быть очень коротким, поэтому он не выполняет основную работу, а только выдаёт семафор; задача, ожидающая этот семафор, просыпается и выполняет работу. Основы прерываний разобраны в статье Прерывания Arduino. Мьютекс гарантирует, что общий ресурс, например последовательный порт, шину I2C или дисплей, в каждый момент использует только одна задача. Если две задачи одновременно вызывают Serial.printf(), их строки могут смешаться; с мьютексом каждая задача захватывает блокировку перед записью и освобождает её после завершения. В коде ниже каждое нажатие кнопки переключает второй светодиод, а две задачи пишут в один монитор порта, не смешивая вывод.

C++ (Arduino IDE)
1const int BUTON_PIN = 27;              // butonun diğer ucu GND / other leg to GND
2const int LED_PIN   = 4;
3
4SemaphoreHandle_t butonSemaforu;       // kesme -> görev sinyali / ISR -> task signal
5SemaphoreHandle_t seriKilit;           // Serial için mutex / mutex for Serial
6
7void IRAM_ATTR butonKesmesi() {
8  BaseType_t uyandir = pdFALSE;
9  xSemaphoreGiveFromISR(butonSemaforu, &uyandir);   // ISR'de FromISR sürümü / FromISR version in ISR
10  if (uyandir == pdTRUE) {
11    portYIELD_FROM_ISR();              // bekleyen görevi hemen çalıştır / run the waiting task now
12  }
13}
14
15void guvenliYaz(const char *metin) {
16  if (xSemaphoreTake(seriKilit, pdMS_TO_TICKS(100)) == pdTRUE) {
17    Serial.println(metin);
18    xSemaphoreGive(seriKilit);         // kilidi mutlaka bırak / always release the lock
19  }
20}
21
22void butonGorevi(void *parametre) {
23  uint32_t sonBasma = 0;
24  for (;;) {
25    xSemaphoreTake(butonSemaforu, portMAX_DELAY);    // basılana kadar uyu / sleep until pressed
26    if (millis() - sonBasma > 200) {                 // 200 ms ark önleme / 200 ms debounce
27      sonBasma = millis();
28      digitalWrite(LED_PIN, !digitalRead(LED_PIN));
29      guvenliYaz("Butona basildi / Button pressed");
30    }
31  }
32}
33
34void raporGorevi(void *parametre) {
35  char satir[64];
36  for (;;) {
37    snprintf(satir, sizeof(satir), "Calisma suresi / Uptime: %lu s", (unsigned long)(millis() / 1000));
38    guvenliYaz(satir);
39    vTaskDelay(pdMS_TO_TICKS(2000));
40  }
41}
42
43void setup() {
44  Serial.begin(115200);
45  pinMode(LED_PIN, OUTPUT);
46  pinMode(BUTON_PIN, INPUT_PULLUP);
47  butonSemaforu = xSemaphoreCreateBinary();
48  seriKilit = xSemaphoreCreateMutex();
49  xTaskCreatePinnedToCore(butonGorevi, "Buton", 2048, NULL, 3, NULL, 1);
50  xTaskCreatePinnedToCore(raporGorevi, "Rapor", 2048, NULL, 1, NULL, 1);
51  attachInterrupt(digitalPinToInterrupt(BUTON_PIN), butonKesmesi, FALLING);
52}
53
54void loop() {
55  vTaskDelay(pdMS_TO_TICKS(1000));
56}
В обработчике прерывания используй только функции FreeRTOS, имена которых заканчиваются на FromISR (например, xSemaphoreGiveFromISR и xQueueSendFromISR). Вызов Serial.print(), delay() или любой функции с ожиданием внутри прерывания приводит к сбою ESP32. Добавь IRAM_ATTR перед функцией прерывания: это размещает её в быстром ОЗУ вместо флеш-памяти. После захвата мьютекса всегда освобождай его на каждом пути выполнения: если забыть xSemaphoreGive() в ветке обработки ошибки, все задачи, ожидающие этот ресурс, будут заблокированы навсегда.

На каком ядре работает Wi-Fi и где размещать свои задачи?

В ядре Arduino драйвер Wi-Fi, стек TCP/IP и Bluetooth привязаны к ядру 0; loop() и события Arduino выполняются на ядре 1. По умолчанию сторожевой таймер задач ESP32 также следит за задачей простоя на ядре 0 (IDLE0). Если разместить на ядре 0 задачу, которая имеет приоритет и никогда не ждёт, IDLE0 не сможет выполняться в течение 5 секунд, в мониторе порта появится Task watchdog got triggered, и плата перезапустится. Эта же задача задерживает обработку сетевых пакетов. Простое правило облегчает выбор:

РаботаРекомендуемое ядроПочему?
Быстрое регулярное управление, считывание датчиков, управление моторами1Прерывания Wi-Fi не нарушают временные интервалы
Веб-сервер, MQTT, HTTP-запросы0 или 1, низкий приоритетСетевой стек уже на ядре 0; твоя задача должна часто переходить в ожидание
Обновление дисплея, запись в журнал1, приоритет 1Несрочная работа, использует свободное время
Долгие вычисления (FFT, шифрование)1 или 0 с низким приоритетом и vTaskDelay(1) между вычислениямиЧтобы сторожевой таймер и другие задачи получали процессорное время

Размер стека и ошибки сторожевого таймера

У каждой задачи есть собственный стек; эту память используют локальные переменные, вызовы функций и библиотечные функции вроде printf. На ESP32 размер стека задаётся в байтах; единица «слово», упомянутая в стандартной документации FreeRTOS, к ESP32 не относится. Для простой задачи светодиода достаточно 2 048 байт. Задачам с Serial.printf(), операциями со String и выводом чисел с плавающей точкой выделяй 3 072–4 096 байт. Задачам, работающим с HTTPClient, TLS (HTTPS) или JSON, может понадобиться 8 192 байта и более. При переполнении стека ESP32 сообщает Stack canary watchpoint triggered или A stack overflow in task ... has been detected и перезапускается. Узнать минимальный объём свободного стека задачи за всё время её работы можно с помощью uxTaskGetStackHighWaterMark(); значение указано в байтах, и если оно опускается ниже 500 байт, стек следует увеличить. Как читать сообщения об ошибках при неожиданных перезапусках, объясняется в статье ESP32: просадка питания (brownout) и Guru Meditation.

Сообщение об ошибкеЗначениеРешение
Task watchdog got triggered ... IDLE (CPU 0) (ошибка: сработал сторожевой таймер задачи на ядре 0)Задача на ядре 0 не переходила в ожидание 5 сДобавь в цикл vTaskDelay(1), понизь приоритет или перенеси задачу на ядро 1
Stack canary watchpoint triggered (task name) (ошибка: переполнение стека задачи)Переполнен стек указанной задачиУвеличь размер стека в xTaskCreatePinnedToCore
Guru Meditation Error: LoadProhibitedПрочитан недопустимый адресПроверь, не указывает ли переданный задаче указатель на локальную переменную
Interrupt wdt timeout on CPU1Обработчик прерывания работал слишком долго или прерывания остались отключённымиСократи ISR и передай работу задаче через семафор
FreeRTOS Task "Gorev" should not return, Aborting now! (ошибка: функция задачи не должна завершаться)Функция задачи завершилась через returnИспользуй бесконечный цикл или вызови vTaskDelete(NULL) в конце

Проект: светодиод, датчик и веб-сервер одновременно

Теперь объединим изученное в одном проекте. Будет три задачи: задача датчика считывает потенциометр каждые 200 мс и записывает среднее последних 8 показаний в очередь на один элемент; задача светодиода мигает встроенным светодиодом со скоростью, заданной на веб-странице; веб-задача показывает текущее значение датчика на странице, открытой с телефона, и предлагает ссылки для изменения скорости мигания. Задачи обмениваются данными не через глобальные переменные, а с помощью xQueueOverwrite() и xQueuePeek(). loop() каждые 10 секунд выводит свободный объём стека каждой задачи и свободное ОЗУ, поэтому во время реальной работы видно, достаточно ли выделенного стека. Замени имя сети Wi-Fi и пароль своими.

C++ (Arduino IDE)
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_ADI   = "EvAgi_2G";       // Wi-Fi adı / network name
5const char* WIFI_SIFRE = "sifre1234";      // Wi-Fi şifresi / Wi-Fi password
6
7const int LED_PIN = 2;                     // dahili LED / onboard LED
8const int POT_PIN = 34;                    // ADC1, Wi-Fi ile çalışır / ADC1, works with Wi-Fi
9
10WebServer sunucu(80);
11QueueHandle_t sensorKutusu;                // tek öğe: son ortalama / one item: latest average
12QueueHandle_t hizKutusu;                   // tek öğe: LED yarım periyodu / one item: LED half period
13TaskHandle_t ledTutamac, sensorTutamac, webTutamac;
14
15void sensorGorevi(void *p) {
16  uint16_t son[8] = {0};
17  uint8_t sira = 0;
18  TickType_t sonUyanma = xTaskGetTickCount();
19  for (;;) {
20    son[sira] = analogRead(POT_PIN);
21    sira = (sira + 1) % 8;
22    uint32_t toplam = 0;
23    for (int i = 0; i < 8; i++) toplam += son[i];
24    uint16_t ortalama = toplam / 8;
25    xQueueOverwrite(sensorKutusu, &ortalama);       // eskisinin üzerine yaz / overwrite the old one
26    vTaskDelayUntil(&sonUyanma, pdMS_TO_TICKS(200));
27  }
28}
29
30void ledGorevi(void *p) {
31  pinMode(LED_PIN, OUTPUT);
32  uint32_t beklemeMs = 500;
33  for (;;) {
34    xQueuePeek(hizKutusu, &beklemeMs, 0);           // yeni hız varsa al / take a new speed if any
35    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
36    vTaskDelay(pdMS_TO_TICKS(beklemeMs));
37  }
38}
39
40void anaSayfa() {
41  uint16_t deger = 0;
42  uint32_t hiz = 0;
43  xQueuePeek(sensorKutusu, &deger, 0);              // okur ama silmez / reads without removing
44  xQueuePeek(hizKutusu, &hiz, 0);
45  String html = "<!DOCTYPE html><html><head><meta charset='utf-8'>"
46                "<meta http-equiv='refresh' content='2'>"
47                "<meta name='viewport' content='width=device-width'></head><body>"
48                "<h2>ESP32 FreeRTOS</h2>";
49  html += "<p>Sensor: " + String(deger) + " / 4095</p>";
50  html += "<p>LED: " + String(hiz) + " ms</p>";
51  html += "<p><a href='/hiz?ms=100'>100 ms</a> | <a href='/hiz?ms=500'>500 ms</a> | "
52          "<a href='/hiz?ms=1000'>1000 ms</a></p></body></html>";
53  sunucu.send(200, "text/html", html);
54}
55
56void hizAyarla() {
57  uint32_t ms = sunucu.arg("ms").toInt();
58  if (ms >= 50 && ms <= 5000) {
59    xQueueOverwrite(hizKutusu, &ms);
60  }
61  sunucu.sendHeader("Location", "/");
62  sunucu.send(303);
63}
64
65void webGorevi(void *p) {
66  WiFi.mode(WIFI_STA);
67  WiFi.begin(WIFI_ADI, WIFI_SIFRE);
68  while (WiFi.status() != WL_CONNECTED) {
69    vTaskDelay(pdMS_TO_TICKS(500));                 // beklerken çekirdeği bırak / yield while waiting
70  }
71  Serial.print("Adres / Address: http://");
72  Serial.println(WiFi.localIP());
73  sunucu.on("/", anaSayfa);
74  sunucu.on("/hiz", hizAyarla);
75  sunucu.begin();
76  for (;;) {
77    sunucu.handleClient();
78    vTaskDelay(pdMS_TO_TICKS(2));                   // IDLE görevine nefes aldır / let the idle task run
79  }
80}
81
82void setup() {
83  Serial.begin(115200);
84  sensorKutusu = xQueueCreate(1, sizeof(uint16_t));
85  hizKutusu = xQueueCreate(1, sizeof(uint32_t));
86  uint32_t ilkHiz = 500;
87  xQueueOverwrite(hizKutusu, &ilkHiz);
88
89  xTaskCreatePinnedToCore(sensorGorevi, "Sensor", 2048, NULL, 2, &sensorTutamac, 1);
90  xTaskCreatePinnedToCore(ledGorevi, "LED", 2048, NULL, 1, &ledTutamac, 1);
91  xTaskCreatePinnedToCore(webGorevi, "Web", 6144, NULL, 1, &webTutamac, 0);
92}
93
94void loop() {
95  // boş yığın (bayt) ve boş RAM / free stack (bytes) and free heap
96  Serial.printf("Bos yigin / Free stack  Sensor: %u  LED: %u  Web: %u  |  Heap: %u\n",
97                (unsigned)uxTaskGetStackHighWaterMark(sensorTutamac),
98                (unsigned)uxTaskGetStackHighWaterMark(ledTutamac),
99                (unsigned)uxTaskGetStackHighWaterMark(webTutamac),
100                (unsigned)ESP.getFreeHeap());
101  vTaskDelay(pdMS_TO_TICKS(10000));
102}

После загрузки открой на телефоне адрес, показанный в мониторе порта. Страница обновляется каждые 2 секунды, а значение меняется при повороте потенциометра. При нажатии на ссылки скорость мигания светодиода меняется мгновенно, но ритм считывания датчика не нарушается, поскольку каждая работа выполняется в отдельной задаче в своём темпе. Веб-задача находится на ядре 0 рядом с сетевым стеком и имеет низкий приоритет; поскольку на каждом проходе она ждёт 2 мс, задача IDLE0 получает время на выполнение и сторожевой таймер не срабатывает. Задачи светодиода и датчика находятся на ядре 1 и не зависят от трафика Wi-Fi. Эту структуру легко расширить: для мгновенного обновления значений без перезагрузки страницы добавь способ с WebSocket из статьи Веб-сервер ESP32 и WebSocket, а для сглаживания шумных показаний замени усреднение в задаче датчика медианным или экспоненциальным фильтром.

Сравнение с Raspberry Pi Pico: два ядра в MicroPython

RP2040 в Raspberry Pi Pico тоже двухъядерный, но операционной системы здесь нет: в MicroPython второе ядро запускается модулем _thread, и на двух ядрах выполняются только два потока. В Arduino ядро arduino-pico предлагает для второго ядра функции setup1() и loop1(). Код MicroPython ниже мигает светодиодом на втором ядре, пока первое считывает потенциометр; общий счётчик защищён блокировкой, как мьютексом на ESP32. Подробнее о ядрах Pico и блоках PIO — в статье PIO и два ядра Pico.

MicroPython
1import _thread, time
2from machine import Pin, ADC
3
4led = Pin(25, Pin.OUT)          # Pico dahili LED (Pico W'da Pin("LED")) / onboard LED (Pin("LED") on Pico W)
5pot = ADC(26)                   # GP26 = ADC0
6kilit = _thread.allocate_lock() # ortak veri kilidi / lock for shared data
7yanma_sayisi = 0
8
9def ikinci_cekirdek():
10    global yanma_sayisi
11    while True:
12        led.toggle()
13        with kilit:             # sayaç güvenle artar / counter updated safely
14            yanma_sayisi += 1
15        time.sleep_ms(300)
16
17_thread.start_new_thread(ikinci_cekirdek, ())   # çekirdek 1'de çalışır / runs on core 1
18
19while True:
20    deger = pot.read_u16()      # 0-65535
21    with kilit:
22        sayac = yanma_sayisi
23    print("Pot:", deger, "LED degisimi / toggles:", sayac)
24    time.sleep(1)

На Pico этот способ хорошо подходит для двух дел, но возможности по числу задач, приоритетам, очередям и планированию не так богаты, как у FreeRTOS на ESP32. Для проектов с множеством одновременно выполняемых задач, сетевыми соединениями и точными временными интервалами ESP32 и FreeRTOS дают более удобную основу. Если хочешь создавать проекты с Wi-Fi на Pico, загляни в статью Веб-сервер Wi-Fi на Pico W.

Частые ошибки и решения

СимптомВероятная причинаРешение
Плата перезапускается сразу после создания задачиФункция задачи завершается через return или стек слишком малДобавь бесконечный цикл и увеличь стек до 4 096 байт
loop() никогда не выполняетсяБолее приоритетная задача на ядре 1 никогда не ждётДобавь в эту задачу vTaskDelay() или понизь её приоритет до 1
Ошибка сторожевого таймера при включённом Wi-FiЗадача на ядре 0 не даёт выполняться IDLE0Используй vTaskDelay(1) в цикле или перенеси задачу на ядро 1
Значения иногда становятся бессмысленнымиДве задачи одновременно читают и записывают одну глобальную структуруПередавай данные через очередь или защищай доступ мьютексом
Строки в мониторе порта смешиваютсяДве задачи одновременно пишут в SerialЗахватывай мьютекс перед записью и освобождай после неё
Плата аварийно завершает работу при нажатии кнопкиSerial.print или обычная функция FreeRTOS в обработчике прерыванияИспользуй в ISR только функции FromISR и передавай работу задаче
analogRead() возвращает 4095 или 0 при включённом Wi-FiДатчик подключён к пину ADC2Используй один из пинов ADC1 GPIO 32–39
Код компилируется для ESP32-C3, но не работаетНа одноядерной плате запрошено ядро 1Используй ядро 0 или tskNO_AFFINITY либо функцию xTaskCreate()
При переходе на FreeRTOS не разбивай всё на задачи сразу. Сначала вынеси самую чувствительную ко времени работу из своего рабочего кода, например считывание датчика, в отдельную задачу, а остальное оставь в loop(). После добавления каждой задачи проверяй стек с помощью uxTaskGetStackHighWaterMark(). Если все данные между задачами передавать через очереди, а доступ к общему оборудованию защищать мьютексом, большинство ошибок типа «иногда ломается» удастся предотвратить с самого начала.

Два ядра ESP32 и FreeRTOS превращают сложные функции loop(), полные вычислений с millis(), в небольшие понятные задачи, каждая из которых занимается одним делом. Теперь ты знаешь, как создавать задачи, задавать приоритеты, передавать данные через очереди, обрабатывать прерывания с помощью семафоров и измерять стек, и твои проекты с Wi-Fi смогут работать без задержек. Если знакомство с ESP32 только начинается, основы найдёшь в статье Что такое ESP32?. В приложении BlueGrays также можно изучить проекты на ESP32: асинхронный веб-сервер, WebSocket, NTP-часы, регистратор температуры и умное освещение. Каждый проект содержит пошаговые схемы подключения и готовый код.

Частые вопросы

Что такое FreeRTOS на ESP32?

FreeRTOS — операционная система реального времени, которая работает внутри ESP32, а твой код Arduino выполняется поверх неё. Она позволяет разделить работу на отдельные задачи, назначить им приоритеты и распределить между двумя ядрами. Отдельная установка не нужна: функции вроде xTaskCreate уже доступны в ядре ESP32 для Arduino.

На каком ядре ESP32 выполняется loop()?

В ядре Arduino setup() и loop() выполняются внутри задачи loopTask на ядре 1 с приоритетом 1. Wi-Fi, TCP/IP и Bluetooth находятся на ядре 0. Проверить это можно, выведя результат xPortGetCoreID().

Чем delay() отличается от vTaskDelay() на ESP32?

В ядре ESP32 для Arduino delay() на самом деле вызывает vTaskDelay(), поэтому обе функции на время ожидания освобождают ядро для других задач. Активное ожидание, знакомое по Arduino Uno, на ESP32 возникает при использовании delayMicroseconds() и пустых циклов while. Для работы с постоянной частотой точнее использовать vTaskDelayUntil().

Какой размер стека задать в xTaskCreatePinnedToCore?

На ESP32 размер стека задаётся в байтах. Хорошая отправная точка — 2 048 байт для простых задач светодиода, 3 072–4 096 для задач с Serial.printf и String и 8 192 для тяжёлой работы вроде HTTPS и JSON. Измерь реальную потребность с помощью uxTaskGetStackHighWaterMark() и скорректируй размер.

Как исправить ошибку ESP32 «Task watchdog got triggered»?

Эта ошибка означает, что задача простоя на ядре 0 не могла выполняться в течение 5 секунд; обычно какая-то задача крутится в цикле без ожидания. Добавь в цикл vTaskDelay(1), понизь приоритет задачи или перенеси её на ядро 1. Также помогает разбиение долгих вычислений на небольшие части.

Как обмениваться данными между задачами на ESP32?

Самый безопасный способ — очереди FreeRTOS: данные отправляются через xQueueSend() и принимаются через xQueueReceive(), а благодаря копированию не возникает частично прочитанных значений. Если нужно только последнее значение, используй очередь на один элемент с xQueueOverwrite() и xQueuePeek(). При совместном использовании оборудования или глобальной структуры защищай доступ мьютексом.

Все проекты
Асинхронный веб-сервер на ESP32 (с выводом IP на LCD)
ES-27Продвинутый

Асинхронный веб-сервер на ESP32 (с выводом IP на LCD)

В этом проекте ESP32 превращается в асинхронный веб-сервер, которым можно управлять с телефона или компьютера в той же сети Wi-Fi. Благодаря библиотеке ESPAsyncWebServer сервер может обрабатывать несколько запросов одновременно (в отличие от классического WebServer.h, который блокируется на одном запросе). Открыв IP-адрес ESP32 в браузере, ты нажимаешь кнопки ON/OFF (маршруты /on и /off) и включаешь и выключаешь светодиод на GPIO 5.

4.8(16)
26
Счётчик на WebSocket с ESP32 (2 кнопки + LCD + веб в реальном времени)
ES-28Продвинутый
Premium

Счётчик на WebSocket с ESP32 (2 кнопки + LCD + веб в реальном времени)

В этом проекте две кнопки, подключённые к ESP32 (GPIO 5 увеличивает, GPIO 4 уменьшает), меняют счётчик. Значение сразу обновляется и на I2C LCD 16x2, и — через поддержку WebSocket в ESPAsyncWebServer — во всех подключённых браузерах без перезагрузки страницы. Вместо опроса по HTTP используется одно постоянное соединение, и ESP32 отправляет новое значение всем через ws.textAll().

4.5(14)
23
Подключение ESP32 к Wi-Fi в режиме STA (с экраном LCD)
ES-25Продвинутый

Подключение ESP32 к Wi-Fi в режиме STA (с экраном LCD)

В этом проекте ESP32 надёжно и устойчиво к сбоям подключается к домашней сети Wi-Fi в режиме станции (STA). SSID и пароль хранятся в отдельном файле secrets.h, чтобы не утекли в Git; настроено автоматическое переподключение, а уровень сигнала RSSI и IP-адрес выводятся на I2C LCD-экран. Встроенный светодиод служит индикатором состояния. Это менеджер подключения уровня реальных устройств.

4.4(21)
38
Регулировка яркости светодиода потенциометром на ESP32 (аналог → PWM)
ES-13Средний
Premium

Регулировка яркости светодиода потенциометром на ESP32 (аналог → PWM)

В этом проекте яркость светодиода плавно регулируется потенциометром. Пин АЦП ESP32 читает напряжение 0–3,3V с потенциометра, затем это значение превращается в сигнал PWM (широтно-импульсная модуляция) и подаётся на светодиод. В результате при повороте потенциометра светодиод постепенно становится ярче или тусклее. В Arduino Core 3.0+ можно сразу использовать analogWrite(); на ESP32-S2/S3 разрешение АЦП фиксировано — 12 бит.

4.5(19)
32
Управление лентой WS2812B NeoPixel на ESP32
ES-24Средний
Premium

Управление лентой WS2812B NeoPixel на ESP32

Адресуемые светодиоды WS2812B (NeoPixel) — умные RGB-светодиоды, которыми управляют цепочкой через один пин данных. В этом проекте лента WS2812B из 8 светодиодов управляется библиотекой Adafruit_NeoPixel и показывает плавную радужную анимацию. Логика 3,3V у ESP32 работает с большинством WS2812B, но на случай нестабильности показано решение с последовательным резистором 470Ω и конденсатором 1000µF. Анимация получается сдвигом значения оттенка.

4.9(19)
30
Глубокий сон ESP32: экономия батареи (OLED + счётчик в RTC RAM)
ES-33Продвинутый
Premium

Глубокий сон ESP32: экономия батареи (OLED + счётчик в RTC RAM)

Режим глубокого сна (Deep Sleep) у ESP32 снижает потребление до ~10 µA, выключая процессор и большую часть периферии, — это важно для IoT-устройств на батарейках. В этом проекте используются три источника пробуждения: таймер (15 секунд), внешний пин (EXT0 — кнопка GPIO 33) и касание (T0/GPIO 4). Переменные с RTC_DATA_ATTR сохраняются во время глубокого сна — счётчики загрузок, пробуждений по таймеру и по кнопке ведутся непрерывно.

4.3(10)
16
Регистратор температуры на ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Продвинутый
Premium

Регистратор температуры на ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Собери на ESP32 регистратор температуры с отметками времени! Каждую минуту читай температуру и влажность с DHT22, бери реальное время из DS1307 RTC и записывай всё на карту microSD в формате CSV. OLED показывает текущую температуру (крупным шрифтом), влажность в процентах, время и счётчик записей. Файл /temp_log.csv на SD-карте открывается в Excel, Google Sheets или Python pandas — идеально для теплиц, комнат, лабораторий и хранения продуктов.

4.7(7)
12
Умное освещение на ESP32 (PIR + LDR + реле + OLED)
ES-37Продвинутый
Premium

Умное освещение на ESP32 (PIR + LDR + реле + OLED)

Сделай умное освещение для коридора, ванной или кладовки на ESP32! С PIR-датчиком движения, датчиком освещённости LDR и модулем реле собирается классический сценарий «свет включается при движении в темноте»: если вокруг уже светло, движение свет НЕ включает, и днём энергия экономится. Свет горит 30 секунд; если движение продолжается, таймер сбрасывается, и свет горит дольше. OLED SSD1306 крупно показывает состояние (ON / DAYTIME / WAITING) и обратный отсчёт.

4.3(6)
11