FreeRTOS für IoT: Echtzeitbetriebssystem auf ESP32 und STM32

FreeRTOS ist das De-facto-RTOS für IoT. ESP-IDF liefert FreeRTOS bereits integriert; STM32CubeMX generiert die FreeRTOS-Integration. Es zu beherrschen unterscheidet Firmware, die 3 Jahre im Produktivbetrieb übersteht, von Firmware, die nur im Labor funktioniert.

Task-Architektur

void sensor_task(void *p) {
    TickType_t last = xTaskGetTickCount();
    while (1) {
        sensor_data_t d = {.temp=read_temp(), .hum=read_hum()};
        xQueueSend(sensor_q, &d, portMAX_DELAY);
        vTaskDelayUntil(&last, pdMS_TO_TICKS(5000));
    }
}
void ble_task(void *p) {
    sensor_data_t d;
    while (1) {
        xQueueReceive(sensor_q, &d, portMAX_DELAY);
        ble_transmit(&d);
        xSemaphoreGive(watchdog_sem);
    }
}

Erkennung von Stack-Überläufen

#define configCHECK_FOR_STACK_OVERFLOW 2
void vApplicationStackOverflowHook(TaskHandle_t t, char *name) {
    ESP_LOGE(TAG, "STACK OVERFLOW: %s", name);
    esp_restart();
}

Muster für die Kommunikation zwischen Tasks

Über einfache Queues hinaus bietet FreeRTOS Event-Groups, Stream-Buffer und Message-Buffer. Event-Groups eignen sich ideal, um mehrere Tasks anhand einer Reihe von Bedingungen zu koordinieren — zum Beispiel ein OTA-Task, der wartet, bis sowohl ein WLAN-Verbindungs-Flag als auch ein Zeitsynchronisations-Flag gesetzt sind, bevor er ein Firmware-Update herunterlädt. Ein einziger Aufruf von xEventGroupWaitBits() ersetzt eine komplexe Polling-Schleife.

Stream-Buffer sind für Byte-Stream-Daten aus Interrupts optimiert — eine UART-Empfangs-ISR, die in einen Stream-Buffer schreibt, aus dem ein Parsing-Task liest. Die ISR blockiert nie; der Parser blockiert, bis Daten verfügbar sind. Dieses Muster verarbeitet Sensordatenpakete variabler Länge effizient und ohne dynamische Speicherzuweisung.

Watchdog-Integration

Ein Hardware-Watchdog, der nicht ordnungsgemäß mit FreeRTOS integriert ist, ist schlimmer als nutzlos — er löst willkürlich aus, wenn ein legitimer Task länger als erwartet dauert, und verursacht unnötige Geräteneustarts. Der Task-Watchdog (TWDT) von ESP-IDF überwacht einzelne Tasks, nicht das gesamte System. Konfigurieren Sie ihn so, dass er Ihre höchstpriorisierten Tasks überwacht, und füttern Sie ihn in der Hauptschleife jedes Tasks.

esp_task_wdt_init(30, true);       // 30s Timeout, Panik bei Auslösung
esp_task_wdt_add(sensor_task_h);   // Sensor-Task überwachen
esp_task_wdt_add(ble_task_h);      // BLE-Task überwachen
// In der Hauptschleife jedes Tasks:
esp_task_wdt_reset();              // Watchdog füttern

Speicherverwaltung in FreeRTOS

Die dynamische Speicherzuweisung (pvPortMalloc) in FreeRTOS nutzt einen Heap. ESP-IDF stellt mehrere Heap-Implementierungen bereit — heap_4 ist die Voreinstellung, mit First-Fit-Zuweisung und dem Zusammenführen freier Blöcke. Vermeiden Sie in Produktiv-Firmware dynamische Zuweisungen in ISRs vollständig und minimieren Sie Zuweisungen nach der Systeminitialisierung. Fragmentierung über Tage des Dauerbetriebs kann Zuweisungsfehler verursachen, die im Test nahezu unmöglich zu reproduzieren sind.

Verwenden Sie statische Zuweisung für Queues, Semaphoren und Task-Stacks, wo Vorhersagbarkeit zählt. FreeRTOS unterstützt vollständig statische Zuweisung (ganz ohne Heap) über configSUPPORT_STATIC_ALLOCATION — nützlich für sicherheitskritische Anwendungen, bei denen Speichererschöpfung nachweislich unmöglich sein muss.

Portierung zwischen ESP32 und STM32

Die FreeRTOS-APIs sind auf ESP32 (über ESP-IDF) und STM32 (über STM32CubeMX) identisch. Task-Erstellung, Queue-Operationen und Synchronisations-Primitive haben alle dieselben Funktionssignaturen. Wenn Sie Ihre Anwendungsschicht gegen die FreeRTOS-APIs entwerfen und den Hardwarezugriff hinter einem HAL abstrahieren, ist die Portierung zwischen MCU-Familien eine Sache von Tagen statt Wochen. Bei FSS pflegen wir gemeinsam genutzte Firmware-Komponenten — MQTT-Client, OTA-Manager, Sensortreiber —, die unverändert auf beiden Plattformen laufen.