Seminar PikeOS Core Training – Grundlagen und Systemkonfiguration

Dieses Einzelseminar vermittelt die grundlegende PikeOS-Architektur, die Arbeit mit CODEO sowie die Konfiguration, Inbetriebnahme und Diagnose eines partitionierten Systems. 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. Echtzeitmodell und Zeitbudgets
5. Kommunikationsarchitektur zwischen Partitionen
6. Build, Systemabbild und Inbetriebnahme
7. Quellnahes Debugging

Zielgruppe

Neue PikeOS-Entwickler, Systemintegratoren, technische Architekten, Testingenieure und Plattformverantwortliche.

Voraussetzungen

Sichere Grundlagen in C oder C++, Embedded-Systemen und Betriebssystemkonzepten; keine PikeOS-Vorkenntnisse erforderlich.

Lernziele

• Architektur und Sicherheitsgrenzen eines PikeOS-Systems erklären.
• Ein CODEO-Projekt von der Ausgangskonfiguration bis zum Systemabbild aufbauen.
• Partitionen, Ressourcen, Zeitfenster und Kommunikationspfade korrekt konfigurieren.
• Das System in Simulation oder auf Zielhardware in Betrieb nehmen.
• Typische Start-, Kommunikations- und Laufzeitfehler systematisch diagnostizieren.

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.

Echtzeitmodell und Zeitbudgets

1. Schritt 1: Ende-zu-Ende-Zeitanforderungen in messbare Teilbudgets zerlegen.
2. Schritt 2: Partitionszeit, Thread-Laufzeit, Kommunikation und Geräteverhalten getrennt betrachten.
3. Schritt 3: Perioden, Fristen, Jitter und Überlastbedingungen eindeutig definieren.
4. Schritt 4: Annahmen und Sicherheitsmargen für spätere Messungen dokumentieren.

Kommunikationsarchitektur zwischen Partitionen

1. Schritt 1: Datenflüsse, Produzenten, Verbraucher und Vertrauensgrenzen erfassen.
2. Schritt 2: Direkte Kopplung durch klar definierte Kanäle und Nachrichtenmodelle ersetzen.
3. Schritt 3: Richtung, Datenformat, Aktualität und Ausfallverhalten spezifizieren.
4. Schritt 4: Unnötige Kommunikationsbeziehungen konsequent entfernen.

Build, Systemabbild und Inbetriebnahme

1. Schritt 1: Anwendungen und Systemkonfiguration in definierter Reihenfolge bauen.
2. Schritt 2: Systemabbild erzeugen und für Simulation oder Zielhardware bereitstellen.
3. Schritt 3: Bootablauf beobachten und Startfehler anhand belastbarer Indikatoren eingrenzen.
4. Schritt 4: Eine funktionsfähige Baseline mit Build-Protokoll und Prüfschritten sichern.

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

• Partitioniertes Beispielsystem mit zwei unterschiedlich kritischen Anwendungen entwerfen.
• Speicher-, CPU- und Kommunikationsressourcen in CODEO zuweisen.
• Systemabbild bauen, starten und anhand definierter Prüfpunkte abnehmen.
• Konfigurations- und Laufzeitfehler einspielen, eingrenzen und korrigieren.

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.