ESP32 FreeRTOS: Dual-Core, Tasks, Queues und Semaphoren
ESP32 FreeRTOS: xTaskCreatePinnedToCore, Prioritäten, delay vs. vTaskDelay, Queues, Semaphoren, Stack und Watchdog; LED, Sensor und Webserver gleichzeitig.
ESP32 FreeRTOS ist das Echtzeitbetriebssystem, das ohnehin im ESP32 läuft und dir erlaubt, mehrere Dinge gleichzeitig zu erledigen. Jeder ESP32-Sketch, den du in der Arduino IDE schreibst, läuft in Wirklichkeit auf FreeRTOS: Deine Funktionen setup() und loop() laufen in einem Task namens loopTask auf einem der beiden Kerne des ESP32. Mit eigenen Tasks kannst du eine LED blinken lassen, während du einen Sensor ausliest und gleichzeitig Anfragen an einen Webserver beantwortest, ohne dass einer den anderen aufhält. Das Muster „mehrere Aufgaben gleichzeitig“, das du auf dem Arduino Uno mühsam mit millis() baust, bekommt auf dem ESP32 eine viel sauberere Struktur.
In dieser Anleitung lernst du, wie die beiden Kerne des ESP32 aufgeteilt sind und auf welchem Kern das WLAN läuft. Danach legen wir mit xTaskCreatePinnedToCore Tasks an, binden sie an einen bestimmten Kern, setzen Prioritäten und sehen uns den Unterschied zwischen delay() und vTaskDelay() an. Für den sicheren Datenaustausch zwischen Tasks nutzen wir eine Queue, für das Aufwecken eines Tasks per Tasterinterrupt eine Semaphore und zum Schutz des gemeinsamen Seriellen Monitors einen Mutex. Nach Stackgröße und Watchdog-Fehlern bauen wir ein komplettes Beispiel, in dem LED, Sensor und Webserver gleichzeitig laufen. Am Ende folgt ein kurzer Vergleich mit den zwei Kernen des Raspberry Pi Pico.

