Seminar PikeOS Kompaktseminar – Architektur, CODEO und erste Anwendungen

Dieses Kompaktseminar vermittelt einen konzentrierten Einstieg in Architektur, CODEO, Partitionierung, Kommunikation und die Entwicklung einer ersten lauffähigen PikeOS-Anwendung. 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. Ports, Kanäle und Datenmodelle
6. Native-API-Laufzeitmodell
7. Build, Systemabbild und Inbetriebnahme
8. Quellnahes Debugging
9. Durchgängiges Abschlusslabor

Zielgruppe

Embedded-Entwickler, Systemintegratoren und technische Projektmitarbeiter, die einen schnellen, praxisorientierten Einstieg benötigen.

Voraussetzungen

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

Lernziele

• PikeOS-Architektur und Partitionsgrenzen sicher einordnen.
• CODEO-Arbeitsbereich und Projektstruktur selbstständig aufbauen.
• Ressourcen, Zeitfenster und Kommunikationskanäle für ein kleines System konfigurieren.
• Eine erste Native- oder POSIX-Anwendung integrieren, bauen und starten.
• Typische Fehler mit Debugger und klaren Prüfschritten beheben.

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.

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-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.

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.

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

• Kleine Mixed-Criticality-Architektur mit zwei Partitionen skizzieren.
• CODEO-Projekt und Systemkonfiguration aus einer leeren Ausgangslage anlegen.
• Erste Anwendung mit periodischem Thread und Nachrichtenkanal integrieren.
• Systemabbild in Simulation starten, Fehler einspielen und korrigieren.
• Abschlussaufgabe anhand einer technischen Abnahmecheckliste 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.