Ratgeber · 12 Min. Lesezeit

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.

ESP32-Entwicklungsboard
Der klassische ESP32 hat zwei Xtensa-LX6-Kerne und kann mit FreeRTOS auf jedem Kern eigene Tasks ausführen.

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:

TaskKernPrioritätAufgabe
loopTask (setup und loop)11Dein Arduino-Code, 8192 Byte Stack
WLAN-Treiber023Funk und WLAN-Protokoll
lwIP (tcpip)018TCP/IP-Stack, Web- und MQTT-Pakete
Bluetooth (BT/BLE)0HochBluetooth-Controller und Bluedroid
esp_timer022Software-Timer
IDLE0 und IDLE10 und 10Idle-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.

BauteilESP32-PinHinweis
Board-LEDGPIO 2Bei den meisten DevKits eingebaut
Zweite LEDGPIO 4220-Ω-Vorwiderstand, kurzes Bein an GND
Potentiometer MittelabgriffGPIO 34Nur Eingang, ADC1; äußere Beine an 3V3 und GND
TasterGPIO 27Anderes Bein an GND, mit INPUT_PULLUP
Schließe das äußere Bein des Potentiometers an 3V3 an, nicht an 5V. Die Pins des ESP32 arbeiten mit 3,3 V und sind nicht 5-V-tolerant. Verbinde analoge Sensoren in WLAN-Projekten mit den ADC1-Pins GPIO 32–39; die ADC2-Pins (GPIO 0, 2, 4, 12–15, 25–27) lassen sich bei aktivem WLAN nicht mit analogRead() lesen. Deine Pinwahl kannst du im Tool Pinout prüfen.

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.

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}

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:

ParameterWert im BeispielBedeutung
pvTaskCodeledGoreviDie Funktion, die der Task ausführt
pcName"LED1"Name für die Fehlersuche, höchstens 16 Zeichen
usStackDepth2048Stackgröße; beim ESP32 in Byte
pvParameters&led1Zeiger, der an den Task übergeben wird; er sollte auf eine globale oder statische Variable zeigen
uxPriority1Priorität von 0 (niedrigste) bis 24
pvCreatedTaskNULLHandle, um den Task später zu stoppen oder zu überwachen
xCoreID0 oder 1Kern, auf dem er läuft; mit tskNO_AFFINITY läuft er auf dem gerade freien Kern
Eine Task-Funktion darf niemals mit return enden; sonst meldet der ESP32 einen Fehler und startet neu. Ist ein Task fertig, lösche ihn mit vTaskDelete(NULL) in der letzten Zeile. Übergib dem Task auch nicht die Adresse einer lokalen Variable aus setup(): Wenn setup() endet, verschwindet diese Variable und der Task liest eine ungültige Adresse. Auf den Single-Core-Chips ESP32-C3, S2 und C6 sind als Kernnummer nur 0 oder tskNO_AFFINITY erlaubt; am portabelsten ist xTaskCreate(), das keinen Kern festlegt.

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().

MethodeGibt den Kern frei?Wann verwenden?
delay(ms)Ja (ruft beim ESP32 vTaskDelay auf)Einfache Wartezeiten in loop()
vTaskDelay(pdMS_TO_TICKS(ms))JaWarten in Tasks; die Wartezeit kommt zur Arbeitszeit hinzu
vTaskDelayUntil(&letzte, periode)JaAbtastung mit festem Takt; exakte Periode unabhängig von der Arbeitszeit
delayMicroseconds(us)NeinMikrosekunden-Wartezeiten in Sensorprotokollen
while (millis() - t < ms) {}NeinNicht 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.

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}

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.

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}
Verwende in einer Interrupt-Routine nur FreeRTOS-Funktionen, deren Name auf FromISR endet (etwa xSemaphoreGiveFromISR und xQueueSendFromISR). Serial.print(), delay() oder eine wartende Funktion im Interrupt bringt den ESP32 zum Absturz. Setze IRAM_ATTR vor die Interrupt-Funktion; damit liegt sie im schnellen RAM statt im Flash. Hast du einen Mutex genommen, gib ihn auf jedem Weg zurück: Fehlt xSemaphoreGive() in einem Fehlerzweig, bleiben alle Tasks, die auf diese Ressource warten, für immer blockiert.

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:

AufgabeEmpfohlener KernWarum?
Schnelle, regelmäßige Regelung, Sensorabtastung, Motorsteuerung1WLAN-Unterbrechungen stören das Timing nicht
Webserver, MQTT, HTTP-Anfragen0 oder 1, niedrige PrioritätDer Netzwerkstack liegt ohnehin auf Kern 0; dein Task sollte oft warten
Displayaktualisierung, Protokollierung1, Priorität 1Nicht 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.

