FreeRTOS für ESP32 in der Arduino-Umgebung E-Book

Markus Edenhauser

• Herausgeber: Selbstverlag
• Kategorie: Fachliteratur
• Sprache: Deutsch

Veröffentlichungsjahr: 2025

Beschreibung

Tauche ein in die Welt der Echtzeitbetriebssysteme mit FreeRTOS auf dem ESP32 in der Arduino-Umgebung! In diesem praxisorientierten Buch lernst du, wie du FreeRTOS auf dem ESP32 einsetzt, um Multitasking und Echtzeitfähigkeit in deinen Projekten zu realisieren. Das erwartet dich in den 40 Code-Beispiele zu folgenden Themen: -Tasks: Erstelle und verwalte Tasks, die parallel laufen. Lerne, wie du Prioritäten vergibst, CPU-Cores zuweist und Tasks effizient steuerst – vom einfachen Blink-Beispiel bis hin zu komplexeren Anwendungen. -Queues: Setze Queues ein, um Daten sicher und strukturiert zwischen Tasks auszutauschen. Von einfachen Signalen bis hin zu komplexeren Datenstrukturen und der Anzeige auf OLED-Displays – hier erfährst du alles, was du wissen musst. -Mutex: Vermeide Race Conditions und Deadlocks mit Mutexes. Du lernst, wie du kritische Abschnitte schützt und Probleme frühzeitig erkennst. -Interrupts (ISR): Reagiere schnell und präzise auf externe Ereignisse mit Interrupt Service Routines. Entdecke, wie du Interrupts in FreeRTOS integrierst und mit Tasks kombinierst. Nach dem Lesen dieses Buches wirst du in der Lage sein, FreeRTOS auf dem ESP32 effektiv zu nutzen, um Multitasking und Echtzeitfähigkeiten in deinen Projekten zu integrieren. Du wirst lernen, wie du Tasks erstellst und verwaltest, Queues für die Kommunikation zwischen Tasks einsetzt und Mutexes verwendest, um Race Conditions zu vermeiden. Du wirst Interrupt Service Routines (ISR) nutzen, um auf externe Ereignisse schnell und präzise zu reagieren. Du kannst deine ESP32-Projekte mit FreeRTOS optimieren und leistungsstarke, echtzeitfähige Anwendungen entwickeln, die sowohl komplexe als auch zeitkritische Aufgaben zuverlässig bewältigen. Ideal für alle, die ihre Projekte mit FreeRTOS auf dem ESP32 auf das nächste Level heben möchten – von der Theorie bis hin zur praktischen Umsetzung. Hol dir jetzt das Buch und entwickle leistungsstarke, echtzeitfähige Anwendungen!

Leseprobe

FreeRTOS für ESP32 in der Arduino-Umgebung

Ein praxisorientierter Einstieg in ein Echtzeitbetriebssystem

Markus Edenhauser, MA MSc

2025-02-08

FreeRTOS für ESP32 in der Arduino-Umgebung

