Seminar PikeOS CODEO, Simulation und CI/CD

Dieses Einzelseminar vermittelt den professionellen Entwicklungsablauf mit CODEO, QEMU-Simulation, automatisierten Builds und technischen Qualitätsgates. 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. CODEO-Arbeitsbereich und Projektstruktur
2. Partitionierung und Ressourcenmodell
3. Simulation mit QEMU
4. Konfiguration und automatisierte Builds
5. Quellnahes Debugging
6. Tracing, Ereignisse und Laufzeitanalyse
7. CI/CD und Qualitätsgates

Zielgruppe

PikeOS-Entwickler, Build- und Release-Ingenieure, DevOps-Spezialisten, Integratoren und Testautomatisierer.

Voraussetzungen

Grundkenntnisse in Embedded-Softwareentwicklung, Buildsystemen und Versionsverwaltung; erste Linux- oder Eclipse-Erfahrung ist hilfreich.

Lernziele

• CODEO-Projekte reproduzierbar strukturieren und verwalten.
• PikeOS-Systeme vor Hardwareverfügbarkeit mit QEMU aufbauen und prüfen.
• Konfiguration und Builds für eine Headless-Ausführung vorbereiten.
• Debugger und Trace zielgerichtet in den Entwicklungsprozess integrieren.
• Eine CI/CD-Pipeline mit nachvollziehbaren Artefakten und Freigabekriterien entwerfen.

Seminarinhalte

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.

Simulation mit QEMU

1. Schritt 1: Eine geeignete virtuelle Zielplattform auswählen und konfigurieren.
2. Schritt 2: Systemabbild ohne physische Hardware starten und Bootausgaben erfassen.
3. Schritt 3: Virtuelle Geräte, Netzwerke und Massenspeicher kontrolliert anbinden.
4. Schritt 4: Simulationsergebnisse gegenüber späteren Hardwaretests eindeutig kennzeichnen.

Konfiguration und automatisierte Builds

1. Schritt 1: Konfigurationswerte von Quelltext und Umgebungsdetails trennen.
2. Schritt 2: Headless-Builds mit eindeutigen Eingaben und Rückgabewerten aufsetzen.
3. Schritt 3: Artefakte, Protokolle und Prüfergebnisse für eine CI-Pipeline strukturieren.
4. Schritt 4: Abweichungen zwischen Entwicklerarbeitsplatz und Build-Server systematisch vermeiden.

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.

Praxisübungen

• Workspace mit System-, Konfigurations- und Anwendungsprojekt aufbauen.
• Systemabbild in QEMU starten und eine automatisierte Funktionsprüfung ausführen.
• Headless-Build mit eindeutigen Eingaben, Protokollen und Rückgabewerten erstellen.
• Fehlerhafte Änderung durch Debugger, Trace und Pipelineprotokoll eingrenzen.

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.