FehlermeldungBedeutungLösung
Task watchdog got triggered ... IDLE (CPU 0)Ein Task auf Kern 0 hat 5 s lang nicht gewartetvTaskDelay(1) in die Schleife, Priorität senken oder Task auf Kern 1 verschieben
Stack canary watchpoint triggered (Taskname)Der Stack des genannten Tasks ist übergelaufenStackwert in xTaskCreatePinnedToCore erhöhen
Guru Meditation Error: LoadProhibitedEine ungültige Adresse wurde gelesenPrüfen, ob der Zeiger für den Task auf eine lokale Variable zeigt
Interrupt wdt timeout on CPU1Eine Interrupt-Routine dauerte zu lange oder Interrupts blieben gesperrtISR kürzen, Arbeit per Semaphore an einen Task abgeben
FreeRTOS Task "Gorev" should not return, Aborting now!Die Task-Funktion endete mit returnEndlosschleife 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.

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}

Ö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.

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)

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

SymptomMögliche UrsacheLösung
Das Board startet neu, sobald ein Task angelegt wirdDie Task-Funktion endet mit return oder der Stack ist zu kleinEndlosschleife einbauen, Stack auf 4096 Byte erhöhen
loop() läuft nieEin höher priorisierter Task auf Kern 1 wartet nievTaskDelay() in diesen Task einbauen oder seine Priorität auf 1 senken
Watchdog-Fehler bei aktivem WLANEin Task auf Kern 0 lässt IDLE0 verhungernvTaskDelay(1) in der Schleife nutzen oder Task auf Kern 1 verschieben
Werte sind gelegentlich unsinnigZwei Tasks lesen und schreiben gleichzeitig dieselbe globale StrukturDaten per Queue übertragen oder Zugriff mit Mutex schützen
Zeilen im Seriellen Monitor vermischen sichZwei Tasks schreiben gleichzeitig auf SerialVor dem Schreiben Mutex nehmen, danach freigeben
Das Board stürzt beim Tastendruck abSerial.print oder normale FreeRTOS-Funktion in der Interrupt-RoutineIn der ISR nur FromISR-Funktionen nutzen, Arbeit an einen Task abgeben
analogRead() liefert bei WLAN 4095 oder 0Der Sensor hängt an einem ADC2-PinEinen der ADC1-Pins GPIO 32–39 verwenden
Der Code kompiliert auf dem ESP32-C3, läuft aber nichtAuf einem Single-Core-Chip wurde Kern 1 angefordertKern 0 oder tskNO_AFFINITY angeben oder xTaskCreate() nutzen
Teile beim Umstieg auf FreeRTOS nicht alles auf einmal in Tasks auf. Verschiebe zuerst die zeitkritischste Aufgabe deines funktionierenden Codes, etwa die Sensorabtastung, in einen eigenen Task und lass den Rest in loop(). Prüfe nach jedem neuen Task den Stack mit uxTaskGetStackHighWaterMark(). Wenn du alle Daten zwischen Tasks über Queues austauschst und jede gemeinsame Hardware über einen Mutex ansprichst, vermeidest du die meisten Fehler der Sorte „manchmal geht es kaputt“ von Anfang an.

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.

Alle Projekte ansehen
ESP32 Async-Webserver (mit IP-Anzeige auf dem LCD)
ES-27Fortgeschritten

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.

4.8(16)
26
ESP32-WebSocket-Zähler (2 Tasten + LCD + Web-Echtzeit)
ES-28Fortgeschritten
Premium

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.

4.5(14)
23
ESP32-WLAN-STA-Verbindung (mit LCD-Display)
ES-25Fortgeschritten

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.

4.4(21)
38
ESP32: LED-Helligkeit mit Potentiometer (Analog → PWM)
ES-13Mittel
Premium

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.

4.5(19)
32
Steuerung des ESP32 WS2812B NeoPixel-Streifens
ES-24Mittel
Premium

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.

4.9(19)
30
ESP32 Deep Sleep – Batteriesparmodus (OLED + RTC-RAM-Zähler)
ES-33Fortgeschritten
Premium

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.

4.3(10)
16
ESP32 Temperatur-Datenlogger (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Fortgeschritten
Premium

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.

4.7(7)
12
ESP32 Intelligente Beleuchtung (PIR + LDR + Relais + OLED)
ES-37Fortgeschritten
Premium

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.

4.3(6)
11