Was ist ESP32 FreeRTOS und wie arbeiten die zwei Kerne?
In FreeRTOS ist jede Aufgabe ein Task. Ein Task ist eine gewöhnliche C-Funktion mit eigenem Stack und eigener Priorität, meist mit einer Endlosschleife. Der Scheduler von FreeRTOS wählt auf jedem Kern unter den lauffähigen Tasks den mit der höchsten Priorität. Wartet ein Task mit vTaskDelay(), auf Daten aus einer Queue oder auf eine Semaphore, bekommt sofort ein anderer Task den Kern. Tasks mit gleicher Priorität wechseln sich bei jedem Tick ab. Im ESP32-Arduino-Core dauert ein Tick 1 ms (1000 Ticks pro Sekunde), vTaskDelay(100) wartet also etwa 100 ms. Der klassische ESP32 hat zwei Kerne: Kern 0 (PRO_CPU) und Kern 1 (APP_CPU). Espressif legt die Funkkommunikation auf Kern 0 und deinen Code auf Kern 1, damit das WLAN deine Schleife nicht unterbricht. Mit den Standardeinstellungen von Arduino läuft auf den Kernen Folgendes:
| Task | Kern | Priorität | Aufgabe |
|---|---|---|---|
| loopTask (setup und loop) | 1 | 1 | Dein Arduino-Code, 8192 Byte Stack |
| WLAN-Treiber | 0 | 23 | Funk und WLAN-Protokoll |
| lwIP (tcpip) | 0 | 18 | TCP/IP-Stack, Web- und MQTT-Pakete |
| Bluetooth (BT/BLE) | 0 | Hoch | Bluetooth-Controller und Bluedroid |
| esp_timer | 0 | 22 | Software-Timer |
| IDLE0 und IDLE1 | 0 und 1 | 0 | Idle-Tasks; füttern den Watchdog und geben den Speicher gelöschter Tasks frei |
Die Tabelle enthält zwei wichtige Lehren. Erstens haben WLAN- und TCP/IP-Tasks eine sehr hohe Priorität: Legst du einen schweren eigenen Task auf Kern 0, unterbrechen sie ihn bei jedem Netzwerkverkehr, und hältst du sie lange beschäftigt, leidet das WLAN. Zweitens hat loopTask nur Priorität 1: Legst du auf Kern 1 einen Task mit höherer Priorität, der nie wartet, läuft loop() überhaupt nicht mehr. Auch der ESP32-S3 hat zwei Kerne. ESP32-S2, ESP32-C3 und ESP32-C6 sind dagegen Single-Core; Tasks kannst du dort trotzdem anlegen, sie teilen sich aber alle denselben Kern.
Schaltung
Für die Beispiele in diesem Artikel brauchst du ein ESP32-DevKit, zwei LEDs, ein Potentiometer und einen Taster. Die blaue LED auf dem Board hängt an GPIO 2; die zweite LED schließt du über einen 220-Ω-Widerstand an GPIO 4 an. Das Potentiometer kommt an GPIO 34, einen ADC1-Kanal, denn ADC2-Pins lassen sich bei aktivem WLAN nicht auslesen.
| Bauteil | ESP32-Pin | Hinweis |
|---|---|---|
| Board-LED | GPIO 2 | Bei den meisten DevKits eingebaut |
| Zweite LED | GPIO 4 | 220-Ω-Vorwiderstand, kurzes Bein an GND |
| Potentiometer Mittelabgriff | GPIO 34 | Nur Eingang, ADC1; äußere Beine an 3V3 und GND |
| Taster | GPIO 27 | Anderes Bein an GND, mit INPUT_PULLUP |
Erste Tasks mit xTaskCreatePinnedToCore
Im ersten Beispiel lassen wir zwei LEDs mit zwei getrennten Tasks unterschiedlich schnell und auf verschiedenen Kernen blinken. Jede Task-Funktion hat die Form void funktion(void *parameter) und enthält eine Endlosschleife. xTaskCreatePinnedToCore() startet den Task und legt gleichzeitig fest, auf welchem Kern er läuft. Beachte, dass wir dieselbe Task-Funktion zweimal verwenden und jedes Mal eine andere Einstellungsstruktur übergeben; dank des Parameters steuert eine Funktion zwei LEDs unabhängig voneinander.
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}Nach dem Hochladen blinken die beiden LEDs unabhängig voneinander, und der Serielle Monitor zeigt, dass loop() auf Kern 1 läuft. Die Parameter der Funktion:
| Parameter | Wert im Beispiel | Bedeutung |
|---|---|---|
| pvTaskCode | ledGorevi | Die Funktion, die der Task ausführt |
| pcName | "LED1" | Name für die Fehlersuche, höchstens 16 Zeichen |
| usStackDepth | 2048 | Stackgröße; beim ESP32 in Byte |
| pvParameters | &led1 | Zeiger, der an den Task übergeben wird; er sollte auf eine globale oder statische Variable zeigen |
| uxPriority | 1 | Priorität von 0 (niedrigste) bis 24 |
| pvCreatedTask | NULL | Handle, um den Task später zu stoppen oder zu überwachen |
| xCoreID | 0 oder 1 | Kern, auf dem er läuft; mit tskNO_AFFINITY läuft er auf dem gerade freien Kern |
delay(), vTaskDelay() und vTaskDelayUntil() im Vergleich
Auf dem Arduino Uno hält delay() den Prozessor komplett beschäftigt; während des Wartens läuft nichts anderes. Beim ESP32 ist das anders: delay() ruft im Arduino-Core in Wirklichkeit vTaskDelay() auf. Schreibst du delay(100), schläft dein Task 100 ms und der Kern gehört in dieser Zeit anderen Tasks. Darum funktioniert delay() auch in Tasks; trotzdem zeigt vTaskDelay(pdMS_TO_TICKS(100)) in FreeRTOS-Code deine Absicht deutlicher. Der eigentliche Unterschied liegt bei Methoden, die durch aktives Warten blockieren: delayMicroseconds() und leere Schleifen wie while (millis() - t < 500) {} geben den Kern nie frei. Das millis()-Muster auf dem Arduino erklären wir ausführlich in millis() statt delay().
| Methode | Gibt den Kern frei? | Wann verwenden? |
|---|---|---|
| delay(ms) | Ja (ruft beim ESP32 vTaskDelay auf) | Einfache Wartezeiten in loop() |
| vTaskDelay(pdMS_TO_TICKS(ms)) | Ja | Warten in Tasks; die Wartezeit kommt zur Arbeitszeit hinzu |
| vTaskDelayUntil(&letzte, periode) | Ja | Abtastung mit festem Takt; exakte Periode unabhängig von der Arbeitszeit |
| delayMicroseconds(us) | Nein | Mikrosekunden-Wartezeiten in Sensorprotokollen |
| while (millis() - t < ms) {} | Nein | Nicht in FreeRTOS-Tasks verwenden; andere Tasks verhungern |
Läuft eine Schleife mit vTaskDelay(100) und die Arbeit dauert 15 ms, wiederholt sie sich alle 115 ms und der Fehler summiert sich. Willst du einen Sensor exakt alle 100 ms lesen, nimm vTaskDelayUntil(): Die Funktion merkt sich den letzten Weckzeitpunkt und weckt den Task jedes Mal genau eine Periode später. Der Sensor-Task im nächsten Abschnitt nutzt diese Methode.
Task-Prioritäten: Welcher Task läuft zuerst?
Sind auf einem Kern mehrere Tasks lauffähig, läuft immer der mit der höchsten Priorität. Ein Task mit niedrigerer Priorität kommt erst an die Reihe, wenn die höher priorisierten warten. Das nennt man präemptives, prioritätsbasiertes Scheduling: Sobald die Daten eintreffen, auf die ein hoch priorisierter Task wartet, wird der niedriger priorisierte unterbrochen. So kannst du Aufgaben, die schnell reagieren müssen, hoch priorisieren, doch es gibt eine Falle: Wartet ein hoch priorisierter Task nie, kommen die darunter nie zum Zug. In der Praxis bewährt sich folgendes Schema:
- Priorität 1: Aufgaben ohne Eile, etwa Displayaktualisierung, Ausgaben im Seriellen Monitor oder ein Webserver. Auch loop() liegt auf dieser Stufe.
- Priorität 2–3: Aufgaben, die pünktlich erledigt werden müssen, etwa regelmäßiges Sensorlesen, Regelschleifen und Tasterauswertung.
- Priorität 4–5: Kurze Tasks, die von einem Interrupt geweckt werden und sofort reagieren müssen.
- Vermeiden: Gib eigenen Tasks keine Priorität ab 18; diese Stufen gehören WLAN, TCP/IP und den System-Timern.
Daten sicher zwischen Tasks austauschen: die Queue
Der erste Gedanke für den Datenaustausch zwischen Tasks ist eine globale Variable, doch zwei Tasks können gleichzeitig darauf zugreifen. Liest ein Task eine mehrbytige Struktur, während ein anderer sie schreibt, bekommt er einen Wert, der halb alt und halb neu ist; solche Fehler treten selten und zufällig auf und sind deshalb schwer zu finden. Die Lösung von FreeRTOS ist die Queue (Warteschlange). Eine Queue ist eine Reihe von Elementen fester Größe, die Daten als Kopie transportiert: Der sendende Task legt mit xQueueSend() eine Kopie ab, der empfangende holt sie mit xQueueReceive(). Ist die Queue leer, schläft der Empfänger und verbraucht keine Rechenzeit; sobald Daten kommen, wacht er auf. Im folgenden Beispiel liest ein Task das Potentiometer exakt alle 100 ms und legt den Messwert mit Zeitstempel in die Queue; ein zweiter Task verarbeitet jeden Messwert, der aus der Queue kommt.
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}Da der Sensor-Task eine höhere Priorität (2) hat als der Verarbeiter (1), werden die Messwerte immer pünktlich erfasst. Selbst wenn der Verarbeiter kurz langsamer wird, etwa beim Schreiben auf eine SD-Karte, geht kein Messwert verloren; sie warten in der Queue mit 10 Plätzen. Ist die Queue voll, gibt xQueueSend() ohne Warten einen Fehler zurück, und du bemerkst es. Brauchst du nur den neuesten Wert, etwa für die aktuelle Temperatur auf einem Display, legst du eine Queue mit nur einem Platz an, schreibst mit xQueueOverwrite() hinein und liest den Wert mit xQueuePeek(), ohne ihn zu entfernen. Diese Methode nutzen wir im letzten Beispiel.
Semaphore und Mutex: Task per Interrupt wecken und gemeinsame Ressourcen schützen
Eine binäre Semaphore ist wie eine Flagge, mit der ein Task auf ein Ereignis wartet. Am häufigsten wird sie mit Interrupts verwendet: Die Interrupt-Routine (ISR) eines Tasters muss sehr kurz sein, sie erledigt also nicht die eigentliche Arbeit, sondern gibt nur die Semaphore frei; der darauf wartende Task wacht auf und erledigt die Aufgabe. Die Grundlagen von Interrupts erklären wir im Artikel Arduino Interrupt. Ein Mutex garantiert, dass nur ein Task gleichzeitig eine gemeinsame Ressource nutzt, etwa die serielle Schnittstelle, den I2C-Bus oder ein Display. Rufen zwei Tasks gleichzeitig Serial.printf() auf, können sich ihre Zeilen vermischen; mit einem Mutex holt sich jeder Task vor dem Schreiben die Sperre und gibt sie danach zurück. Im folgenden Code schaltet jeder Tastendruck die zweite LED um, und zwei Tasks schreiben in denselben Seriellen Monitor, ohne dass sich ihre Ausgaben vermischen.
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}Auf welchem Kern läuft das WLAN und wohin gehören deine Tasks?
Im Arduino-Core sind WLAN-Treiber, TCP/IP-Stack und Bluetooth an Kern 0 gebunden; loop() und Arduino-Events laufen auf Kern 1. Der Task-Watchdog des ESP32 überwacht standardmäßig auch den Idle-Task auf Kern 0 (IDLE0). Legst du einen Task mit hoher Priorität auf Kern 0, der nie wartet, kann IDLE0 fünf Sekunden lang nicht laufen, der Serielle Monitor zeigt Task watchdog got triggered und das Board startet neu. Derselbe Task verzögert außerdem die Verarbeitung von Netzwerkpaketen. Eine einfache Regel hilft:
| Aufgabe | Empfohlener Kern | Warum? |
|---|---|---|
| Schnelle, regelmäßige Regelung, Sensorabtastung, Motorsteuerung | 1 | WLAN-Unterbrechungen stören das Timing nicht |
| Webserver, MQTT, HTTP-Anfragen | 0 oder 1, niedrige Priorität | Der Netzwerkstack liegt ohnehin auf Kern 0; dein Task sollte oft warten |
| Displayaktualisierung, Protokollierung | 1, Priorität 1 | Nicht dringend, nutzt die freie Zeit |
| Lange Berechnungen (FFT, Verschlüsselung) | 1, oder 0 mit niedriger Priorität, dazwischen vTaskDelay(1) | Damit Watchdog und andere Tasks nicht verhungern |
Stackgröße und Watchdog-Fehler
Jeder Task hat seinen eigenen Stack; lokale Variablen, Funktionsaufrufe und Bibliotheksfunktionen wie printf nutzen diesen Bereich. Beim ESP32 wird die Stackgröße in Byte angegeben; die Einheit „Word“ aus der Standard-Dokumentation von FreeRTOS gilt beim ESP32 nicht. Für einen einfachen LED-Task reichen 2048 Byte. Tasks mit Serial.printf(), String-Operationen und Gleitkomma-Ausgaben bekommen 3072–4096 Byte. Tasks mit HTTPClient, TLS (HTTPS) oder JSON brauchen eventuell 8192 Byte und mehr. Läuft ein Stack über, meldet der ESP32 Stack canary watchpoint triggered oder A stack overflow in task ... has been detected und startet neu. Wie viel vom Stack eines Tasks bisher mindestens frei geblieben ist, verrät uxTaskGetStackHighWaterMark(); der Wert ist in Byte, und fällt er unter 500 Byte, solltest du den Stack vergrößern. Wie man die Fehlermeldungen hinter unerwarteten Neustarts liest, zeigen wir in ESP32 Brownout und Guru Meditation.
| Fehlermeldung | Bedeutung | Lösung |
|---|---|---|
| Task watchdog got triggered ... IDLE (CPU 0) | Ein Task auf Kern 0 hat 5 s lang nicht gewartet | vTaskDelay(1) in die Schleife, Priorität senken oder Task auf Kern 1 verschieben |
| Stack canary watchpoint triggered (Taskname) | Der Stack des genannten Tasks ist übergelaufen | Stackwert in xTaskCreatePinnedToCore erhöhen |
| Guru Meditation Error: LoadProhibited | Eine ungültige Adresse wurde gelesen | Prüfen, ob der Zeiger für den Task auf eine lokale Variable zeigt |
| Interrupt wdt timeout on CPU1 | Eine Interrupt-Routine dauerte zu lange oder Interrupts blieben gesperrt | ISR kürzen, Arbeit per Semaphore an einen Task abgeben |
| FreeRTOS Task "Gorev" should not return, Aborting now! | Die Task-Funktion endete mit return | Endlosschleife nutzen oder am Ende vTaskDelete(NULL) aufrufen |
Praxisprojekt: LED, Sensor und Webserver gleichzeitig
Jetzt fassen wir alles in einem Projekt zusammen. Es gibt drei Tasks: Der Sensor-Task liest das Potentiometer alle 200 ms und schreibt den Mittelwert der letzten 8 Messungen in eine Queue mit einem Platz; der LED-Task lässt die Board-LED in der Geschwindigkeit blinken, die auf der Webseite eingestellt wird; der Web-Task zeigt auf einer Seite, die du am Handy öffnest, den aktuellen Sensorwert und bietet Links zum Ändern der LED-Geschwindigkeit. Die Tasks tauschen Daten nicht über globale Variablen aus, sondern über xQueueOverwrite() und xQueuePeek(). loop() gibt alle 10 Sekunden den freien Stack jedes Tasks und den freien RAM aus, so siehst du im echten Betrieb, ob die Stacks reichen. Ersetze WLAN-Name und Passwort durch deine eigenen Daten.
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}Öffne nach dem Hochladen die Adresse aus dem Seriellen Monitor auf deinem Handy. Die Seite lädt sich alle 2 Sekunden neu, und der Wert ändert sich, wenn du am Potentiometer drehst. Tippst du auf die Links, ändert sich die LED-Geschwindigkeit sofort, doch der Takt der Sensormessung bleibt ungestört, weil jede Aufgabe in ihrem eigenen Task und ihrem eigenen Tempo läuft. Der Web-Task sitzt mit niedriger Priorität auf Kern 0 neben dem Netzwerkstack; da er in jedem Durchlauf 2 ms wartet, kann IDLE0 laufen und der Watchdog löst nicht aus. LED- und Sensor-Task liegen auf Kern 1 und bleiben vom WLAN-Verkehr unberührt. Die Struktur lässt sich leicht erweitern: Für sofortige Aktualisierung ohne Neuladen ergänzt du die WebSocket-Methode aus dem Artikel ESP32 Webserver und WebSocket, und um verrauschte Sensorwerte zu glätten, ersetzt du den Mittelwert im Sensor-Task durch einen Median- oder Exponentialfilter.
Vergleich mit dem Raspberry Pi Pico: zwei Kerne in MicroPython
Auch der RP2040 im Raspberry Pi Pico hat zwei Kerne, aber kein Betriebssystem: In MicroPython startest du den zweiten Kern mit dem Modul _thread, und auf den beiden Kernen laufen nur zwei Threads. Auf der Arduino-Seite bietet der arduino-pico-Core für den zweiten Kern die Funktionen setup1() und loop1(). Der folgende MicroPython-Code lässt die LED auf dem zweiten Kern blinken und liest auf dem ersten das Potentiometer; der gemeinsame Zähler ist mit einem Lock geschützt, genau wie mit dem Mutex beim ESP32. Mehr über die Kerne und PIO-Einheiten des Pico findest du im Artikel Pico PIO und zwei Kerne.
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)Für zwei Aufgaben funktioniert das auf dem Pico gut, doch Werkzeuge wie viele Tasks, Prioritäten, Queues und Scheduler sind nicht so umfangreich wie FreeRTOS auf dem ESP32. Für Projekte mit vielen parallelen Aufgaben, Netzwerkverbindungen und präzisem Timing bieten ESP32 und FreeRTOS die bequemere Grundlage. Willst du WLAN-Projekte mit dem Pico bauen, schau in den Artikel Pico W WLAN-Webserver.
Häufige Fehler und Lösungen
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| Das Board startet neu, sobald ein Task angelegt wird | Die Task-Funktion endet mit return oder der Stack ist zu klein | Endlosschleife einbauen, Stack auf 4096 Byte erhöhen |
| loop() läuft nie | Ein höher priorisierter Task auf Kern 1 wartet nie | vTaskDelay() in diesen Task einbauen oder seine Priorität auf 1 senken |
| Watchdog-Fehler bei aktivem WLAN | Ein Task auf Kern 0 lässt IDLE0 verhungern | vTaskDelay(1) in der Schleife nutzen oder Task auf Kern 1 verschieben |
| Werte sind gelegentlich unsinnig | Zwei Tasks lesen und schreiben gleichzeitig dieselbe globale Struktur | Daten per Queue übertragen oder Zugriff mit Mutex schützen |
| Zeilen im Seriellen Monitor vermischen sich | Zwei Tasks schreiben gleichzeitig auf Serial | Vor dem Schreiben Mutex nehmen, danach freigeben |
| Das Board stürzt beim Tastendruck ab | Serial.print oder normale FreeRTOS-Funktion in der Interrupt-Routine | In der ISR nur FromISR-Funktionen nutzen, Arbeit an einen Task abgeben |
| analogRead() liefert bei WLAN 4095 oder 0 | Der Sensor hängt an einem ADC2-Pin | Einen der ADC1-Pins GPIO 32–39 verwenden |
| Der Code kompiliert auf dem ESP32-C3, läuft aber nicht | Auf einem Single-Core-Chip wurde Kern 1 angefordert | Kern 0 oder tskNO_AFFINITY angeben oder xTaskCreate() nutzen |
Die zwei Kerne des ESP32 und FreeRTOS verwandeln komplizierte loop()-Funktionen voller millis()-Rechnungen in kleine, gut lesbare Tasks, die sich jeweils um eine Aufgabe kümmern. Jetzt, da du Tasks anlegen, Prioritäten vergeben, Daten per Queue übertragen, Interrupts mit Semaphoren behandeln und den Stack messen kannst, laufen deine WLAN-Projekte ohne Hänger. Bist du neu beim ESP32, findest du die Grundlagen im Artikel Was ist der ESP32?. In der BlueGrays-App findest du außerdem ESP32-Projekte wie Async-Webserver, WebSocket, NTP-Uhr, Temperaturlogger und smarte Beleuchtung, jeweils mit Schritt-für-Schritt-Schaltplänen und fertigem Code.
Häufige Fragen
Was ist FreeRTOS beim ESP32?
FreeRTOS ist ein Echtzeitbetriebssystem, das im ESP32 läuft, und auch dein Arduino-Code läuft darauf. Es erlaubt dir, mehrere Aufgaben in getrennte Tasks aufzuteilen, ihnen Prioritäten zu geben und sie auf zwei Kerne zu verteilen. Eine eigene Installation ist nicht nötig; Funktionen wie xTaskCreate stehen im ESP32-Arduino-Core bereit.
Auf welchem Kern läuft loop() beim ESP32?
Im Arduino-Core laufen setup() und loop() im Task loopTask auf Kern 1 mit Priorität 1. WLAN, TCP/IP und Bluetooth liegen auf Kern 0. Das kannst du selbst prüfen, indem du xPortGetCoreID() ausgibst.
Was ist der Unterschied zwischen delay() und vTaskDelay() beim ESP32?
Im ESP32-Arduino-Core ruft delay() in Wirklichkeit vTaskDelay() auf, beide geben also während des Wartens den Kern an andere Tasks ab. Aktives Warten wie beim Arduino Uno passiert beim ESP32 mit delayMicroseconds() und leeren while-Schleifen. Für Aufgaben mit festem Takt ist vTaskDelayUntil() genauer.
Wie groß sollte der Stack bei xTaskCreatePinnedToCore sein?
Beim ESP32 wird die Stackgröße in Byte angegeben. Für einfache LED-Tasks sind 2048 Byte ein guter Start, für Tasks mit Serial.printf und String 3072–4096 und für schwere Aufgaben wie HTTPS und JSON 8192 Byte. Den echten Bedarf misst du mit uxTaskGetStackHighWaterMark() und passt ihn an.
Wie behebe ich beim ESP32 „Task watchdog got triggered“?
Der Fehler bedeutet, dass der Idle-Task auf Kern 0 fünf Sekunden lang nicht laufen konnte; meist dreht ein Task seine Schleife, ohne je zu warten. Füge vTaskDelay(1) in die Schleife ein, senke die Priorität des Tasks oder verschiebe ihn auf Kern 1. Lange Berechnungen in kleinere Stücke aufzuteilen hilft ebenfalls.
Wie tausche ich beim ESP32 Daten zwischen Tasks aus?
Am sichersten sind FreeRTOS-Queues: Mit xQueueSend() sendest du Daten, mit xQueueReceive() empfängst du sie, und da kopiert wird, entstehen keine halb gelesenen Werte. Wird nur der neueste Wert gebraucht, nutzt du eine Queue mit einem Platz zusammen mit xQueueOverwrite() und xQueuePeek(). Teilst du Hardware oder eine globale Struktur, schütze den Zugriff mit einem Mutex.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
Wir machen den ESP32 zu einem asynchronen Webserver, den du per Handy oder Computer im selben WLAN steuerst. Dank der Bibliothek ESPAsyncWebServer verarbeitet der Server mehrere Anfragen gleichzeitig (er blockiert nicht wie das klassische WebServer.h bei einer einzigen Anfrage). Öffne im Browser die IP-Adresse des ESP32 und schalte mit den Tasten ON/OFF (Adressen /on und /off) die LED an GPIO 5 ein und aus.

ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
In diesem Projekt ändern zwei am ESP32 angeschlossene Taster (GPIO 5 zählt hoch, GPIO 4 zählt herunter) einen Zähler. Der Wert wird sofort auf einem 16x2-I2C-LCD und über die WebSocket-Unterstützung von ESPAsyncWebServer in allen verbundenen Browsern aktualisiert, ohne die Seite neu zu laden. Statt HTTP-Polling wird eine einzige dauerhafte Verbindung genutzt; der ESP32 sendet den neuen Wert mit ws.textAll() an alle.

