Seminar PikeOS Native API – Anwendungsentwicklung

Dieses Einzelseminar vermittelt die robuste Entwicklung echtzeitfähiger Anwendungen mit der PikeOS Native API einschließlich Threads, Zeitdiensten, Synchronisation, Kommunikation und Tests. Die Inhalte sind auf technische Umsetzbarkeit, nachvollziehbare Konfiguration und einen kontrollierten Betrieb ausgerichtet. Theorie, Demonstrationen und Laboraufgaben greifen unmittelbar ineinander.

Jeder Arbeitsschritt beginnt mit einer fachlichen Entscheidung, wird anschließend in CODEO oder am Zielsystem umgesetzt und endet mit einer prüfbaren Kontrolle. Dadurch entsteht kein reines Produktwissen, sondern ein belastbarer Arbeitsablauf für Entwicklung, Integration, Prüfung und Betrieb.

Inhaltsübersicht

1. Native-API-Laufzeitmodell
2. Threads, Prioritäten und Synchronisation
3. Zeitdienste und periodische Verarbeitung
4. Speicher, Stacks und robuste Datenhaltung
5. Ports, Kanäle und Datenmodelle
6. Native Anwendung integrieren und testen
7. Quellnahes Debugging

Zielgruppe

Embedded-C- und C++-Entwickler, Echtzeitentwickler, Systemintegratoren und technische Testingenieure.

Voraussetzungen

Sichere C- oder C++-Kenntnisse, Verständnis von Threads und Synchronisation sowie PikeOS-Core-Grundlagen.

Lernziele

• Das Native-Laufzeitmodell und seine Systemobjekte sicher anwenden.
• Threads, Prioritäten, Synchronisation und Zeitdienste deterministisch konfigurieren.
• Speicher, Stacks und Kommunikationspuffer belastbar dimensionieren.
• Native Anwendungen in Partitionen integrieren und mit Ressourcenrechten abstimmen.
• Funktionale, zeitliche und robuste Fehlerfälle automatisiert prüfen.

Seminarinhalte

Native-API-Laufzeitmodell

1. Schritt 1: Native-Prozesse, Threads, Objekte und Systemdienste fachlich einordnen.
2. Schritt 2: Initialisierung und Lebenszyklus einer nativen Anwendung strukturieren.
3. Schritt 3: Ressourcen und Rechte aus der Systemkonfiguration mit der Anwendung abgleichen.
4. Schritt 4: Fehlerzustände so behandeln, dass die Partitionsgrenze erhalten bleibt.

Threads, Prioritäten und Synchronisation

1. Schritt 1: Thread-Aufgaben und gemeinsame Zustände klar trennen.
2. Schritt 2: Prioritäten, Aktivierungsbedingungen und Stackgrößen begründet festlegen.
3. Schritt 3: Mutexe, Semaphore und Ereignisse passend zum Datenfluss einsetzen.
4. Schritt 4: Deadlocks, Prioritätsinversion und ungebundene Wartezeiten durch Tests ausschließen.

Zeitdienste und periodische Verarbeitung

1. Schritt 1: Systemzeit, monotone Zeit und anwendungsbezogene Zeit unterscheiden.
2. Schritt 2: Periodische Aktivierung mit definiertem Überlauf- und Verzögerungsverhalten umsetzen.
3. Schritt 3: Timeouts konsistent an Kommunikations- und Synchronisationsobjekte koppeln.
4. Schritt 4: Jitter und Fristverletzungen im Trace sichtbar machen.

Speicher, Stacks und robuste Datenhaltung

1. Schritt 1: Statische und dynamische Speicherverwendung nach Echtzeitbedarf auswählen.
2. Schritt 2: Stacks und Puffer mit nachvollziehbaren Annahmen dimensionieren.
3. Schritt 3: Grenzfälle durch Schutzwerte, Füllmuster und Belastungstests untersuchen.
4. Schritt 4: Speicherfehler von Kommunikations- oder Schedulingfehlern unterscheiden.

Ports, Kanäle und Datenmodelle

1. Schritt 1: Sampling- und Queuing-Verhalten nach fachlicher Semantik auswählen.
2. Schritt 2: Kapazitäten, Nachrichtengrößen und Timeout-Regeln dimensionieren.
3. Schritt 3: Datenvalidierung und Versionsfelder an der Empfängergrenze einführen.
4. Schritt 4: Kommunikationskonfiguration gegen die Systemarchitektur prüfen.

Native Anwendung integrieren und testen

1. Schritt 1: Anwendung in die Partition einbinden und Berechtigungen abstimmen.
2. Schritt 2: Build, Start und Diagnose in einer reproduzierbaren Reihenfolge ausführen.
3. Schritt 3: Funktions-, Timing- und Fehlerfälle automatisiert auslösen.
4. Schritt 4: Prüfergebnisse mit Quellstand und Konfiguration verknüpfen.

Quellnahes Debugging

1. Schritt 1: Debug-Konfiguration, Symbole und Zielverbindung korrekt vorbereiten.
2. Schritt 2: Breakpoints, Watchpoints, Register- und Speicheransichten gezielt einsetzen.
3. Schritt 3: Partitionen und Ausführungskontexte unterscheiden, ohne andere Bereiche unnötig zu beeinflussen.
4. Schritt 4: Einen reproduzierbaren Fehlerpfad mit Beobachtung, Hypothese und Gegenprobe dokumentieren.

Praxisübungen

• Native Anwendung mit mehreren Threads und periodischer Verarbeitung erstellen.
• Synchronisations- und Timeoutkonzept für gemeinsam genutzte Zustände umsetzen.
• Nachrichtenkanal zu einer zweiten Partition integrieren und Grenzfälle testen.
• Stack-, Timing- und Kommunikationsfehler instrumentieren und beheben.

Arbeitsweise

Kurze Fachblöcke werden unmittelbar durch Demonstrationen und geführte Übungen ergänzt. Konfigurationen, Quelltexte, Prüfprotokolle und Checklisten werden in einer konsistenten Laborumgebung geführt. Fehlerbilder werden nicht nur behoben, sondern systematisch eingegrenzt und dokumentiert.