Category

Wie man ein Safety-Konzept erstellt und pflegt habe ich in verschiedenen Projekten bei unterschiedlichen Kunden erfahren dürfen. Dabei gab es in jedem Projekt Momente, wo uns die Komplexität drohte zu entgleisen: Die Traceability wurde unübersichtlich, eine FMEA ist ausgeufert oder enthielt plötzlich Doppelspurigkeit, oder eine Impact-Analyse wurde wegen fehlender Dokumentation der Abhängigkeiten schier unmöglich. Dies wieder in den Griff zu bekommen hat uns viel Mühe und Aufwand gekostet.

Da war mir natürlich ein Tool wie Ansys medini analyze herzlich willkommen. Es verspricht, all meine bekannten Probleme zu lösen, indem es die gängigen Methodiken und Werkzeuge für das Safety-Konzept in einem modellbasierten Tool vereinigt. Es schlägt somit Brücken wo ich vorher mühsam mit händischer Arbeit welche finden musste.

Auch innerhalb Noser Engineering war Ansys medini analyze noch nicht bekannt. Es musste also dringend eine eigene Erfahrung her, um die Versprechungen auf die Probe zu stellen. In Zusammenarbeit mit CADFEM habe ich während 1 Woche ein kleines Beispielprojekt erstellen dürfen.

Das Beispielprojekt

Als Beispiel habe ich einen “Industrial Lasercutter and plotter” gewählt, welcher den Anforderungen der Norm IEC 61508 entsprechen muss. Die funktionalen Anforderungen waren schnell formuliert und für das Beispiel absichtlich einfach gehalten:

• High performance Laser Cutter and Laser Plotter in a single robust housing.
• Cutting and plotting of different materials and patterns with high throughput for industrial purposes.
• Ethernet connection to an order and design system for full control.
• Simple operating elements on housing for easy and safe handling.

Ein abstraktes Systemskizze gab zudem erste Einblicke in die bevorstehenden Gefahren für Mensch und Maschine.

Mit dem Beispiel habe ich mich dem gängigen Vorgehen zum Erstellen eines Safety-Konzepts durchgearbeitet.

1. Erstellen eines Systemmodells
2. Erste Hazard-Analyze für die Ermittlung der Safety-Requirements
3. Aufstellung der Safety-Requirements
4. Safety-Architektur
5. System-FMEA

Ansys medini analyze hat mir dabei die ersten Schritte danke Templates stark vereinfacht und mich mit anderen Beispielen aus dem Automotive Bereich inspiriert.

Einblick in Ansys medini analyze

Systemmodell

Als erstes habe ich ein vereinfachtes Systemmodell erstellt. Dabei sind die wichtigsten Komponenten und Funktionalitäten bereits aufgelistet. Zudem hat Ansys medini analyze es ermöglicht, zu jeder Funktionalität oder Komponente bereits die ersten Fehlerfälle sauber zu notieren.

Prelimenary Hazard-Analysis

Dank den Fehlerfällen in dem Systemmodell liess sich die “Prelimenary Hazard-Analysis” schnell und einfach erstellen. Die ermittelten Hazards konnten notiert und mit den Fehlerfällen verlinkt werden. Zudem liess sich für jede Hazard auch eine Safety Measure beschreiben.

Safety-Requirements

Die Safety Measures aus der Hazard-Analyze habe ich in Safety-Requirements sauber ausformuliert und mit der Anforderungsansicht von Ansys medini analyze einfach dargestellt.

Safety-Architektur

Danach ging es an die Safety-Architektur. In dieser habe ich das System mit den zusätzlichen Safety-Komponenten ergänzt und alle für mein Beispiel relevanten Fehlerfälle ergänzt. Wichtig war dabei auch die Verlinkung zu Safety-Requirements.

FMEA