FreeRTOS für ESP32 in der Arduino-UmgebungVorwortEinleitungBenötigte Software und HardwareCode, Materialliste, Grafiken und E-BookDIY-Devboard für PrototypingWarum Denglisch?Unterschiedlicher CodeaufbauZielgruppeMIT-Lizenz und HaftungsausschlussGlossarEinführung FreeRTOSWarum braucht man FreeRTOS?Andere RTOS Systeme im Embedded BereichDesignKonventionenMultithreading und kooperatives MultitaskingSpeicherverwaltungSystem Ticks und Task-SwitchingESP32C3 Time SlicesÜbersicht Scheduler-TypenFreeRTOS API und QuelleUnterschiede ESP32 und AVR-ArduinoVergleich der ESP32-Modelle C3, S3, H2 und C6WiederholungsfragenVorbereitung und BasicsVSCode mit PlatformIOESP32 mit ESP-Prog debuggenESP32S3 debuggenHardware TimerPointerRingbufferRingbuffer mit AnalogsensorTasksErste Schritte: LED Blink mit TasksAusführenden CPU-Core festlegenTasks laufen unabhängig vom Delay im LoopMemory Management Stack Size bestimmenvTaskDelete – Tasks bzw Loop löschenvTaskResume – Fortfahren und AussetzenTicks mit ESP32 und Messung mit OszilloskopYielding CPU – Timeslot freigebenvTaskDelay mit ESP32vTaskDelay mit Arduino UnoTask PrioritiesuxTaskGetSystemStateErrorhandling von TasksxTaskNotifyFazit zu TasksQueuesPraxisbeispiel QueueAuf ein Signal wartenSenden und Empfangen mehrerer DatenwerteButton und LEDs mit QueueStruct und Queues mit OLEDSemaphoresBinary Semaphores EinführungsbeispielBinary Semaphores Button-BeispielBinary Semaphore Buffer-BeispielBinary Semaphore Task-SwitchCountable Semaphores3xI2C Module mit Binary SemaphoreUnterscheidung zwischen Semaphoren und QueuesMutexUnterschiede zwischen Mutex und Binary Semaphore:Race Condition provozieren ohne MutexMutex verhindert Race ConditionDeadlockDeadlock-VermeidungInterruptsVorbereitungsbeispielFrequenz messen mit FreeRTOS ISRISR Notify und PrioritätenISR und SemaphoreISR und MutexWatchdog-TimerSimpler Watchdog-Timer ohne FreeRTOSWatchdog-Timer mit TasksDanke und AusblickÜber den AutorWeiteres vom AutorDownloadlinksAntworten WiederholungsfragenStichwortverzeichnis

FreeRTOS für ESP32 in der Arduino-Umgebung

Copyright © Februar 2025 1. Auflage Selbstverlag

Markus Edenhauser, MA MSc Völser Straße 41 6020 Innsbruck Österreich pixeledi.eu/impressum

Danke für dein unermüdliches Vertrauen und deinen Glauben an meine Ideen. Dieses Buch widme ich dir, weil deine Unterstützung den Unterschied gemacht hat!

Vorwort

Dieses Buch richtet sich an alle, die in die Welt von FreeRTOS auf dem ESP32 einsteigen möchten. Es behandelt die grundlegenden Konzepte von FreeRTOS und zeigt auf, wie man diese im Arduino-Framework auf dem ESP32 umsetzt. Ziel dieses Buches ist es, dir einen Überblick und den besten Start in FreeRTOS zu ermöglichen, indem wir einfache Schritt-für-Schritt-Anleitungen durchgehen und die einzelnen Konzepte anhand von Sketchen besprechen. Es gibt keine langen Theorie-Blöcke, wir fokussieren uns stattdessen auf die praktische Umsetzung.

Die Grundlage des Buches bildet die Arbeit mit FreeRTOS, einem Open-Source-Echtzeitbetriebssystem, das speziell für Embedded-Systeme entwickelt wurde. FreeRTOS ermöglicht es dir, mehrere Aufgaben gleichzeitig auszuführen und sorgt dafür, dass dein System auf Echtzeitbedingungen reagiert. Das Besondere an FreeRTOS ist, dass es im Arduino-Core verfügbar ist, sodass wir uns nicht lange mit Konfigurationen aufhalten müssen, sondern direkt loslegen können. Achtung: Du kannst zwar auch einen Arduino Uno oder andere AVRs verwenden, musst die Sketche jedoch anpassen. Ein extra Kapitel bietet eine genauere Erklärung zu den Anpassungen.

Zu Beginn konzentrieren wir uns auf einfache, aber wesentliche Konzepte wie Task-Management, Timer sowie die grundlegenden Mechanismen von FreeRTOS. Du wirst lernen, wie du Aufgaben (Tasks) erstellst, verwaltest und mit ihnen interagierst. Außerdem behandeln wir wichtige Techniken zur Fehlerbehandlung. Darüber hinaus werden auch Queues, Semaphoren und Mutex behandelt, um die Kommunikation und Synchronisation zwischen Tasks zu ermöglichen. Diese Aufgaben sind leicht zu verstehen und liefern schnelle Ergebnisse, die dich motivieren und dir Vertrauen in die Anwendung von FreeRTOS auf dem ESP32 geben.

