Espressif IDF – Tasks

Last Updated on 3. Oktober 2026 by sfambach●Link-Status: OK

Ein Task ist eine (wiederkehrende) Aufgabe für den Prozessor. Mehrere Tasks ringen um die Aufmerksamkeit der CPU. Wie diese erstellt werden und welche Datenstrukturen zur Datenübermittlung und Synchronisation vorhanden sind, wird in diesem Beitrag kurz umrissen.

Tasks können zu einer sehr komplexen Angelegenheit werden, weshalb ich hier nur die Spitze des Eisberges ankratzen kann. Dennoch handelt es sich hierbei um den bisher längsten Beitrag der Serie. Für die weitere Recherche sei auch auf die Espressif Website – Kapitel FreeRtos●Link-Status: OK verwiesen.

Grundsätzliches

Tasks können als gekapselte Aufgaben betrachtet werden. In der Espressif IDF können je nach Anzahl der Prozessor-Kerne ein oder mehrere Tasks parallel/gleichzeitig ausgeführt werden. Grundsätzlich können aber mehrere Tasks gestartet werden, die um den/die Prozessorkern(e) konkurrieren. Immer wenn ein Task den Prozessorkern nicht mehr braucht, gibt er ihn frei und der nächste Task kommt an die Reihe.

Welcher Task als Nächstes bevorzugt wird, hängt grundsätzlich mit seiner Priorität zusammen und wie lange er schon wartet. Wie genau die Abarbeitungsreihenfolge ist, hängt von der Implementierung des Schedulers ab. Die Tasks in der IDF stammen aus dem FreeRtos, hier wacht zusätzlich ein Wachhund (Watchdog) darüber, dass die Tasks nicht zu lange brauchen. Weiterhin wird davon ausgegangen, dass Tasks ewig laufen, sollte ein Task beendet werden, muss dieser vorher gelöscht werden, sonst kommt es zu einem Fehler.

Viele der im Folgenden beschriebenen Funktionen gibt es mehrfach. Zum einen kann bei der Erstellung bestimmt werden, ob der Speicher dynamisch oder statisch zur Kompilierzeit reserviert werden soll. Die statischen Funktionen enden immer mit static.

Zum anderen gibt es Funktionen, die aus einem Interrupt gerufen werden können, diese enden immer mit ‚FromISR‘.

Es wird im Folgenden meist nur auf die Funktionen mit dynamischer Speicherreservierung eingegangen, für weitere Infos sei auch hier auf die IDF Referenz verwiesen.

Task erstellen

Bibliotheken:

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

Erstellt werden Tasks mit dem Befehl:

xTaskCreate(
   <pointer zur Task Funktion, 
   <Task Name>, 
   <Speicher für Task>, 
   <Task parameter>, 
   <Priotität>,
   <Referenz für Handle>);

Gute Programmierpraxis ist es, einen Task immer nur so lange laufen zu lassen, wie wirklich nötig ist. Muss ein Task auf einen Wert oder eine Aktion warten, sollte er sich schlafen legen und den Prozessor an einen anderen Task weitergeben. Das Schlafen kann mit der folgenden Funktion eingeleitet werden.

void vTaskDelay(const TickType_t xTicksToDelay);

Mit diesem Befehl wartet der Task eine bestimmte Zeit, bevor er wieder bereit zur Ausführung ist. Generell schlafen legen kann man den Task mit dem folgenden Befehl:

// speziellen Task anhalten
void vTaskSuspend(<TaskHandle>);
// Task aus interupt routine anhalten
BaseType_t xTaskResumeFromISR(<TaskHandle>)
// eigenen Task anhalten
vTaskSuspend(NULL);

In diesem Fall wartet der Task, bis er wieder von außen aktiviert wird. Dies geschieht mit dem folgenden Befehl:

// normale Freigabe
void xTaskResume(<TaskHandle>);
// aus Interrupt Routine
void xTaskResumeFromISR(<TaskHandle>);

FreeRtos-Tasks werden normal nicht beendet, wenn sie wie im Beispiel dennoch enden, wird ein Fehler geworfen. Um dies zu verhindern, muss der Task vor Ende gelöscht werden. Dies geschieht mit der Anweisung:

vTaskDelete( xHandles[task_index] );

Zu beachten ist: Wenn wie im Beispiel das xTaskDelete in seiner eigenen Task-Funktion aufgerufen wird, werden alle Anweisungen, die auf diesen Befehl folgen nicht mehr ausgeführt, weil der Task dann schon gelöscht ist.

Das folgende Beispiel erstellt mehrere Tasks, die unterschiedlich lange laufen und, wenn sie aktiv sind, eine Ausgabe erzeugen: