Software für Embedded Systems entwickeln: Mit UML schneller zur einer strukturierten Softwarearchitektur

(openPR) Software für Embedded Systems entwickeln bedeutet weit mehr als Code zu schreiben. Embedded Software muss eng mit der Hardware zusammenarbeiten, Echtzeitanforderungen erfüllen und zuverlässig funktionieren. Was die Sache nicht einfacher macht: Mehr Funktionen, mehr Schnittstellen und höhere Anforderungen an Qualität, Wartbarkeit und Testbarkeit seitens der Systeme stellen Entwickler vor große Herausforderungen.

Eine Möglichkeit, diese Komplexität beherrschbar zu machen, ist die modellbasierte Entwicklung mit UML. Statt die Softwarearchitektur ausschließlich im Quellcode abzubilden, wird das System zunächst grafisch modelliert. Verhalten, Strukturen und Zusammenhänge lassen sich dadurch bereits auf Modellebene beschreiben, analysieren und testen. Hier helfen moderne IT-Anwendungen wie Embedded UML Studio: Die Lösung verbindet IBM Rhapsody mit den SodiusWillert-Modulen UML Target Debugger und Real-time Execution Framework RXF sowie Adaptern für Compiler, Zielplattformen und Echtzeitbetriebssysteme. Damit entsteht eine durchgängige Umgebung, um Software für Embedded Systeme modellbasiert zu entwickeln, zu simulieren, zu testen und anschließend Source Code aus den getesteten Modellen zu generieren.

Was bedeutet es, Software für Embedded Systems zu entwickeln?

Embedded Software ist Software, die Bestandteil eines technischen Systems oder Produkts ist und dessen Funktionen steuert oder überwacht. Anders als klassische PC-Software ist sie häufig eng an eine bestimmte Hardware, einen Prozessor, Sensoren, Aktoren oder ein Echtzeitbetriebssystem gekoppelt.

Typische Beispiele sind Steuerungen in Maschinen und Anlagen, Automotive-Systeme, Medizintechnik, Haushaltsgeräte oder vernetzte IoT-Geräte.

Bei der Entwicklung spielen deshalb mehrere Ebenen zusammen:

• Anforderungen und Funktionen
• Architektur des Gesamtsystems
• Softwarearchitektur
• Hardware und Prozessor
• Firmware und Treiber
• Kommunikationsschnittstellen
• Echtzeitverhalten
• Tests und Validierung
• Wartbarkeit und Dokumentation

Aktuelle Übersichten zur Embedded-Softwareentwicklung beschreiben ebenfalls einen strukturierten Entwicklungsprozess von Anforderungen und Hardwareauswahl über Architektur und Implementierung bis hin zu Test, Sicherheit und Wartung.

Gerade bei komplexeren Projekten stellt sich deshalb die Frage: Wie lässt sich die Softwarearchitektur so darstellen, dass Entwickler Zusammenhänge verstehen, Fehler früh erkennen und die Konsistenz zwischen Modell, Code und Dokumentation erhalten können?

UML als Grundlage für die Entwicklung von Embedded Software

Die Unified Modeling Language (UML) bietet eine standardisierte grafische Notation, um Softwarestrukturen und Softwareverhalten zu beschreiben. Statt beispielsweise das Verhalten einer Steuerungslogik ausschließlich in vielen Zeilen C- oder C++-Code nachvollziehen zu müssen, kann es mit UML-Diagrammen visualisiert werden. Klassen, Komponenten, Zustände, Abläufe und Interaktionen lassen sich dadurch aus unterschiedlichen Perspektiven betrachten.

Für die Entwicklung von Embedded Software sind insbesondere Verhaltensmodelle interessant. Zustandsautomaten können beispielsweise abbilden, welche Zustände ein System einnimmt und wie es auf Ereignisse reagiert. Sequenzdiagramme zeigen Interaktionen zwischen Komponenten oder Objekten.

IBM Rhapsody übernimmt dabei die Rolle als modellbasierte Entwicklungsumgebung für Echtzeit- und Embedded-Anwendungen. UML-Modelle können für Design, Simulation, Validierung, Testing, Dokumentation und Codegenerierung eingesetzt werden.

Warum Modellierung bei Embedded Projekten hilfreich ist

Bei der Entwicklung von Software für Embedded Systems entstehen schnell komplexe Abhängigkeiten. Eine Änderung an einer Funktion kann Auswirkungen auf mehrere Komponenten haben. Gleichzeitig müssen Entwickler häufig Hardware, Softwarearchitektur und zeitliches Verhalten gleichzeitig berücksichtigen. Ein grafisches Modell schafft hier eine zusätzliche Abstraktionsebene.

Die wichtigsten Vorteile sind:

• Besseres Verständnis:
  Komplexe Zusammenhänge lassen sich grafisch darstellen und leichter mit anderen Entwicklern, Architekten und Projektbeteiligten diskutieren.
• Strukturierte Softwarearchitektur:
  Komponenten, Klassen und Beziehungen werden explizit modelliert. Dadurch entsteht eine nachvollziehbare Struktur, bevor sich die Komplexität ausschließlich im Source Code widerspiegelt.
