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 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) | 1 | 1 | Твой код Arduino, стек 8 192 байта |
| Драйвер Wi-Fi | 0 | 23 | Радиосвязь и протокол Wi-Fi |
| lwIP (tcpip) | 0 | 18 | Стек TCP/IP, пакеты веб-сервера и MQTT |
| Bluetooth (BT/BLE) | 0 | Высокий | Контроллер Bluetooth и Bluedroid |
| esp_timer | 0 | 22 | Программные таймеры |
| IDLE0 и IDLE1 | 0 и 1 | 0 | Задачи простоя; обслуживают сторожевой таймер и освобождают память удалённых задач |
Из этой таблицы следуют два важных вывода. Во-первых, у задач 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 |
Первые задачи с xTaskCreatePinnedToCore
В первом примере два светодиода мигают с разной скоростью под управлением двух отдельных задач на разных ядрах. Каждая функция задачи имеет вид void function(void *parameter) и содержит бесконечный цикл. Функция xTaskCreatePinnedToCore(), запускающая задачу, также указывает, на каком ядре её выполнять. Обрати внимание: мы дважды используем одну функцию задачи и каждый раз передаём разную структуру настроек; благодаря параметру одна функция независимо управляет двумя светодиодами.
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. Вот параметры функции:
| Параметр | Значение в примере | Значение параметра |
|---|---|---|
| pvTaskCode | ledGorevi | Функция, которую выполняет задача |
| pcName | "LED1" | Имя, отображаемое при отладке, до 16 символов |
| usStackDepth | 2048 | Размер стека; на ESP32 задаётся в байтах |
| pvParameters | &led1 | Указатель, передаваемый задаче; должен указывать на глобальную или статическую переменную |
| uxPriority | 1 | Приоритет от 0 (самый низкий) до 24 |
| pvCreatedTask | NULL | Дескриптор для последующей остановки или наблюдения за задачей |
| xCoreID | 0 или 1 | Ядро для выполнения; с tskNO_AFFINITY задача работает на любом свободном ядре |
Сравнение 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 мс и помещает показание в очередь вместе с меткой времени; вторая обрабатывает каждое показание, полученное из очереди.
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(), их строки могут смешаться; с мьютексом каждая задача захватывает блокировку перед записью и освобождает её после завершения. В коде ниже каждое нажатие кнопки переключает второй светодиод, а две задачи пишут в один монитор порта, не смешивая вывод.
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}На каком ядре работает 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 и пароль своими.
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, °er, 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.
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() |
Два ядра 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)
В этом проекте ESP32 превращается в асинхронный веб-сервер, которым можно управлять с телефона или компьютера в той же сети Wi-Fi. Благодаря библиотеке ESPAsyncWebServer сервер может обрабатывать несколько запросов одновременно (в отличие от классического WebServer.h, который блокируется на одном запросе). Открыв IP-адрес ESP32 в браузере, ты нажимаешь кнопки ON/OFF (маршруты /on и /off) и включаешь и выключаешь светодиод на GPIO 5.

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

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

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

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

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

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

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