Ein zentraler Punkt dieses Buches ist, dass es dir nicht nur den Einstieg in FreeRTOS zeigt, sondern dir auch die nötige Grundlage bietet, um eigene Projekte umzusetzen. Du wirst nach den ersten Kapiteln in der Lage sein, eigene Sketche zu schreiben und zu verstehen, wie du mit FreeRTOS ein echtes Multitasking-System aufbaust. Die Beispiele, die du in diesem Buch findest, wurden bewusst einfach gehalten, um dir die grundlegenden Prinzipien von FreeRTOS nahezubringen. Mit jeder neuen Aufgabe wirst du tiefer in die Materie eintauchen, sodass du schrittweise die Fähigkeiten entwickelst, komplexere Anwendungen zu erstellen. Der erste Schritt in die Welt von FreeRTOS besteht oft darin, die Grundlagen zu verstehen – und dieses Buch hilft dir genau dabei.

Der ESP32 und FreeRTOS stehen bereit, deine Ideen zum Leben zu erwecken – auf geht’s, viel Erfolg und Freude mit diesem Buch!

Markus Edenhauser, MA MSc

1. https://www.youtube.com/watch?v=1kgCB8Hgv-U

2. https://github.com/espressif/arduino-esp32/tree/master/libraries/ESP32/examples/FreeRTOS

Einführung FreeRTOS

Seit 2005 ermöglicht das Arduino-Projekt einer breiten Masse den Zugang zur Mikrocontroller-Programmierung durch eine vereinfachte Entwicklungsumgebung. Seitdem nutzen Hobbyisten, Maker und Studierende diese Plattform, um Mikrocontroller effizient zu programmieren.

Für Anwendungen, die präzises Timing und zuverlässige Task-Koordination erfordern, hat sich FreeRTOS als eines der meistgenutzten Echtzeitbetriebssysteme (RTOS) im Embedded-Bereich etabliert. Mit seiner flexiblen Architektur und offenen Lizenz wird es kontinuierlich weiterentwickelt und für verschiedenste Hardwareplattformen angepasst, wodurch es sich ideal für anspruchsvolle Mikrocontroller-Projekte eignet.

Dieses Kapitel widmet sich zunächst der Frage, warum ein RTOS wie FreeRTOS überhaupt notwendig ist, und stellt es in den Kontext anderer RTOS-Lösungen, die ebenfalls im Embedded-Bereich eingesetzt werden. Im Anschluss wird das zugrunde liegende Design beleuchtet, einschließlich der zentralen Prinzipien, die FreeRTOS effizient und robust machen. Dazu gehören Konventionen für die Nutzung und Implementierung, die für eine reibungslose Integration in Embedded-Projekte entscheidend sind.

Ein Fokus liegt auf der Funktionsweise von Multithreading und kooperativem Multitasking. Hier wird erklärt, wie FreeRTOS Tasks verwaltet, priorisiert und auf Systemressourcen zugreift. Dies führt nahtlos zur Speicherverwaltung, einem kritischen Thema in ressourcenbeschränkten Umgebungen wie Mikrocontrollern, sowie zu System Ticks und Task-Switching, die das Herzstück eines jeden RTOS bilden.

Für Hardwareentwickler mit Fokus auf den ESP32 stellt das Kapitel spezifische Informationen bereit, beispielsweise zur Task-Verteilung bei Time Slices auf dem ESP32C3. Darüber hinaus wird der Scheduler, das zentrale Steuerelement in jedem RTOS, mit seinen unterschiedlichen Typen und Mechanismen betrachtet.

Die FreeRTOS API und deren Quellen werden ebenfalls vorgestellt, um Entwicklern einen Einstiegspunkt in die praktische Anwendung zu bieten. Für Leser, die bereits mit Arduino oder AVR-Plattformen vertraut sind, wird ein Vergleich der RTOS-Funktionalitäten auf ESP32- und AVR-Systemen geboten. Abschließend gibt es eine Übersicht über die Unterschiede der verschiedenen ESP32-Modelle und deren Auswirkungen auf die RTOS-Implementierung, sowie eine Klärung zentraler Begriffe rund um Echtzeitbetriebssysteme.