• Frühzeitige Fehlererkennung:
  Modelle können bereits während der Entwicklung analysiert und simuliert werden. Fehler in Verhalten oder Architektur lassen sich dadurch früher entdecken.
• Automatische Codegenerierung:
  Aus getesteten Modellen kann Source Code generiert werden. Das reduziert manuelle Übertragungsarbeit zwischen Design und Implementierung.
• Aktuelle Dokumentation:
  Das Modell beschreibt gleichzeitig die Struktur und das Verhalten der Software. Dadurch kann es als lebendige technische Dokumentation dienen.

Das Ziel ist dabei nicht, Code durch Diagramme zu ersetzen. Vielmehr wird das Modell zu einer zentralen Entwicklungsgrundlage.

Embedded UML Studio: Modellbasierte Entwicklung bis zum Zielsystem

Mit Embedded UML Studio lassen sich die Vorteile der UML-Modellierung gezielt für Embedded-Softwareprojekte nutzen.

Die Lösung besteht aus:

• IBM Rhapsody
• SodiusWillert UML Target Debugger
• SodiusWillert Real-time Execution Framework RXF
• Adaptern für Compiler
• Adaptern für Zielplattformen
• Adaptern für Real-time Operating Systems

Damit unterstützt Embedded UML Studio den gesamten Weg vom UML-Modell bis zur Ausführung auf dem tatsächlichen Embedded Target.

1. Softwarearchitektur grafisch modellieren

Die Entwicklung beginnt auf Modellebene. Entwickler können die Struktur ihrer Software mit UML beschreiben und Komponenten, Klassen und Beziehungen übersichtlich organisieren.

Das schafft eine gemeinsame Grundlage für die Kommunikation im Entwicklungsteam und hilft dabei, die Architektur frühzeitig zu überprüfen.

2. Verhalten auf Modellebene simulieren

Ein besonderer Vorteil der modellbasierten Entwicklung ist die Möglichkeit, das Verhalten bereits auf Modellebene dynamisch zu untersuchen. So können Entwickler beispielsweise Zustandsübergänge und Interaktionen überprüfen, bevor die vollständige Software auf der Zielhardware ausgeführt wird. Fehler werden dadurch nicht erst entdeckt, wenn die Implementierung bereits weit fortgeschritten ist.

3. Getestete Modelle in Source Code überführen

Ist das Modell entwickelt und getestet, kann daraus Source Code generiert werden. Damit entsteht eine Verbindung zwischen Architektur, Verhalten und Implementierung: Das Modell ist nicht nur eine Dokumentation des fertigen Codes, sondern ein aktiver Bestandteil des Entwicklungsprozesses.

4. Modelle auf dem Zielsystem debuggen

Mit dem UML Target Debugger geht die Modellierung noch einen Schritt weiter. Das Modell kann auf dem tatsächlichen Zielsystem debuggt werden. Entwickler können damit die Verbindung zwischen dem abstrakten Modell und dem real ausgeführten Embedded System nachvollziehen.

Gerade bei komplexen Echtzeitsystemen ist diese Verbindung zwischen Modell und Target besonders interessant.

5. Echtzeitverhalten mit RXF umsetzen

Das Real-time Execution Framework RXF stellt die Verbindung zwischen UML-Modell und Zielplattform her und ermöglicht die Umsetzung modellbasierter Anwendungen für Embedded Targets. Damit wird UML nicht nur zur Beschreibung der Software eingesetzt. Das Modell kann Bestandteil einer durchgängigen Entwicklung bis zur Ausführung auf dem Embedded System werden.

Ready-to-use Adapter für Compiler, Zielplattformen und RTOS

Embedded-Projekte unterscheiden sich stark hinsichtlich Prozessor, Compiler, Zielhardware und Betriebssystem. Deshalb ist eine modellbasierte Entwicklungsumgebung allein noch nicht ausreichend. Entscheidend ist auch die Anbindung an die konkrete Zielumgebung. Embedded UML Studio bietet dafür ready-to-use Adapter für gängige Compiler, Zielplattformen und Real-time Betriebssysteme. Das reduziert den Integrationsaufwand und erleichtert es, die modellbasierte Entwicklung in bestehende Embedded-Toolchains einzubinden.

Single Source of Truth für Modell und Dokumentation

Ein häufiges Problem in Softwareprojekten ist die zunehmende Abweichung zwischen Architektur-Dokumentation und tatsächlicher Implementierung. Wird die Dokumentation separat gepflegt, besteht das Risiko, dass Änderungen im Code nicht entsprechend im Architekturmodell nachvollzogen werden – oder umgekehrt. Bei der modellbasierten Entwicklung mit Embedded UML Studio steht dagegen das Modell im Mittelpunkt.

Es kann gleichzeitig als:

• Architekturmodell,
• Verhaltensbeschreibung,
• Grundlage für Simulation und Tests,
• Ausgangspunkt für die Codegenerierung und
• technische Dokumentation

