Seminar PikeOS Intensivseminar Entwicklung und Laufzeitumgebungen

Dieses Intensivseminar vermittelt einen durchgängigen Entwicklungsweg von PikeOS-Grundlagen über Native-, POSIX- und ARINC-653-Anwendungen bis zu Linux-Gästen, Diagnose und CI/CD. 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. PikeOS-Architektur und Systemmodell
2. CODEO-Arbeitsbereich und Projektstruktur
3. Partitionierung und Ressourcenmodell
4. Native-API-Laufzeitmodell
5. Threads, Prioritäten und Synchronisation
6. POSIX-Laufzeitumgebung unter PikeOS
7. POSIX-Threads und Synchronisationsobjekte
8. ARINC-653-Systemmodell und IMA-Kontext
9. Sampling- und Queuing-Ports
10. Linux-Gastarchitektur und Verantwortungsgrenzen
11. Virtuelle Geräte, Netzwerk und Speicher
12. Integrität, Fehlerszenarien und Prüfung
13. Quellnahes Debugging
14. Tracing, Ereignisse und Laufzeitanalyse
15. CI/CD und Qualitätsgates
16. Durchgängiges Abschlusslabor

Zielgruppe

Entwickler, Systemintegratoren, technische Architekten und Testingenieure, die mehrere PikeOS-Laufzeitumgebungen in einem kompakten Gesamtprogramm beherrschen müssen.

Voraussetzungen

Sichere C- oder C++-Kenntnisse, Erfahrung mit Embedded- oder Echtzeitsystemen und Bereitschaft zu umfangreichen Laborarbeiten.

Lernziele

• Ein partitioniertes PikeOS-System von der Architektur bis zum reproduzierbaren Build aufsetzen.
• Native-, POSIX- und ARINC-653-Anwendungen passend zum jeweiligen Laufzeitmodell entwickeln.
• Linux als Gast mit kontrollierten virtuellen Geräten integrieren.
• Kommunikation und Zeitverhalten über unterschiedliche Laufzeitumgebungen abstimmen.
• Debugging, Tracing, Performanceprüfung und CI/CD in einen gemeinsamen Qualitätsprozess einbinden.

Abgedeckte Themenfelder

• PikeOS ARINC 653 und IMA-Integration
• PikeOS CODEO, Simulation und CI/CD
• PikeOS Core Training – Grundlagen und Systemkonfiguration
• PikeOS Debugging, Tracing und Monitoring
• PikeOS Echtzeit, Scheduling und Zeitpartitionierung
• PikeOS Kompaktseminar – Architektur, CODEO und erste Anwendungen
• PikeOS Linux als Gastbetriebssystem
• PikeOS Native API – Anwendungsentwicklung
• PikeOS Performanceanalyse und Optimierung
• PikeOS POSIX – Echtzeitanwendungen
• PikeOS Sichere Inter-Partition-Kommunikation

Seminarinhalte

PikeOS-Architektur und Systemmodell

1. Schritt 1: Separation Kernel, Typ-1-Hypervisor und Systemsoftware voneinander abgrenzen.
2. Schritt 2: Partitionen, Gastumgebungen, Anwendungen und Hardware-Ressourcen in ein gemeinsames Modell einordnen.
3. Schritt 3: Zeitliche und räumliche Trennung als Grundlage für Mixed-Criticality-Systeme bewerten.
4. Schritt 4: Eine Zielarchitektur mit klaren Vertrauens- und Verantwortungsgrenzen skizzieren.

CODEO-Arbeitsbereich und Projektstruktur

1. Schritt 1: Workspace, Projektarten, Toolchain und Zielplattform kontrolliert auswählen.
2. Schritt 2: Projektabhängigkeiten, Build-Varianten und Artefaktpfade nachvollziehbar strukturieren.
3. Schritt 3: BSP, PSP und Laufzeitumgebung dem Projekt korrekt zuordnen.
4. Schritt 4: Eine reproduzierbare Ausgangskonfiguration erzeugen und versionieren.

Partitionierung und Ressourcenmodell

1. Schritt 1: Partitionen aus technischen und sicherheitsbezogenen Anforderungen ableiten.
2. Schritt 2: Speicherbereiche, CPU-Zeit, Gerätezugriffe und Kommunikationswege zuweisen.
3. Schritt 3: Startreihenfolge, Zustände und Fehlergrenzen konfigurieren.
4. Schritt 4: Die Konfiguration auf Vollständigkeit, Konflikte und unnötige Berechtigungen prüfen.

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.

POSIX-Laufzeitumgebung unter PikeOS

1. Schritt 1: Unterstützte POSIX-Konzepte und PikeOS-spezifische Grenzen einordnen.
2. Schritt 2: Prozess- und Threadmodell einer vorhandenen Anwendung analysieren.
3. Schritt 3: Abhängigkeiten von Bibliotheken, Dateisystem und Geräten erfassen.
4. Schritt 4: Portierungsstrategie mit klaren Austausch- und Anpassungspunkten festlegen.