Das Kapitel richtet sich an fachkundige Leser, die FreeRTOS tiefer verstehen und effektiv in ihren Projekten einsetzen möchten. Es bildet damit die Grundlage für die praktischen Beispiele, die in den folgenden Abschnitten behandelt werden.

Warum braucht man FreeRTOS?

Ein Echtzeitbetriebssystem wie FreeRTOS wird benötigt, um in eingebetteten Systemen komplexe Aufgaben effizient und zeitkritisch zu verwalten. In solchen Systemen gibt es oft mehrere gleichzeitige Prozesse, die unabhängig voneinander laufen müssen, wie beispielsweise die Steuerung von Sensoren, die Kommunikation mit anderen Geräten oder die Verarbeitung von Nutzereingaben. Ohne ein RTOS wird dies oft durch sogenannte bare-metal-Programmierung umgesetzt, bei der die gesamte Logik manuell mit Interrupts und Schleifen implementiert wird. Diese Ansätze stoßen jedoch schnell an ihre Grenzen, wenn mehrere Aufgaben gleichzeitig und deterministisch bearbeitet werden müssen.

FreeRTOS bietet hier eine Lösung durch seine Fähigkeit, mehrere Tasks parallel zu verwalten, sie zu priorisieren und dabei präzise Zeitsteuerung zu garantieren. Das bedeutet, dass kritische Aufgaben wie z. B. ein Echtzeit-Signalverarbeitungssystem nicht von weniger wichtigen Aufgaben wie einer LED-Steuerung unterbrochen werden. FreeRTOS garantiert, dass wichtige Tasks immer rechtzeitig ausgeführt werden können, selbst wenn das System stark ausgelastet ist.

Darüber hinaus ist die Portabilität ein entscheidender Vorteil: FreeRTOS läuft auf einer Vielzahl von Mikrocontrollern, darunter ARM Cortex-M, ESP32, AVR und viele mehr. Dies erleichtert die Skalierbarkeit und Wiederverwendbarkeit von Code, da Entwickler nicht bei jedem Hardwarewechsel von Grund auf neu programmieren müssen.

Ein weiterer Aspekt ist die Integration moderner Kommunikationsprotokolle und Technologien, wie z. B. Bluetooth, Wi-Fi oder Ethernet, die häufig in heutigen IoT-Anwendungen genutzt werden. Ohne ein RTOS wären die Implementierung und das Timing solcher Protokolle äußerst kompliziert.

Zusätzlich erlaubt FreeRTOS eine saubere und modulare Architektur. Anstatt den gesamten Code in eine große Main-Schleife zu packen, können Entwickler einzelne Aufgaben in separate Tasks auslagern. Das erhöht nicht nur die Übersichtlichkeit und Wartbarkeit, sondern erleichtert auch die Fehlersuche und Optimierung.

Kurz zusammengefasst geht es um folgende Punkte:

Echtzeitfähigkeit: FreeRTOS ermöglicht präzise zeitgesteuerte Abläufe und garantiert, dass kritische Aufgaben rechtzeitig ausgeführt werden.Multitasking: Es erlaubt die Ausführung mehrerer Aufgaben (Tasks) gleichzeitig, ohne dass sie sich gegenseitig blockieren.Effiziente Ressourcennutzung: Mit Funktionen wie Task-Priorisierung und Speicherverwaltung wird die Hardware effizient genutzt.Modulare Programmierung: FreeRTOS erleichtert die Trennung von Aufgaben in kleinere, unabhängige Module, was den Code übersichtlicher und wartbarer macht.Industriestandard: FreeRTOS ist weit verbreitet und bietet Unterstützung durch eine große Community und viele Bibliotheken.

Andere RTOS Systeme im Embedded Bereich