dienen. Damit entsteht eine Single Source of Truth für Modelle und Dokumentation.

Das ist insbesondere dann wertvoll, wenn Embedded Software über viele Jahre weiterentwickelt und gewartet wird.

Software für Embedded Systems entwickeln: Welche Vorteile bietet der modellbasierte Ansatz?

Die modellbasierte Entwicklung ist insbesondere für Projekte interessant, bei denen Softwarekomplexität, Echtzeitverhalten und langfristige Wartbarkeit eine wichtige Rolle spielen.

HerausforderungAnsatz mit Embedded UML StudioKomplexe SoftwarearchitekturGrafische Modellierung mit UMLSchwer nachvollziehbares VerhaltenDynamische Simulation auf ModellebeneFehler werden spät entdecktFrühe Validierung und TestsHoher manueller ImplementierungsaufwandAutomatische Source-Code-GenerierungModell und Dokumentation laufen auseinanderModell als aktuelle DokumentationsbasisVerbindung zum Embedded TargetDebuggen des Modells auf dem ZielsystemUnterschiedliche ToolchainsAdapter für Compiler, Zielplattformen und RTOSHohe Komplexität in EchtzeitsystemenModellbasierte Entwicklung dank RXF

HerausforderungAnsatz mit Embedded UML StudioKomplexe SoftwarearchitekturGrafische Modellierung mit UMLSchwer nachvollziehbares VerhaltenDynamische Simulation auf ModellebeneFehler werden spät entdecktFrühe Validierung und TestsHoher manueller ImplementierungsaufwandAutomatische Source-Code-GenerierungModell und Dokumentation laufen auseinanderModell als aktuelle DokumentationsbasisVerbindung zum Embedded TargetDebuggen des Modells auf dem ZielsystemUnterschiedliche ToolchainsAdapter für Compiler, Zielplattformen und RTOSHohe Komplexität in EchtzeitsystemenModellbasierte Entwicklung dank RXF

Für welche Entwickler ist Embedded UML Studio geeignet?

Embedded UML Studio richtet sich an Entwickler und Entwicklungsteams, die Software für Embedded Systeme designen, entwickeln und testen. Besonders relevant ist der Ansatz für Projekte, bei denen eine nachvollziehbare Softwarearchitektur, modellbasiertes Testen und eine enge Verbindung zwischen Design und Implementierung wichtig sind. Dabei kann die Umgebung sowohl für neue Projekte als auch als Grundlage für eine schrittweise Weiterentwicklung bestehender Entwicklungsprozesse eingesetzt werden.

On-Premise oder Cloud mit Citrix

Embedded UML Studio kann entsprechend der IT- und Entwicklungsumgebung des Kunden eingesetzt werden. Möglich sind sowohl On-Premise-Szenarien als auch die Nutzung in einer Cloud-Umgebung mit Citrix. Für Unternehmen, die bereits mit einer Jazz-Umgebung arbeiten, kann die Lösung in die vorhandene Umgebung eingebunden werden. Unterstützt werden dabei sowohl Windows als auch Linux, abhängig von der jeweiligen eingesetzten Umgebung und Konfiguration.

Flexible Lizenzmodelle für unterschiedliche Anforderungen

Embedded-Softwareprojekte unterscheiden sich hinsichtlich Teamgröße, Projektlaufzeit und Einsatzszenario. Daher steht Embedded UML Studio mit flexiblen Kauf- und Mietlizenzen zur Verfügung. Das Angebot wird entsprechend dem individuellen Bedarf und den jeweiligen Vereinbarungen mit dem Kunden zusammengestellt.

Je nach Projekt kann beispielsweise zunächst eine zeitlich begrenzte Evaluierungslizenz eingesetzt werden. Nach Auftragserteilung erhält der Kunde den entsprechenden Download-Link und Lizenzschlüssel beziehungsweise bei nativen Jazz Tools den Berechtigungsnachweis zur Generierung des Keys. Die Preise beginnen je nach Lizenzmodell und Anzahl der Nutzer bei etwa 1.000 Euro und können bei größeren Konfigurationen im fünfstelligen Bereich liegen.

Software für Embedded Systems entwickeln mit einem durchgängigen Modell

Wer Software für Embedded Systems entwickeln möchte, muss heute nicht nur effizienten Source Code erzeugen. Ebenso wichtig sind eine klare Architektur, nachvollziehbares Verhalten, frühe Tests und eine langfristig wartbare Dokumentation. Die modellbasierte Entwicklung mit UML bietet dafür einen strukturierten Ansatz. Mit Embedded UML Studio werden IBM Rhapsody und die SodiusWillert-Technologien UML Target Debugger und RXF um die notwendigen Verbindungen zu Compilern, Zielplattformen und Echtzeitbetriebssystemen ergänzt.

So können Entwickler ihre Embedded Software grafisch modellieren, Verhalten simulieren, Modelle testen, Source Code aus getesteten Modellen generieren und die Modelle anschließend auf dem Zielsystem debuggen.