FreeRTOS - Ein Echtzeitbetriebssystem in Theorie und Praxis

FreeRTOS - Ein Echtzeitbetriebssystem in Theorie und Praxis

3-tägiger Schulungskurs

Der Kursinhalt kann auf Ihre Bedürfnisse und Ziele zugeschnitten werden. Wenn es die Zeit erlaubt, kann auch eine Beratung während des Kurses stattfinden. Bitte klicken Sie auf die öffentliche Registerkarte, um die öffentlichen Sitzungen zu sehen.

Privat online
Vor Ort in Ihrem Unternehmen
Wir werden Ihre E-Mail niemals an Dritte weitergeben.
Viertel wählen Quartal Status Zugang Lieferung Standort Sprache Zeitzone Buchen bis
2. Quartal 2024 privat remote virtuell Deutsch/Englisch (noch zu definieren) UTC+2 (noch zu definieren) 01. Juli 2024
3. Quartal 2024 privat remote virtuell Deutsch/Englisch (noch zu definieren) UTC+2 (noch zu definieren) 01. Oktober 2024
4. Quartal 2024 privat remote virtuell Deutsch/Englisch (noch zu definieren) UTC+2 (noch zu definieren) Jan 01, 2025

Inhalt wie unten beschrieben. Ab drei Teilnehmern aus demselben Unternehmen besuchen Sie bitte unsere privaten Sitzungen.

Öffentlich online
Öffentlicher Workshop im Klassenzimmer
Wir werden Ihre E-Mail niemals an Dritte weitergeben.
Datum auswählen Datum Status Zugang Lieferung Standort Sprache Zeitzone Buchen bis
Aug 12, 2024 öffentlich remote virtuell Deutsch/Englisch (noch zu definieren) UTC+2 17. Juli 2024
28. Oktober 2024 öffentlich remote virtuell Deutsch/Englisch (noch zu definieren) UTC+2 02. September 2024

Von Bare Metal C zu einem industrietauglichen Open-Source-Echtzeitbetriebssystem.

Ziele des Kurses

Ein "Know-how-Upgrade" für einen Bare-Metal-Mikrocontroller-C-Programmierer auf ein industrietaugliches Open-Source-Echtzeitbetriebssystem.

  • Was sind die Vorteile?
  • Was ist der Kompromiss?

Praktische Übungen vermitteln Ihnen die nötige Praxiserfahrung, um nach erfolgreichem Abschluss dieser Schulung ein Echtzeit-Betriebssystem auf Ihrem eigenen eingebetteten System einzusetzen.

Beschreibung

Dieser 3-tägige Kurs veranschaulicht die Konzepte eines Echtzeitbetriebssystems. FreeRTOS wird als Beispiel verwendet. Der Kurs ist so konzipiert, dass Sie schnell auf den neuesten Stand gebracht werden. Die Konzepte und Befehle, die für eine effektive Nutzung von FreeRTOS notwendig sind, werden durch eine Kombination aus Theorie und praktischen Beispielen beschrieben. Erfinden Sie das Rad nicht neu, sondern lernen Sie von einem erfahrenen Trainer und nehmen Sie ein funktionierendes Wissen über FreeRTOS und die Fähigkeit, es in Ihrem eigenen Embedded-Entwicklungsprojekt effektiv einzusetzen, mit nach Hause.

Voraussetzungen

  • je nach Host
    • grundlegende Vertrautheit mit der Verwendung eines GNU/Linux-Systems als Endbenutzer
    • (Der Trainer wird Ubuntu als Host-System verwenden)
  • Grundkenntnisse der C-Programmierung

Kurs-Fahrplan

Wer sollte teilnehmen?

Personen, die an der Entwicklung eines ressourcenbeschränkten Echtzeitsystems interessiert oder damit beauftragt sind, wie z. B. Softwareingenieure, Feldingenieure, (Projekt-)Manager, . .

Gliederung des Kurses

Tag 1

Einführung

  • Einführung | Lizenzvergabe | FreeRTOS-Lizenzierung | Echtzeit-Intro (Zeit/Utility Funktionen | Was ist Echtzeit? | Determinismus | Was ist harte Echtzeit?) | RTOS vs. Linux | IDE/Board

Aufgabenverwaltung

  • Einführung (Was ist ein task? | Task Erstellung)
    • Example01 - grobe Schleife
    • Example02 - task Parameter
    • Example03 - task Prioritäten (starvation)
    • Example04 - vTaskDelay() (idle task)
    • Example05 - vTaskDelayUntil()
    • Example06 - "kontinuierliche Verarbeitung" und vTaskDelayUntil()
    • Example07 - idle hook
    • Example08 - mit Prioritäten spielen
    • Example09 - task löschen
  • Scheduling (Was ist ein Betriebssystem? | Was ist ein task? | Was ist ein scheduler?)
  • Schedulers (Schleife | cyclic executives | Grenzen der cyclic executives | manual preemption | mit Unterbrechungen | nicht/präemptiv | priorisiertes Präventivverfahren | rate monotonic | deadline | cooperative | hybrid)

Verwaltung von Warteschlangen

  • Einführung (Was ist eine Warteschlange? | Warteschlange als Datentyp) | Queue Management (Datenspeicherung) | Zugriff durch mehrere tasks | Blockierung beim Lesen/Schreiben | Inter Task Kommunikation | Beispiel Queue Access)
    • Example10 - Warteschlange senden/empfangen (Client/Server-Muster)
    • Example11 - Warteschlangen/idle task
  • Arbeiten mit großen Daten | Generische Nachrichtenübermittlung (Indirekt/Direkt Synchron/Asynchron)

Tag 2