POSIX-Threads und Synchronisationsobjekte

1. Schritt 1: pthread-Attribute, Schedulingklasse und Prioritäten explizit konfigurieren.
2. Schritt 2: Mutexe, Condition Variables, Semaphore und Barrieren passend auswählen.
3. Schritt 3: Prioritätsvererbung und Zeitüberschreitungen kontrolliert einsetzen.
4. Schritt 4: Nebenläufigkeitsfehler durch wiederholbare Last- und Störungstests sichtbar machen.

ARINC-653-Systemmodell und IMA-Kontext

1. Schritt 1: Modul, Partition, Prozess, Zeitplan und Health Monitoring voneinander abgrenzen.
2. Schritt 2: IMA-Ziele auf ein partitioniertes PikeOS-System übertragen.
3. Schritt 3: APEX-Dienste den Anwendungsanforderungen zuordnen.
4. Schritt 4: Konfigurations- und Anwendungsanteile mit klarer Verantwortlichkeit festlegen.

Sampling- und Queuing-Ports

1. Schritt 1: Kommunikationsbedarf nach Aktualitäts- oder Ereignissemantik klassifizieren.
2. Schritt 2: Portparameter, Nachrichtengrößen und Kanäle konsistent konfigurieren.
3. Schritt 3: Gültigkeit, Überlauf und leere Queues im Anwendungscode behandeln.
4. Schritt 4: Sender- und Empfängerzeitverhalten über den Modulzeitplan prüfen.

Linux-Gastarchitektur und Verantwortungsgrenzen

1. Schritt 1: Linux-Aufgaben von sicherheitskritischen PikeOS-Partitionen abgrenzen.
2. Schritt 2: CPU, Speicher, Geräte und Kommunikationswege für den Gast festlegen.
3. Schritt 3: Bootabhängigkeiten und Vertrauensgrenzen in der Systemarchitektur markieren.
4. Schritt 4: Aktualisierung und Wiederanlauf des Gastes vom Basissystem entkoppeln.

Virtuelle Geräte, Netzwerk und Speicher

1. Schritt 1: Virtuelle Geräte dem Gast eindeutig zuordnen und PikeOS-seitig bereitstellen.
2. Schritt 2: Netzwerkpfade, Adressierung und Filterregeln kontrolliert konfigurieren.
3. Schritt 3: Block- und Dateisystemzugriffe mit Fehler- und Wiederanlauffällen prüfen.
4. Schritt 4: Gerätelast und Interruptverhalten auf andere Partitionen beobachten.

Integrität, Fehlerszenarien und Prüfung

1. Schritt 1: Fehlerhafte, veraltete und unvollständige Nachrichten erzeugen.
2. Schritt 2: Empfängerreaktionen und Fehlerbegrenzung gegen definierte Kriterien prüfen.
3. Schritt 3: Trace-Daten von Sender, Kanal und Empfänger zeitlich zusammenführen.
4. Schritt 4: Prüffälle und erwartete Ergebnisse für Regressionstests festhalten.

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.

Tracing, Ereignisse und Laufzeitanalyse

1. Schritt 1: Messziel, Ereignisklassen und notwendige Zeitauflösung festlegen.
2. Schritt 2: Trace-Erfassung mit begrenztem Einfluss auf das Zielsystem konfigurieren.
3. Schritt 3: Zeitachsen, Zustandswechsel und Kommunikationsereignisse korrelieren.
4. Schritt 4: Aus Messdaten eine belastbare Ursache-Wirkungs-Kette ableiten.

CI/CD und Qualitätsgates

1. Schritt 1: Build-, Konfigurations- und Testschritte als deterministische Pipeline definieren.
2. Schritt 2: Statische Prüfungen, Simulationstests und Hardwaretests sinnvoll staffeln.
3. Schritt 3: Freigabekriterien für Artefakte und Konfigurationen maschinenlesbar festlegen.
4. Schritt 4: Fehlerhafte Änderungen durch Rückverfolgbarkeit und reproduzierbare Wiederholung eingrenzen.

Durchgängiges Abschlusslabor

1. Schritt 1: Anforderungen für ein kleines partitioniertes System präzisieren.
2. Schritt 2: Projekt, Partitionen, Kommunikation und Zeitverhalten schrittweise umsetzen.
3. Schritt 3: System in Simulation oder auf Zielhardware starten und instrumentieren.
4. Schritt 4: Fehlerfall einspielen, Ursache bestimmen und die korrigierte Baseline nachprüfen.

Praxisübungen

• Mehrpartitionensystem mit Native-, POSIX- und ARINC-653-Anwendung entwerfen.
• Kommunikationskette über unterschiedliche Laufzeitumgebungen implementieren und zeitlich prüfen.
• Linux-Gast mit virtuellem Netzwerk oder Speicher integrieren und isoliert belasten.
• Fehlerfall über Debugger und Trace analysieren und als CI-Regression automatisieren.
• Abschlusslabor aus Architektur, Build, Deployment, Störung und dokumentierter Abnahme durchführen.

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.