Ein Grund, warum FreeRTOS so gut ins Arduino Framework integriert ist, liegt darin, dass es ursprünglich leichtgewichtig und flexibel entwickelt wurde, was es ideal für Mikrocontroller- und Embedded-Anwendungen macht. Es ist in C implementiert und bietet eine einfache API, die sich nahtlos in Arduino C++-Projekte integrieren lässt. Auf dem ESP32 läuft FreeRTOS direkt auf der Hardware und übernimmt die Verwaltung der Aufgaben und Timer, während der Entwickler die Kontrolle über die Programmlogik behält.

Es gibt mehrere Alternativen zu FreeRTOS für den ESP32, die ich der vollständigkeitshalber hier anführen möchte:

Zephyr OS – Ein Open-Source RTOS, das auf verschiedenen Mikrocontrollern und -prozessoren läuft, einschließlich ESP32.

RIOT OS – Ein weiteres Open-Source RTOS, das speziell für IoT-Geräte entwickelt wurde und auch auf dem ESP32 läuft.

Mbed OS – Ein Echtzeitbetriebssystem von Arm, das auch für den ESP32 unterstützt wird.

ChibiOS – Ein kleines und effizientes RTOS, das auf Embedded-Systemen, einschließlich des ESP32, gut läuft.

Besonders ZephyrOS könnte dem ein oder anderen ein Begriff sein: Zephyr ist ein modernes Open-Source-RTOS, das eine Vielzahl von Plattformen unterstützt, darunter ARM, x86 und RISC-V. Es ist eine hervorragende Wahl für komplexe Embedded-Projekte, die auf IoT, Sicherheit und Netzwerkkommunikation angewiesen sind. Zephyr bietet umfangreiche Funktionen wie Bluetooth Low Energy (BLE), Netzwerkstack und die Unterstützung für Multithreading. Für die Integration in Arduino-Projekte ist jedoch mehr Konfigurationsaufwand erforderlich als bei FreeRTOS und es hat eine größere Lernkurve. Ende 2024 hat Arduino bekannt gegeben, dass sie als Basis für den Arduino Core von Mbed auf ZephyrOS umsteigen. Das wird für uns als Endanwender zunächst keinen Unterschied machen, jedoch wird unter der Haube des Arduino Cores einiges optimiert und somit zukunftssicherer gemacht 1.

Warum FreeRTOS

Ich habe bislang ausschließlich FreeRTOS verwendet, weil es mir durch die Arduino-Core-Implementierung eine einfache und schnelle Nutzung ermöglicht, ohne dass viel Konfigurationsaufwand erforderlich ist. Es lässt sich mit minimalem Aufwand in Arduino-Projekte integrieren, während gleichzeitig die Möglichkeit zur Feinabstimmung des Systems gegeben ist. FreeRTOS ist optimal für Entwickler, die ein robustes, bewährtes RTOS für Projekte mit dem ESP32 oder anderen Mikrocontrollern benötigen.

Design

FreeRTOS ist darauf ausgelegt, Aufgaben mit unterschiedlichen Prioritäten effizient zu verwalten und eine deterministische Ablaufsteuerung zu gewährleisten. In Systemen mit mehreren gleichzeitigen Prozessen sorgt es dafür, dass stets die Aufgabe mit der höchsten Priorität ausgeführt wird. Beispielsweise kann es beim Zugriff auf eine Warteschlange sicherstellen, dass die wichtigste Aufgabe bevorzugt behandelt wird, ohne dass der Entwickler aufwendige Steuermechanismen implementieren muss.

Neben der Prioritätsverwaltung bietet FreeRTOS auch Mechanismen zur Synchronisation und Ressourcenverwaltung. Ein Beispiel dafür ist die Handhabung von Mutexen: Wenn eine hochpriorisierte Aufgabe auf einen Mutex wartet, der von einer niederpriorisierten Aufgabe gehalten wird, kann FreeRTOS eine Prioritätsvererbung anwenden. Dadurch wird die niedrigere Priorität vorübergehend angehoben, sodass der Mutex schneller freigegeben wird und potenzielle Deadlocks vermieden werden. Sobald der Zugriff abgeschlossen ist, kehrt die Aufgabe zu ihrer ursprünglichen Priorität zurück.