ESP32-WLAN-STA-Verbindung (mit LCD-Display)
In diesem Projekt verbinden wir den ESP32 im Station-Modus (STA) sicher und fehlertolerant mit dem heimischen WLAN. Wir lagern SSID und Passwort in eine separate secrets.h-Datei aus, um Leaks zu Git zu verhindern, richten einen Auto-Reconnect-Mechanismus ein und zeigen RSSI-Signalpegel und IP-Adresse auf einem I2C-LCD-Display an. Die interne LED dient als Statusanzeige. Ein Verbindungsmanager auf Produktionsniveau.

ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
In diesem Projekt steuern wir die Helligkeit einer LED analog über ein Potentiometer. Der ADC-Pin des ESP32 liest die vom Potentiometer kommende Spannung von 0-3,3 V aus, woraufhin dieser Wert in ein PWM-Signal (Pulsweitenmodulation) umgewandelt und an die LED gesendet wird. So leuchtet die LED beim Drehen des Potentiometers stufenweise auf und erlischt wieder. Mit Arduino Core 3.0+ kann analogWrite() direkt verwendet werden; bei ESP32-S2/S3 ist die ADC-Auflösung auf 12 Bit festgelegt.

Steuerung des ESP32 WS2812B NeoPixel-Streifens
WS2812B-LEDs (NeoPixel) sind adressierbare RGB-LEDs, die sich in Reihe über einen einzigen Datenpin steuern lassen. Wir steuern einen WS2812B-Streifen mit 8 LEDs über die Bibliothek Adafruit_NeoPixel und erzeugen eine flüssige Regenbogenanimation. Die 3,3-V-Logik des ESP32 klappt bei den meisten WS2812B; bei Instabilität hilft ein 470Ω-Serienwiderstand plus 1000µF-Kondensator. Die Animation verschiebt den Farbton im HSV-Farbraum.

ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
Im Deep-Sleep-Modus schaltet der ESP32 die CPU und die meisten Peripheriegeräte ab und senkt den Strom auf etwa 10µA, entscheidend für batteriebetriebene IoT-Geräte. Das Projekt nutzt drei Weckquellen: einen Timer (15 s), einen externen Pin (EXT0, Taster an GPIO 33) und einen Touch-Pin (T0/GPIO 4). Mit RTC_DATA_ATTR markierte Zähler bleiben im Deep Sleep erhalten.

ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
Bau mit dem ESP32 einen zeitgesteuerten Temperatur- und Feuchtigkeitslogger! Ein DHT22 misst einmal pro Minute Temperatur und Luftfeuchtigkeit; jeder Wert landet mit einem Zeitstempel des RTC-Moduls DS1307 im CSV-Format auf einer microSD-Karte. Das OLED zeigt live und in großer Schrift die letzte Temperatur, die Luftfeuchtigkeit, den Zeitstempel und die Zahl der Einträge.

ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
Mit ESP32, PIR-Bewegungssensor, LDR-Lichtsensor und Relaismodul machen wir aus Flur, Bad oder Vorratskammer eine smarte Beleuchtung. Ist es hell, bleibt das Licht trotz Bewegung aus, so brennt es tagsüber nicht umsonst und spart Energie. Das Licht bleibt 30 Sekunden an; solange Bewegung erkannt wird, verlängert sich die Zeit automatisch.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