Aus der Safety-Architektur ist es mit Ansys medini analyze nur ein Klick bis zur FMEA. Das Tool erstellt das Gerüst mit allen bekannten Fehlerfällen automatisch und bietet auch vordefinierte Risikowerte und -kategorien. Die FMEA sauber zu Füllen war dann aber doch wie gewohnt eine händische Arbeit wo viel Detailwissen über die Fehlerfälle gefragt war.

Cause/Effect-Net

Kaum war die FMEA gemacht, hatte ich dank den Cause/Effect-Nets von Ansys medini analyze die Möglichkeit zu verfolgen, welcher Fehler zu welchem Hazard führt. Dabei werden die Cause/Effect-Nets automatisch durch das Tool erstellt. Es ist sogar möglich, im Cause/Effect-Net zu arbeiten und weiter Abhängigkeiten hinzuzufügen – wobei dann die FMEA automatisch ergänzt wird!

Weitere nette Features

Bei meiner Arbeit habe ich noch folgende Features gestreift, welche ich unbedingt bei meinem nächsten Projekt einsetzen möchte:

• Task-Listen (inkl. Verantwortlichkeiten, Termine, Links)
• Sauberer Diff-Viewer (auch für Templates nutzbar)
• Sauberer und umfangreicher Reportgenerierung

Fazit

Ja, Ansys medini analyze kann seine Versprechen halten.

Das Erstellen und Pflegen eines Safety-Konzepts wird einfacher und übersichtlicher. Verlinkungen können schnell und einfach erstellt werden, der modellbasierte Ansatz garantiert dabei eine saubere Nachverfolgbarkeit.

Die aktuellen Templates sind zwar für Automotive und Aerospace ausgelegt und für Medical und Railway wären einige Vorarbeiten nötig. Aber bereits bei einem Folge-Projekt kann dank den Templates sehr schnell profitiert werden.

Ansys medini analyze ist jedoch nicht als Stand-alone Tool ausgelegt. Es ist zwar viele innerhalb des Tools möglich, z.B. mit Task-Listen oder Verlinkungen von externen Dokumenten. Trotzdem ist der Haupt-Use-Case von Ansys medini analyze die Verwendung innerhalb der Ansys Tool-Landschaft oder unterstützend zu anderen grossen Requirement- und Modellierungs-Tools.

So oder so ist klar, Noser Engineering ist bereit für das nächste safety-relevante Projekt – aber am liebsten unterstützt durch Ansys medini analyze.

Hast du dich auch schon gefragt:

“Wie mache ich eine gute Software für sicherheitskritische Anwendungen?”

Ich habe dir die besten und wichtigsten Punkte für eine sichere Software zusammengetragen und in einem 6-Schritte-Plan zusammengefasst!

Nun aber zu den Details, damit dir die 6 Schritte auch gelingen!

Schritt 1: Definiere dein Vorgehen

Für deine sichere Software musst du zuerst ein Vorgehen für den gesamten Entwicklungsprozess und Lebenszyklus definieren. Aus Sicht der Normen gehören dazu folgende Punkte:

• Qualitätsmanagement, also wie kannst du die Qualität mittels Anforderungen, Reviews und Tracing sicherstellen.

• Risikomanagement, also wie kannst du das Risiko analysieren, erkennen, dokumentieren und bewerten.

• Softwaresicherheitszyklus, also wie stellst du sicher, dass die Software am Schluss auch das macht was sie soll und keine systematischen Fehler entstehen.

• Templates und Vorgehensanweisungen für die Architektur-Dokumentation, die Architektur-Bewertung und weitere Artefakte.

Ich hoffe, du hast für diesen Schritt viel Manpower und Erfahrung in deiner Firma zu Verfügung, denn allein stemmen geht hier (fast) nicht.

Schritt 2: Kenne dein Produkt

Damit du die richtige Software erstellst, musst du natürlich dein Produkt kennen. Dazu musst du eine Anforderungsanalyse und eine Risikoanalyse machen. Sie dienen dir als Grundlage für die Qualitäts- und Sicherheitsanforderungen.