Interrupt Verwaltung

  • Intro (Interrupt vs. Polling | Wie kann ein Interrupt arbeiten? | Hardware/Software Interrupts | Was wäre, wenn zwei interrupts zur gleichen Zeit ankommen? | Programmabschnitte | Was ist ablaufinvarianter Code? | Was ist ein event? | Welche Art von "Ereignissen" kennen Sie?)
  • Einführung in die Gleichzeitigkeit
    • Semaphoren Intro (Gegenseitiger Ausschluss) | Synchronisierung) | Mutex vs. Synchronisation | Sempahore-Typen (Signal/Wait Muster | Binäres Semaphor | FreeRTOS Binäre Semaphore | Zählendes Semaphor)
  • Events Intro | Interrupt Handler | Interrupt Bearbeitung (aufgeschoben) | Synchronisieren einer Task mit einer "Unterbrechung"
    • Example12 - verzögerte ISR + Binäre Semaphore (Binäre Semaphore API)
    • Example13 - verzögerte ISR + Zählende Semaphore (Binäre Semaphore vs. Zählende Semaphore - Ereignisse zwischengespeichert | Zählende Semaphore API)
    • Example14 - aufgeschobene ISR + Warteschlangen (Warteschlangen und ISRs - API | Ineffiziente Nutzung der Warteschlange | Effizientere Nutzung von Warteschlangen)
  • Interrupt nesting (NVIC Kortex M3 | LPX17xx NVIC | CMSIS | FreeRTOS und interrupt nesting | Prioritäten)

Ressourcenmanagement

  • Intro (Gleichzeitigkeit | kritische Regionen/Abschnitte | atomar | race condition | Thread safety | die einzelne Variable | Verriegelung | Arten/Ursachen der Gleichzeitigkeit | Was ist schutzbedürftig/nicht schutzbedürftig? | Deadlock | Reihenfolge der Locks | Contention)
  • Ressourcenmanagement (Konfliktpotenzial - gleichzeitiger Zugriff auf Dinge | Lesen/Ändern/Schreiben | nicht-atomarer Zugriff | reentrancy | Schutz gemeinsamer Ressourcen)
  • Schutz kritischer Bereiche/Abschnitte (De-/Aktivierung von Unterbrechungen | Aussetzung/Sperrung des Schedulers | Mutex)
    • Example15 - Mutex (Mutex-API)
  • Prioritätsumkehrung (Unbegrenzt/Bounded | Quellen für unbegrenzte Prioritätsumkehrung | Lösungen? | Prioritätsumkehrung und FreeRTOS) | Deadlock (Bedingungen für Deadlock | Prävention) | Gate-keeper Tasks
    • Example16 - Gate-keeper (vApplicationIdleHook() vs. Priorität 0)
  • Mutex vs. Semaphore (Ownership/Recursive Mutex) | Geschichte

Speicherverwaltung

  • Speicherarten | Fragmentierung | Memory exhaustion | Speicherzuweisungsmuster (fest/statisch) | Variabel/Dynamisch | Stapelzuweisung, Scratch-Pad | Speicherpool) | FreeRTOS Statische Zuweisung | FreeRTOS Dynamische Allokation - FreeRTOS Heap | (Warum nicht malloc()/free() | Portierung der Speicherverwaltung heap_1/3/3/4/5.c) | xPortGetFreeHeapSize()

Tag 3

Störungsbeseitigung

  • Intro (Was ist ein Fehler/Debugging | Arten von bugs | Fehlerbehebungsstrategie) | Fehlervermeidung (Coding Wars) | Produktive Arbeitsumgebung | Build Environment | Wiederverwendung) | Spelunking (find(1), grep(1), cscope(1), global(1),...) | Modellierung/Abstraktion | Prototypen | Schulung | Anforderungen/Architektur/Entwurf (Design for Test) | Firmware Standard | Code Review) | Fehlersuche (GNU-Toolchain)
  • Fehlersuche durch Anhalten (Simulator | JTAG-Fehlersuche | RTOS-fähiger Debugger)
    • Example17 - Queue Table
  • Fehlersuche im laufenden System (Hardware-Ausnahmen) | Stack)
    • Example18 - vApplicationStackOverflowHook()/uxTaskGetStackHighWaterMark()
    • Example19 - FreeRTOS Heap MallocFailedHook()
    • Example20 - FreeRTOS task Statistik
    • Example21 - FreeRTOS-Laufzeit-Statistiken
  • Profilierung (gprof | gcov) | Andere Methoden (Hardware-Trace | Softwaregesteuerte LEDs | Oszilloskop | Logik-Analysator | 7-Segment-Anzeige | Zeichenbasiertes LCD | Grafisches Display) | FreeRTOS Trace hook macros
    • Example22 - FreeRTOS Trace-Hook-Makros 1
    • Example23 - FreeRTOS Trace-Hook-Makros 2
  • FreeRTOS: Häufige Fehlerquellen

FreeRTOS-MPU

  • Einführung (Speicherverwaltung) | Prozessor-Modi) | FreeRTOS MPU (LPC17xx MPU | Zugriffsberechtigungen | FreeRTOS-MPU-API | vom privilegierten zum Benutzermodus | Linker-Konfiguration | Praktische Tipps für die Verwendung | unter task Kommunikation)
    • Example24 - FreeRTOS MPU (Wo war der Absturz?)

Ampelsteuerung

  • Ampelsteuerung - Nutzen Sie das bisher Gelernte
    • Example40 - Ampelsteuerung (Kompilieren und Ausführen | Heartbeat-Aufgabe | FSM-Aufgabe | BenutzerEingabe-Val | Fußgänger)

Kursbroschüre (pdf)

Was die Kunden sagen