Diese durchdachten Mechanismen ermöglichen es FreeRTOS, selbst in anspruchsvollen Embedded-Systemen zuverlässig und effizient zu arbeiten. Durch seine flexible Architektur und umfangreiche Konfigurationsmöglichkeiten lässt es sich an unterschiedlichste Anwendungsfälle anpassen – von einfachen Mikrocontroller-Projekten bis hin zu komplexen Echtzeitanwendungen.

Konventionen

FreeRTOS im Arduino-Umfeld für den ESP32 folgt bestimmten Konventionen, die es ermöglichen, die Funktionen des Echtzeitbetriebssystems optimal zu nutzen. Eine der wichtigsten Konventionen ist die Verwendung von Tasks, die als eigenständige Ausführungseinheiten betrachtet werden. Jede Task läuft in einem eigenen Kontext und kann parallel zu anderen Tasks ausgeführt werden, was eine echte Multitasking-Umgebung schafft. Im Vergleich zur typischen Arduino-Programmierung, die meist auf einer einzigen Hauptschleife basiert, ermöglicht FreeRTOS die Ausführung mehrerer paralleler Aufgaben mit individueller Priorisierung.

Zur Kommunikation und Synchronisation zwischen Tasks nutzt FreeRTOS Mechanismen wie Queues, Semaphoren und Mutexe. Diese sind essenziell, um sicherzustellen, dass Daten korrekt zwischen verschiedenen Tasks ausgetauscht werden, ohne dass es zu Konflikten kommt. Zum Beispiel können Queues verwendet werden, um Nachrichten oder Daten zwischen Tasks zu senden, während Semaphoren und Mutexe dazu dienen, den Zugriff auf kritische Ressourcen zu steuern und Datenkorruption zu verhindern. Eine gängige Konvention dabei ist es, semaphorengeschützte Abschnitte zu definieren, in denen der Zugriff auf Shared Resources geregelt ist.

Ein weiterer wichtiger Aspekt ist die Task-Priorisierung. FreeRTOS erlaubt es, jedem Task eine Priorität zuzuweisen, was bedeutet, dass zeitkritische Tasks bevorzugt ausgeführt werden können. Die Prioritäten der Tasks müssen dabei sorgfältig geplant werden, um die Leistung des Systems zu maximieren und gleichzeitig sicherzustellen, dass alle Tasks ihre jeweiligen Aufgaben termingerecht erfüllen können. Insbesondere bei der Arbeit mit Echtzeitanforderungen am ESP32 müssen Entwickler genau überlegen, welche Tasks hohe Priorität erhalten, um sicherzustellen, dass keine wichtigen Ereignisse verpasst werden.

Ein nicht weniger wichtiger Aspekt bei der Verwendung von FreeRTOS auf dem ESP32 ist das Timing und Scheduling. FreeRTOS arbeitet mit einem präemptiven Scheduler, der Tasks basierend auf ihrer Priorität und der verfügbaren Prozessorzeit verwaltet. Standardmäßig werden Tasks mit niedrigerer Priorität unterbrochen, sobald eine höher priorisierte Task zur Ausführung bereit ist. Wenn mehrere Tasks die gleiche Priorität haben, können sie sich die Prozessorzeit durch Time-Slicing teilen – sofern diese Funktion aktiviert ist. Dadurch wird sichergestellt, dass alle gleichpriorisierten Tasks innerhalb eines bestimmten Zeitrahmens ausgeführt werden, ohne dass eine einzelne Task das System dominiert.

Zusammenfassend lässt sich sagen, dass die FreeRTOS-Konventionen im Arduino-Umfeld für den ESP32 darauf abzielen, eine klare und strukturierte Multitasking-Umgebung zu schaffen, bei der der Fokus auf der sicheren und effizienten Verwaltung von Ressourcen, der Kommunikation zwischen Tasks und der rechtzeitigen Ausführung von kritischen Aufgaben liegt.

Multithreading und kooperatives Multitasking