Die genaue Kenntnis der Qualitätsanforderungen ist essenziell bei einer Software im normativen Umfeld. Denn nur dadurch kannst du die richtige Architektur erstellen und am Schluss mittels Bewertung richtig analysieren. Achte darauf, dass du die Qualitätsanforderungen mittels Qualitätsszenarios definierst.

Die wichtigsten Qualitätsanforderungen, welche immer wieder im Zusammenhang mit funktionaler Sicherheit fallen und auch in deiner Architektur abgedeckt werden sollten sind:
Korrektheit, Robustheit, Deterministisch, Modular, Kapselung, Einfachheit, Aufdeckung von Fehlern.
Die Qualitätsanforderungen erfüllst du mit den richtigen Methoden, Modulen und Muster.

Die Sicherheitsanforderungen ergänzen die funktionalen Anforderungen, also was will der Benutzer vom System, mit sicherheitskritischen Anforderungen, also alles, damit der Benutzer nicht zu Schaden kommt. Die Risikoanalyse dient hier neben deiner Erfahrung als bester Input. Ein detailliertes Verständnis der Anforderungen und des Umfelds, in welchem die Software eingesetzt wird ist ebenfalls von Nöten.

Nicht zuletzt solltest du in diesem Schritt den Systemkontext definieren. Achte darauf, dass du eine saubere Trennung der Umsysteme und verständliche Verantwortlichkeiten der Schnittstellen notierst.

Und natürlich musst du alle oben genannten Punkte sauber dokumentieren.

Schritt 3: Get Ready!

Bevor du mit der Architektur anfängst empfehle ich dir wärmstens, dich in allen Belangen bereit zu machen. Dazu gehört für mich, dass du:

• Bereits eine Coding-Guideline aufstellst
• Deine Toolchain bereits in Betrieb nimmst

• Dich bereits der Themen Code-Review, Statische Code-Analyse, Testing und Continiuous Integration annimmst

• Mit DevOps und der Produktion Kontakt aufnimmst

Alle diese Themen musst du nicht fertig abarbeiten, aber sie geben einen solch wichtigen Input für deine Architektur, dass ein herausschieben meist keinen Sinn macht.

Schritt 4: Starte mit Bewährtem

Wenn du eine gute Software machst, startest du immer mit einer Architektur-Vision und Architektur-Prinzipien. Sie zwingen dich – auch wenn du voller Elan und Ideen bist – kurz inne zuhalten und das grosse Ganze in einfachen und verständlichen Punkten zu dokumentieren.

Lehne dich dabei an bestehende Architektur-Prinzipien deiner Firma an! Dies wird die Akzeptanz stark steigern und allen Projektbeteiligten helfen, eine sichere Software zu entwickeln.

In der Architektur-Vision wählst du bereits ein Architektur-Muster und legst damit den wichtigsten Baustein deiner Software. Für Embedded-Systems im normativen Umfeld eignen sich am besten Hierarchische-Systeme. Sie sind aus Bausteinen in unterschiedlichen Ebenen in einer Hierarchie angeordnet.
Der prominenteste Vertreter daraus ist das Schichten-Modell. Es biete gute Lösungen für Themen wie: Modularität, Kapselung, Einfachheit und Determinismus.

Zudem solltest du die folgenden bewährten Module in deine Software einplanen. Sie lösen dir die grundlegendsten querschnittlichen Architektur-Themen:

• Logger, also zum Loggen von Fehlern und Debug-Informationen aus allen Schichten
• Error- oder Assert-Handler, also ein systemweiter Anlauf-Punkt für Fehlerhandling
• Protective/Sanity, ein Sicherheitsmodul, welches viele Sicherheitsanforderungen realisiert
• SafetyContainers, eine Sammlung an Containers mit sichergestellter Daten-Integrität

Schritt 5: Implementiere sicher

Kommst du zur Realisierung des Systems, musst du auch sicher implementieren. Dazu gehört, dass du Safety-Measures anwendest, auf Fehleraufdeckung achtest und natürlich umfangreich testest.

