Verlässliche Echtzeitsysteme
Sprung zu den Vorlesungsinhalten
Sprung zu den Übungsinhalten
- 05.03.2026 Aufgrund der (durch die benötigte Hardware) limitierten Teilnehmerzahl ist für die Veranstaltung eine Anmeldung via StudOn zwingend erforderlich. Diese ist ab sofort bis zum 06.10.2024, 23:55 geöffnet. Bitte schreibt uns unbedingt ein kurzes Motivationsschreiben (in das StudOn-Anmeldeformular), warum ihr gerne VEZS belegen möchtet.
- 05.03.2026 Bitte beachten: Der aktuelle Zustand ist lediglich aus dem letzten Semester portiert. Alle angegebenen Daten und Termine sind vorläufig oder veraltet!
Inhalt der Vorlesung
Während sich die Veranstaltung Echtzeitsysteme den zeitlichen Aspekten der Systementwicklung widmet, rücken in Verlässliche Echtzeitsysteme Methoden und Techniken für die Entwicklung zuverlässiger Systeme in den Mittelpunkt - schließlich ist Rechtzeitigkeit keine hinreichende Eigenschaft sicherheitskritischer Systemen. Beide Veranstaltungen sind unabhängig voneinander durchführbar, ergänzen sich jedoch in optimaler Weise. Ziel der Vorlesung ist die zuverlässige Entwicklung von Software (frei von internen Fehlern) ebenso wie die Entwicklung zuverlässiger Software (robust gegenüber äußeren Fehlern). Im Fokus steht hierbei weniger die Vermittlung theoretischer Grundkenntnisse, sondern vielmehr deren praktischer Einsatz in Form von:- Fehlersuche und -vermeidung: funktional, räumlich und zeitlich,
- unter Einsatz existierender Werkzeuge und Methoden wie sich auch in der Industrie zum Einsatz kommen.
- Robuste Echtzeitsysteme durch Fehlertoleranz und Verteilung
Inhalt der Übungen
Im Rahmen der Übungen werden ausgewählte Vorlesungsinhalte mit besonderem Fokus auf deren praktischer Anwendung vertieft. Zum Einsatz kommen hierbei sowohl aktuelle Ansätze und Methoden aus der Forschung, als auch Werkzeuge und Techniken aus dem industriellen Umfeld. Hierzu zählt insbesondere auch die Fehlersuche mittels Debugger und die Codeanalyse mit der aiT-Toolchain (WCET-Analyse, Stack-Analyse, Abstrakte Interpretation mit Astrée). Im Verlauf des Semesters wird die Verwendung der verschiedenen Techniken und Werkzeuge in den verschiedenen Phasen der Produktentwicklung aufgezeigt, indem ein solcher Entwicklungszyklus simuliert wird. Die Übung wird in zwei Ausprägungen angeboten:- Grundlegende Übungen [Ü_EZS] (2,5 ETCS)
- Erweiterte Übungen [EÜ_EZS] (5 ECTS)
Für die Bearbeitung der Übungsaufgaben sind entsprechend grundlegenden Programmierkenntnissen in C und/oder C++ notwendig. Hierfür ausreichend ist eine der folgenden Grundlagenveranstaltungen: Systemprogrammierung I/II, Softwaresysteme I, Systemnahe Programmierung in C beziehungsweise äquivalenter Veranstaltungen. Eine erfolgreiche Teilnahme ist für Nebenfächler auch auf der Basis der Grundlagen der Informatik (Programmiersprache: Java) möglich. Hierfür ist die Bereitschaft der eigenständigen (veranstaltungsbegleitenden) Aneignung grundlegender C/C++ Kenntnisse jedoch zwingend erforderlich. Entsprechende Unterlagen und Literaturempfehlungen werden von uns gerne bereitgestellt. Kenntnisse aus der Schwesterveranstaltung Echtzeitsysteme sind durchaus hilfreich, jedoch nicht für einen erfolgreichen Abschluss des Moduls erforderlich.
Weiterhin sind grundlegende Erfahrungen im Umgang mit der Linux-Umgebung in den CIP-Pools beziehungsweise deren Aneignung erforderlich.
Fragebogen: Programmierkenntnisse
Zur Einordnung der eigenen C-Kenntnisse haben wir einen Aufgabenkatalog aus Systemnahe Programmierung in C zusammengestellt. Teilnehmer, die sowohl die meisten Fragen sicher beantworten als auch die Programmieraufgabe lösen können, sollten keine handwerklichen Probleme mit den Übungsaufgaben haben und können sich voll auf die zu vermittelnden Konzepte konzentrieren. Fällt die Beantwortung der Fragen schwer, sollten die fraglichen Programmierkonzepte und die Bedeutung der unbekannten Schlüsselwörter vor Belegung des Moduls nachrecherchiert werden, da diese nicht im Rahmen der Übung vermittelt werden können.
Wochenplan
| Mo | Di | Mi | Do | Fr | |
|---|---|---|---|---|---|
| 08:00 | |||||
| 10:00 | Rechnerübung
CIP3
|
||||
| 12:00 | Vorlesung
02.133-113
|
||||
| 14:00 | Übung
02.133-113
|
||||
| 16:00 | Rechnerübung
CIP3
|
Terminübersicht (Semesterplan)
| KW | Mo | Di | Mi | Do | Fr | Themen |
|---|---|---|---|---|---|---|
| 42 | 14.10 | 15.10 | 16.10 | 17.10 | 18.10 | Vorlesung 1: EZS Zusammenfassung Vorlesung 1: Organisation (Vorlesung) Vorlesung 1: Einleitung Übung 1: Organisation Übung 1: Einführung in den Umgang mit git |
| Vorlesung 1 | ||||||
| Übung 1 | ||||||
| Ausgabe A1 | ||||||
| 43 | 21.10 | 22.10 | 23.10 | 24.10 | 25.10 | Vorlesung 2: Grundlagen Übung 2: Implementieren eines Filters mit Festkommaarithmetik |
| Vorlesung 2 | Fester Termin A1 | |||||
| Übung 2 | ||||||
| Ausgabe A2 | ||||||
| 44 | 28.10 | 29.10 | 30.10 | 31.10 | 01.11 | Vorlesung 3: Fehlertoleranz durch Redundanz Übung 3: Triple Modular Redundancy |
| Vorlesung 3 | ||||||
| Übung 3 | ||||||
| Ausgabe A3 | ||||||
| 45 | 04.11 | 05.11 | 06.11 | 07.11 | 08.11 | Vorlesung 4: Codierung |
| Vorlesung 4 | Fester Termin A2 | |||||
| 46 | 11.11 | 12.11 | 13.11 | 14.11 | 15.11 | Vorlesung 5: Fehlerinjektion Übung 4: EAN Codes und Fehlerinjektion |
| Vorlesung 5 | ||||||
| Übung 4 | ||||||
| Ausgabe A4 | ||||||
| 47 | 18.11 | 19.11 | 20.11 | 21.11 | 22.11 | Vorlesung 6: Dynamisches Testen Übung 5: Testen |
| Vorlesung 6 | Fester Termin A3 | |||||
| Übung 5 | ||||||
| Ausgabe A5.1 | ||||||
| 48 | 25.11 | 26.11 | 27.11 | 28.11 | 29.11 | Vorlesung 7: Grundlagen der statischen Programmanalyse |
| Vorlesung 7 | Fester Termin A4 | |||||
| Ausgabe A5.2 | ||||||
| 49 | 02.12 | 03.12 | 04.12 | 05.12 | 06.12 | Vorlesung 8: Verifikation nicht-funktionaler Eigenschaften, Stack- und WCET-Analyse |
| Vorlesung 8 | ||||||
| Ausgabe A5.3 | ||||||
| 50 | 09.12 | 10.12 | 11.12 | 12.12 | 13.12 | Vorlesung 9: Verifikation funktionaler Eigenschaften: Design-by-Contract Übung 6: Stackverbrauchs Analyse |
| Vorlesung 9 | Fester Termin A5.1 | |||||
| Übung 6 | ||||||
| Ausgabe A6 | ||||||
| 51 | 16.12 | 17.12 | 18.12 | 19.12 | 20.12 | |
| Fester Termin A5.2 | ||||||
| 52 | 23.12 | 24.12 | 25.12 | 26.12 | 27.12 | |
| Weihnachten/Neujahr | ||||||
| 01 | 30.12 | 31.12 | 01.01 | 02.01 | 03.01 | |
| Weihnachten/Neujahr | ||||||
| 02 | 06.01 | 07.01 | 08.01 | 09.01 | 10.01 | |
| Weihnachten/Neujahr | Fester Termin A5.3 | |||||
| 03 | 13.01 | 14.01 | 15.01 | 16.01 | 17.01 | Vorlesung 10: Fallstudie Reaktorschutzsystem Übung 7: Abstrakte Interpretation |
| Vorlesung 10 | Fester Termin A6 | |||||
| Übung 7 | ||||||
| Ausgabe A7 | ||||||
| 04 | 20.01 | 21.01 | 22.01 | 23.01 | 24.01 | |
| Fester Termin A7 | ||||||
| 05 | 27.01 | 28.01 | 29.01 | 30.01 | 31.01 | Vorlesung 11: Industrievortrag Funktionale Sicherheit |
| Vorlesung 11 | ||||||
| 06 | 03.02 | 04.02 | 05.02 | 06.02 | 07.02 | Vorlesung 12: Zusammenfassung & Fragestunde Übung 8: Zusammenfassung |
| Vorlesung 12 | ||||||
| Übung 8 | ||||||
Vorlesung
Gliederung und Vorlesungsfolien
Die Vorlesungsfolien werden im PDF-Format als animierte Folien und als Handout im Format DIN A4 angeboten.
All slides are copyrighted © 2012-13 by Fabian Scheler, © 2014-20 by Peter Ulbrich, and © 2020-24 by Peter Wägemann University of Erlangen-Nürnberg, Germany. Use without prior written permission of the authors is not permitted!
| Kapitel | Thema | Datum | Folien |
|---|---|---|---|
| 0 | EZS Zusammenfassung | 14.10.2024 | |
| 1 | Organisation (Vorlesung) | 14.10.2024 | |
| 2 | Einleitung | 14.10.2024 | |
| 3 | Grundlagen | 21.10.2024 | |
| 4 | Fehlertoleranz durch Redundanz | 28.10.2024 | |
| 5 | Codierung | 04.11.2024 | |
| 6 | Fehlerinjektion | 11.11.2024 | |
| 7 | Dynamisches Testen | 18.11.2024 | |
| 8 | Grundlagen der statischen Programmanalyse | 25.11.2024 | |
| 9 | Verifikation nicht-funktionaler Eigenschaften, Stack- und WCET-Analyse | 02.12.2024 | |
| 10 | Verifikation funktionaler Eigenschaften: Design-by-Contract | 09.12.2024 | |
| 11 | Fallstudie Reaktorschutzsystem | 13.01.2025 | |
| 12 | Industrievortrag Funktionale Sicherheit | 27.01.2025 | |
| 13 | Zusammenfassung & Fragestunde | 03.02.2025 |
All slides are copyrighted ©2005-14 by Wolfgang Schröder-Preikschat, ©2007-14 by Fabian Scheler, ©2014-19 by Peter Ulbrich, FAU Erlangen-Nürnberg, Germany, ©2022 by Peter Wägemann, FAU Erlangen-Nürnberg, Germany. Use without prior written permission of the authors is not permitted!
Literatur
Zur Begleitung und Vertiefung des Vorlesungsinhalts kann auf folgende Fachbücher zurückgegriffen werden:
- Michael Lyu, editor. Software Fault Tolerance, volume 3 of Trends in Software. John Wiley & Sons, Inc., 1995. http://www.cse.cuhk.edu.hk/~lyu/book/sft/.
- Shubu Mukherjee. Architecture Design for Soft Errors. Morgan Kaufmann Publishers Inc., San Francisco, CA, USA, 2008.
- Olga Goloubeva, Maurizia Rebaudengo, Matteo Sonza Reorda, and Massimo Violante. Software-Implemented Hardware Fault Tolerance. Springer-Verlag, 233 Spring Street, New York, NY 10013, USA, 2006.
Hierbei ist aber zu beachten, dass sich der Inhalt der Vorlesung nicht streng an einem dieser Bücher orientiert und sich keineswegs auf diese Bücher beschränkt. Die gezielte Aufarbeitung der einzelnen Vorlesungskapitel kann anhand der Literaturhinweise am Ende der jeweiligen Foliensätze erfolgen. Grundlegende Erläuterungen zu den Fachbegriffen und Grundtechniken fehlertoleranter Systeme sollten darüber hinaus in jedem Fachbuch vermittelt werden, das sich mit diesem Themengebiet befasst.
Übung
Ziel der Übung
Analog zur Vorlesung befassen sich die Übungsaufgaben mit der zuverlässigen Entwicklung zuverlässiger Software. Im Rahmen eines Produktentwicklungszyklus werden in den Übungsaufgaben sowohl selbstgeschriebene als auch fremde Codestücke unter die Lupe genommen. Die Programmiersprache ist hierbei vorwiegend C. Als Vorraussetzung für die Übung sollte man deshalb grundlegende C-Kenntnisse mitbringen.
Das Ziel der Übungsaufgaben ist die Entwicklung eines konkreten Echtzeitsystems auf Anwendungsebene. Zu diesem Zweck kommt das Echtzeitbetriebssystem eCos als Entwicklungsplattform zum Einsatz. eCos wird in den verschiedensten Anwendungen (Kommunikation, Steuerung, ...) und Produkten (z.B. NETGEAR-Routern) eingesetzt und ist auch als Open-Source-Variante verfügbar. In den Übungen wird ein konkretes Echtzeitsystem auf Basis von eCos aufgebaut, anhand dessen sich die verschiedenen Problemstellungen bei der Entwicklung solcher Systeme zeigen lassen.
Zuverlässige Software entwickeln
Während der erste Teil sich auf das Finden von Entwicklungsfehlern konzentriert, betrachten wir in der zweiten Hälfte auch Fehler, die zur Laufzeit auftreten können. Hierzu zählen vor allem unerwartete Hardwarefehler, die den Programmfluss bzw. Rechenergebnisse beeinflussen können. In der Übung werden wir hierzu verschiedene konstruktive Maßnahmen kennenlernen und umsetzen, die die Software gegen derartige Fehlerszenarien härten können.
Zuverlässig entwickeln
Ein wesentlicher Bestandteil dieser Veranstaltung ist das Kennenlernen und der Umgang mit Werkzeugen, die die Entwicklung verlässlicher Systeme unterstützen. Hierzu zählen u.a.:
- Versionsverwaltung von Quellcode mit Hilfe von git
- Softwaretest mittels CMake und CTest
- Codeüberdeckungsanalyse mittels gcov (lcov)
- Überdeckungsorientiertes Fuzzing mittels libFuzzer
- Fehlerinjektion mittels FAIL*
- Statische Bestimmung des Speicherbedarfs (StackAnalyzer)
- Statische Codeanalyse mit Hilfe abstrakter Interpretation (Astrée)
- Formale Verifikation mittels Frama-C
Umfang der Übungen
Der Umfang der Übungen richtet sich nach den angestrebten Prüfung und den dafür notwendigen ECTS-Punkten (zusätzlich zu den 2,5 ECTS der Vorlesung):
- 2,5 ECTS: Die Bearbeitung aller Basis-Übungsaufgaben ist verpflichtend.
- 5,0 ECTS: Die Bearbeitung aller Basis- und Erweiterungs-Übungsaufgaben ist verpflichtend.
Sowohl Tafelübungen als auch Rechnerübungen werden zusammen stattfinden, da sich die beiden Übungsrichtungen hauptsächlich im Umfang der zu bearbeitenden Aufgaben unterscheiden.
Folien und Dokumentation
| Kapitel | Thema | Datum | Folien |
|---|---|---|---|
| U1 | Organisation | 14.10.2024 | |
| U2 | Einführung in den Umgang mit git | 14.10.2024 | |
| U3 | Implementieren eines Filters mit Festkommaarithmetik | 21.10.2024 | |
| U4 | Triple Modular Redundancy | 28.10.2024 | |
| U5 | EAN Codes und Fehlerinjektion | 11.11.2024 | |
| U6 | Testen | 18.11.2024 | |
| U7 | Stackverbrauchs Analyse | 09.12.2024 | |
| U8 | Abstrakte Interpretation | 13.01.2025 | |
| U9 | Zusammenfassung | 03.02.2025 |
Übungsaufgaben
| Nr. | Titel | Kurzbeschreibung | Ausgabetermin | Fester Termin | Vorgaben |
|---|---|---|---|---|---|
| 1 | git | Einführung in den Umgang mit git | 14.10.2024 | 25.10.2024 | Aufgabe 1 |
| 2 | Filter | Implementieren eines Filters mit Festkommaarithmetik | 21.10.2024 | 08.11.2024 | Aufgabe 2 |
| 3 | TMR | Schutz durch Einbringung von Redundanz | 28.10.2024 | 22.11.2024 | Aufgabe 3 |
| 4 | EAN | Schutz durch arithmetische Codierung | 11.11.2024 | 29.11.2024 | Aufgabe 4 |
| 5.1 | Testen | Manuelles und automatisiertes Testen | 18.11.2024 | 13.12.2024 | Aufgabe 5.1 |
| 5.2 | Testen | Manuelles und automatisiertes Testen | 25.11.2024 | 20.12.2024 | Aufgabe 5.2 |
| 5.3 | Testen | Manuelles und automatisiertes Testen | 02.12.2024 | 10.01.2025 | Aufgabe 5.3 |
| 6 | Statische Analyse | Clang Static Analyzer, Stack Analyse, WCET | 09.12.2024 | 17.01.2025 | Aufgabe 6 |
| 7 | Abstrakte Interpretation | Implementierung und Korrektheitsnachweis eines einfachen Ringpuffers und Filters | 13.01.2025 | 24.01.2025 | Aufgabe 7 |
Kontakt
Dozenten und Betreuer
Inhaltliche Fragen (alle Teilnehmer & Betreuende):
Organisatorische Fragen (Betreuende)
Anmeldung
Da die Mailingliste auch für Bekanntmachungen unsererseits genutzt wird, empfehlen wir allen Teilnehmern ausdrücklich die Anmeldung.