Starten wir zuerst mit der Frage: Warum brauchen wir Multitasking? Multitasking erlaubt es einem Mikrocontroller, mehrere Aufgaben gleichzeitig auszuführen, anstatt sie nacheinander abzuarbeiten. In einem klassischen Arduino-Programm blockiert jede langwierige Aufgabe den weiteren Ablauf. Multitasking vermeidet dieses Problem, indem es mehrere Tasks parallel ausführt, z.B. das Blinken einer LED während der Sensorabfrage. Besonders vorteilhaft ist Multitasking beim ESP32, der über zwei CPU-Kerne verfügt. FreeRTOS verteilt die Tasks auf diese Kerne, sodass der ESP32 mehrere Aufgaben gleichzeitig bearbeitet, ohne dass der Code wesentlich komplexer wird.

Multithreading und kooperatives Multitasking sind fundamentale Konzepte, die die parallele Ausführung von Programmen auf einem Mikrocontroller ermöglichen. Beide Konzepte spielen eine zentrale Rolle bei der Entwicklung von effizienten, reaktionsschnellen und gut strukturierten Programmen.

Multithreading mit FreeRTOS

Multithreading bezeichnet die Ausführung mehrerer Threads innerhalb eines Prozesses. Im Kontext des ESP32 und FreeRTOS wird jede parallele Aufgabe als Task bezeichnet. FreeRTOS stellt für jeden Task eine separate Ausführungsumgebung bereit, die es ihr ermöglicht, unabhängig von anderen Tasks zu laufen. Dabei wird der Scheduler von FreeRTOS verwendet, um die CPU-Zeit zwischen den Tasks aufzuteilen und so ein nahezu gleichzeitiges Ausführen mehrerer Tasks zu ermöglichen.

Da der ESP32 über zwei CPU-Kerne verfügt, kann FreeRTOS Aufgaben auf beiden Kernen ausführen. Das bedeutet, dass auf diesem Chip echte Parallelität möglich ist, da Tasks auf den verschiedenen Kernen gleichzeitig laufen. Ein einfaches Beispiel für Multithreading mit FreeRTOS auf dem ESP32 ist, wenn ein Task die Temperatur eines Sensors überwacht und ein anderer Task gleichzeitig die Werte auf einem Display anzeigt. Beide Tasks laufen unabhängig voneinander und blockieren sich nicht gegenseitig, was die Effizienz des Systems erheblich steigert.

Hier ist ein kurzes Code-Beispiel. Keine Sorge, wir werden die einzelnen Bestandteile des Codes in den kommenden Kapiteln noch ausführlich besprechen. An dieser Stelle geht es nur darum, dir einen ersten Einblick zu geben und die grundlegende Syntax kennenzulernen. Dieses kleine FreeRTOS-Beispiel sollte sich auch ohne tiefere Vorkenntnisse gut nachvollziehen lassen.