Die Safety-Measures sind Massnahmen, welche du im Design und der Implementierung umsetzt, um die Software sicher zu gestalten. Die meisten Safety-Measures wurden bereits durch die Risikoanalyse gefunden, die weiteren findest du auf Grund deiner Erfahrung oder der anzuwendenden Norm. Die Safety-Measures, welche ich immer wieder angetroffen habe sind:

• Bereichsprüfungen an Schnittstellen von Komponenten
• Prüfung der zwischengespeicherten Daten mit CRC oder redundanten Daten
• Plausibilitätsprüfungen über verschiedene Daten-Arten
• Programmflussüberwachung
• Runtime-Tests zur Sicherstellung der Korrektheit des Prozessors, wie z.B. RAM, ROM
• Prüfungen auf nullptr
• Zyklisches verarbeiten und versenden der Daten

Auch beim Klassen-Design gilt es, auf bewährtes zu setzten. Dazu gehören insbesondere Design-Patterns. Die im Safety-Bereich immer wieder angetroffenen sind: Singleton, State, Observer, Factory-Pattern. Achte auch auf saubere Interfaces an Schnittstellen der Komponenten. Dies erleichtert nicht nur die Dokumentation, sondern auch das Testing.

Es ist aber auch wichtig, dass in deiner Software Fehler nicht unbemerkt bleiben. Die Fehleraufdeckung erreichst du, indem du die Fehler in der Hierarchie weiter hinauf gibst und/oder den Error- oder Assert-Handler involvierst.

Natürlich ist Testing auf allen Ebenen auch für dein sichere Software wichtig. Getestet wird wie in anderen Systemen auch. Trotzdem möchte ich dir noch ein paar Punkte mitgeben, welche mich beim Testing nach Norm immer wieder beschäftigt haben:

• Teste möglichst zeitnah und periodisch.
• Tests müssen von allen Projekt-beteiligten auch lokal ausgeführt werden können.
• Achte auf sauberes Tracing zu den Anforderungen.

Schritt 6: Reflektiere

Die Reflexion der entstandenen Software wird meist vernachlässigt. Dabei kann sie sehr viele wichtige Rückmeldungen über verbleibende Risiken geben. Ich selbst durfte auch noch nie ein “schöne” Architektur-Bewertung nach z.B. ATAM durchführen. Dazu fehlten in jedem bisherigen Projekt Zeit und Budget. Es gibt zum Glück aber noch andere Orte, wo Reflexion stattfinden kann!

Wird zum Beispiel die Architektur-Arbeit nicht nur vom Architekten alleine, sondern vom Entwicklungs-Team erledigt, bringt dies bereits bei der Erarbeitung wichtige und kritische Einblicke.

Oder du machst im Entwicklungs-Team kleine Reviews von ausgewählten Aspekten, z.B. in Form eines Walkthrough. Dies bringt trotz der Kürze bereits viele Erkenntnisse und Akzeptanz im Team mit sich.

Nutze auch die Sprint-Reviews, um wichtige Architektur-Entscheide kurz vorzustellen. Da an den Reviews meist ein interdisziplinäres Team anwesend ist, kommen die richtigen Fragen und Risiken werden so besser aufgedeckt.

In einem sicheren System ist zudem meist ein Sicherheitsnachweis normativ gefordert. Er ist eine Beweisführung, warum das System aus Sicht des Autors sicher ist und wie es die normativen Anforderungen erfüllt. Meist wird der Sicherheitsnachweis parallel oder nach der Realisierung-Phase des Projekts von einem Safety-Manager erstellt. Nutze den Austausch mit dem Safety-Manager und arbeitet wo möglich die Verbesserungen ein.

Sind wir nun fertig?

Ja, denn wenn du das alles Umsetzten kannst, hast du deine Software im Griff! Eine Prüfung nach Norm ist dann nur noch eine Formsache. Damit das gelingt und du ein Grossteil mit in dein Projekt nehmen kannst, habe ich die genannten Punkte nochmals zusammen gefasst: “Best Practice” sichere Software.

Viel Erfolg!