void Task1(void*pvParameters){while(1){// Temperaturabfrage und Verarbeitung vTaskDelay(1000/ portTICK_PERIOD_MS);}}void Task2(void*pvParameters){while(1){// Anzeige auf Display vTaskDelay(500/ portTICK_PERIOD_MS);}}void setup(){ xTaskCreate(Task1,"Task1",1000, NULL,1, NULL); xTaskCreate(Task2,"Task2",1000, NULL,1, NULL);}void loop(){// FreeRTOS verwaltet die Tasks}

In diesem Beispiel laufen die Tasks Task1 und Task2 parallel und werden durch vTaskDelay unterbrochen, um regelmäßig CPU-Zeit freizugeben.

Kooperatives Multitasking

Kooperatives Multitasking ist ein Modell, bei dem die Tasks die Kontrolle über den Scheduler freiwillig an andere Tasks abgeben. Im Gegensatz zum präemptiven Multitasking, bei dem der Scheduler die Kontrolle basierend auf Prioritäten und Zeitscheiben übernimmt, müssen bei kooperativem Multitasking die Tasks explizit angeben, wann sie “pausieren” und dem System erlauben, andere Aufgaben auszuführen.

FreeRTOS unterstützt sowohl präemptives als auch kooperatives Multitasking. Das bedeutet, dass du entscheiden kannst, ob du ein kooperatives Modell für deine Tasks verwenden möchtest. Beim kooperativen Multitasking liegt es in der Verantwortung des Entwicklers, sicherzustellen, dass jeder Task regelmäßig eine Möglichkeit zur Unterbrechung bietet, sodass andere Tasks ausgeführt werden können.

Ein Beispiel für kooperatives Multitasking könnte ein Task sein, der nur dann Daten verarbeitet, wenn neue Daten zur Verfügung stehen, und ansonsten wartet. In diesem Fall könnte der Task die CPU-Zeit an einen anderen Task übergeben, wenn keine Arbeit mehr zu tun ist.

void Task1(void*pvParameters){while(1){if(newDataAvailable()){// Datenverarbeitung} taskYIELD();// Übergabe der CPU-Zeit an andere Tasks}}void Task2(void*pvParameters){while(1){// Anzeigeaktualisierung taskYIELD();}}void setup(){ xTaskCreate(Task1,"Task1",1000, NULL,1, NULL); xTaskCreate(Task2,"Task2",1000, NULL,1, NULL);}void loop(){// FreeRTOS verwaltet die Tasks}

In diesem Beispiel verwendet Task1 die Funktion taskYIELD(), um der CPU die Möglichkeit zu geben, anderen Tasks CPU-Zeit zuzuweisen, wenn er keine Daten zum Verarbeiten hat. Dies sorgt für ein kooperatives Multitasking, bei dem jeder Task in der Lage ist, selbst zu entscheiden, wann er seine Ausführung unterbricht und ein anderer Task ausgeführt werden kann. Diesen Fakt werden wir später noch mit dem Oszilloskop genauer untersuchen.

Vergleich von präemptivem und kooperativem Multitasking

Der Hauptunterschied zwischen präemptivem und kooperativem Multitasking liegt in der Art und Weise, wie der Scheduler Aufgaben verwaltet:

Präemptives Multitasking: Der Scheduler von FreeRTOS unterbricht Tasks automatisch, basierend auf der Priorität oder der Zeitscheibe, die für jeden Task zugewiesen wurde. Dies ermöglicht eine hohe Reaktionsfähigkeit und eine effiziente Verteilung der CPU-Ressourcen.

Kooperatives Multitasking: In diesem Modell wird jeder Task für die Kontrolle über den Scheduler verantwortlich gemacht. Der Task muss aktiv angeben, wann er aufhören möchte, um anderen Tasks Raum zur Ausführung zu geben.

Das präemptive Modell ist in der Regel für die meisten Anwendungen geeignet, da es eine automatische und dynamische Verwaltung von Ressourcen ermöglicht, ohne dass der Entwickler die Ausführung der Tasks explizit kontrollieren muss. Kooperatives Multitasking kann hingegen für einfache Anwendungen sinnvoll sein, bei denen Tasks leicht miteinander kooperieren und die Kontrolle über den Scheduler behalten können.

Fazit

Multithreading und kooperatives Multitasking ermöglichen es, mehrere Aufgaben gleichzeitig auf dem ESP32 auszuführen. Mit FreeRTOS ist es möglich, komplexe Programme zu schreiben, die auf mehreren Kernen laufen und verschiedene Aufgaben gleichzeitig erledigen. Durch die Wahl des richtigen Modells für das Multitasking können Entwickler die Effizienz ihres Systems steigern und eine gute Balance zwischen Leistung und Komplexität finden. Während das präemptive Multitasking in den meisten Szenarien bevorzugt wird, kann kooperatives Multitasking in speziellen Fällen eine einfachere und ressourcenschonendere Lösung bieten.

Speicherverwaltung

In diesem Kapitel gehen wir auf die grundlegenden Konzepte der Speicherverwaltung in FreeRTOS ein, insbesondere auf den Stack- und Heap-Speicher. Wir werden erklären, wie FreeRTOS den Speicher verwaltet und warum es wichtig ist, die Größe von Tasks und deren Ressourcen im Voraus zu kennen. Außerdem zeigen wir, warum diese Architektur so gewählt wurde und welche Auswirkungen sie auf die Leistung hat.

---ENDE DER LESEPROBE---