Ihr schnellster Weg
zur individuellen Embedded-Steuerung

radCASE richtet sich damit nicht nur an Embedded-Entwickler sondern besonders auch an applikationsnahe Entwickler (Entwickler mit Produkt-, Maschinen- oder Prozesswissen ohne tiefes Embedded-Spezialwissen).

• vorhandene Module auswählen, instanziieren und konfigurieren
• anwendungsspezifische Funktionen und Abläufe ergänzen
• Daten, I/Os und Bedienung innerhalb derselben Modulstruktur definieren
• Funktionalität in C/C++ und/oder grafischen Beschreibungsformen umsetzen
• Erstellen der Applikation unabhängig von Hardware und Zielsystems
• Anbindung des Zielsystems über API und HAL

Getestet wird nicht ein vereinfachtes Simulationsmodell, sondern die Applikation, die später auch 1:1 auf dem Embedded-Target eingesetzt wird.

• Ausführung der generierten Applikationslogik auf einem virtuellen PC-Target
• Simulation von Sensoren, Aktoren und externen Prozessen
• Prüfung von Bedienung, Abläufen und Systemzuständen
• Design-Level-Debugging auf Basis der Modellinformationen
• Selbe Applikationsbasis für Simulation und Embedded-Target

• Anlagen- und Prozessvisualisierung
• Darstellung und Bedienung der Geräte-HMI am PC
• Anzeige von Messwerten, Parametern und Metadaten
• Visualisierung aktiver Zustände und Abläufe
• Design-Level-Debugging statt ausschließlich Source-Code-Debugging
• Beobachtung und Manipulation interner Werte
• Trend-, Verlaufs- und Messwertdarstellung
• Online-Monitoring des realen Embedded-Targets
• Parametrierung und Remote-Bedienung
• Logging und Protokollierung

Die Dokumentationen werden automatisch erzeugt müssen nicht unabhängig von der Implementierung aktuell gehalten werden.

• vollständige Entwicklerdokumentation
• vollständige Anwender- und Bedienungsdokumentation
• Modul- und Applikationsstruktur
• Daten, Parameter, Ein- und Ausgänge
• Funktionen, Abläufe und Diagramme
• HMI-Screens, Bedienseiten und Navigation
• Beschreibungen, Metadaten und technische Zusammenhänge
• konsistente Neuerzeugung aus dem aktuellen Modellstand

radCASE ist vor allem für Unternehmen interessant, die Embedded-Kompetenz stärker im eigenen Haus aufbauen oder verbreitern möchten. Typische Voraussetzungen sind:

• vorhandenes Produkt-, Maschinen- oder Prozesswissen
• eigene Entwickler oder technische Fachkräfte
• wiederkehrende Embedded-Applikationen oder Produktvarianten
• Bedarf an früher Simulation und systematischer Wiederverwendung
• Bereitschaft, Applikationen modular und modellbasiert zu strukturieren

radCASE ist eine Umgebung, in der auch mit vergleichsweise überschaubaren C-Kenntnissen gearbeitet werden kann, während hardwarenahe Funktionen separat angebunden bleiben.

Der Nutzen steigt typischerweise, wenn mehrere dieser Punkte zutreffen:

• Hardware steht zu Projektbeginn noch nicht vollständig zur Verfügung
• Funktionen sollen früh am PC gezeigt oder geprüft werden
• ähnliche Funktionen werden in mehreren Geräten wiederverwendet
• HMI, Simulation und Dokumentation sollen nicht separat gepflegt werden
• mehrere Zielplattformen oder Hardwarevarianten sind vorgesehen
• die Applikation umfasst viele Daten, Parameter, I/Os oder Bedienseiten
• Entwickler- und Anwenderdokumentation sollen aus dem aktuellen Stand erzeugt werden
• Teams sollen an getrennten Modulen oder Bibliotheken arbeiten

radCASE ist konzeptionell nicht auf eine bestimmte Systemgröße begrenzt. Es ist geeignet für

• kleine Mikrocontroller-Systeme
• einzelne Steuergeräte
• Systeme mit grafischer HMI
• Systeme mit vielen I/Os
• mehrere verteilte Knoten
• Embedded-Linux-Systeme

Eher weniger geeignet ist radCASE, wenn:

• es sich um ein einmaliges, sehr kleines Programm ohne Wiederverwendung handelt
• weder HMI noch Simulation noch Dokumentation benötigt werden
• die gesamte Anwendung bereits vollständig in einer bestehenden Toolchain etabliert ist
• ausschließlich sehr hardwarenahe Treiberentwicklung im Vordergrund steht
• keine Bereitschaft besteht, Applikationswissen strukturiert im Modell zu pflegen

Ja. radCASE-Projekte können strukturiert in separate Projekt- und Bibliotheksdateien gegliedert werden. Diese Dateien lassen sich einzeln in Versionsverwaltungssystemen verwalten.

Dadurch können Teams an unterschiedlichen Modulen oder Bibliotheken arbeiten und die Ergebnisse anschließend auf Projektebene zusammenführen. Die konkrete Teamstruktur sollte dabei an Modulgrenzen und Verantwortlichkeiten ausgerichtet werden.

Ja. Bestehender C/C++-Code, eigene Bibliotheken und vorhandene Hardware können weiterverwendet und in die radCASE-Struktur eingebunden werden.

Die Anbindung an das Zielsystem erfolgt über definierte API- und HAL-Schnittstellen. Compiler, Debugger, Versionsverwaltung und weitere Entwicklungswerkzeuge lassen sich in den bestehenden Prozess integrieren. So kann radCASE schrittweise eingeführt werden, ohne die vorhandene Entwicklungsumgebung vollständig zu ersetzen.

radCASE bildet nicht nur Softwarestruktur oder UML-Diagramme ab, sondern die vollständige Embedded-Applikation. Dazu gehören Module und Submodule, Daten und Parameter, Ein- und Ausgänge, Funktionen und Abläufe, Embedded-HMI, PC-Visualisierung sowie Beschreibungen und Metadaten.

Diese Informationen werden fachlich an den jeweiligen Modulen und Elementen hinterlegt und anschließend gemeinsam für Codegenerierung, Simulation, Visualisierung und Dokumentation genutzt.

Ein Modul beschreibt eine fachlich oder technisch zusammengehörige Teilfunktion der Applikation. Es kann unter anderem enthalten:

• Daten, Parameter und I/Os
• Funktionalität und Abläufe
• untergeordnete Module
• Embedded-Bedienoberflächen
• PC-Oberflächen
• Beschreibungen und weitere Metadaten

Module können in Bibliotheken abgelegt, in Projekten mehrfach instanziiert und für die jeweilige Anwendung konfiguriert werden. Dadurch werden vollständige Teilfunktionen wiederverwendet und nicht nur einzelne Codefragmente.

radCASE überführt die im Modell definierten Module, Daten, Funktionen, Abläufe und Bedienoberflächen automatisch in C/C++-Code. Der Generator ergänzt dabei die benötigten Strukturen und verbindet die einzelnen Module zu einer ausführbaren Applikation.

Für jede Ausführungsumgebung wird der Code passend erzeugt:

• am PC mit virtueller Hardware für Simulation und Test
• auf dem Embedded-Target mit der realen Hardwareanbindung über API und HAL

Dadurch bleibt die Applikation unabhängig von der konkreten Zielhardware, während hardwarenahe Treiber und Schnittstellen gezielt angebunden werden.

Die Applikation wird in radCASE zunächst unabhängig von einer konkreten Hardwareplattform beschrieben. Module, Daten, Funktionen, Abläufe und Bedienoberflächen bleiben dadurch von Prozessor, Betriebssystem, Treibern und realen Schnittstellen getrennt.

Die Verbindung zur Zielhardware erfolgt anschließend über definierte API- und HAL-Schnittstellen. Dort werden unter anderem I/Os, Kommunikation, Treiber, Scheduler und betriebssystemspezifische Funktionen angebunden.

So kann dieselbe Applikationsbasis:

• am PC mit virtueller Hardware ausgeführt werden
• auf unterschiedliche Embedded-Targets übertragen werden
• bei einem Hardwarewechsel weitgehend erhalten bleiben

Angepasst werden muss vor allem die hardwarenahe Anbindung, nicht die gesamte Applikation.

Verteilte Systeme können als gemeinsames Projekt modelliert werden. Dabei werden Module den jeweiligen Hardwareknoten zugeordnet.

Der Generator kann für jeden Knoten eigenen Applikationscode sowie die benötigten Kommunikationsstrukturen erzeugen. Auch die Simulation verteilter Systeme auf einem PC wird in der Produktdokumentation beschrieben.

radCASE erzeugt aus dem aktuellen Applikationsmodell sowohl die technische Entwicklerdokumentation als auch die vollständige Anwenderdokumentation.

Dafür werden die bereits im Modell enthaltenen Informationen genutzt, etwa Modul- und Systemstruktur, Daten und Parameter, Funktionen und Abläufe, Diagramme, HMI-Screens, Bedienseiten und Navigation. Änderungen im Modell werden dadurch konsistent in beide Dokumentationen übernommen.

Ja. Für die PC-Simulation wird die modellierte Applikation für eine PC-Ausführungsumgebung generiert. Die gleiche Applikationslogik wird anschließend für das Embedded-Target erzeugt.

Unterschiedlich ist nur die Anbindung an die Umgebung:

• am PC über virtuelle Hardware und simulierte Ein-/Ausgänge
• auf dem Target über API, HAL, Treiber und reale Schnittstellen

Dadurch wird nicht eine separate Testsoftware geprüft, sondern die spätere Zielapplikation in einer anderen Ausführungsumgebung.

Beim Design-Level-Debugging wird nicht nur im Quellcode gesucht, sondern direkt auf Ebene der modellierten Applikation. Sichtbar sind dabei beispielsweise Module, Zustände, Datenflüsse und aktuelle Werte.

Beispiel:
Eine Pumpe startet nicht, obwohl die Freigabe gesetzt ist. Statt einzelne Variablen im Code zu verfolgen, sieht der Entwickler direkt im Modell:

• welches Modul aktiv ist
• welcher Zustand gerade anliegt
• welche Bedingung den nächsten Schritt verhindert
• welche Ein- und Ausgangswerte aktuell wirksam sind
• wie sich der Ablauf in der Simulation oder am realen Target verhält

So bleibt der technische Zusammenhang der Funktion erhalten und die Ursache lässt sich schneller eingrenzen.

Die Simulation führt die Applikation ohne reale Zielhardware auf dem PC aus. Hardware, Umgebung oder Prozess werden dabei virtuell abgebildet.

Die Online-Visualisierung verbindet sich dagegen mit einem realen Embedded-System. Sie kann unter anderem zur Fernbedienung, Parametrierung, Beobachtung, Protokollierung und zum Design-Level-Debugging verwendet werden.

Beide verwenden die Selben, im Modell definierten Daten und Oberflächen. Dadurch wird dieselbe fachliche Darstellung sowohl während der Entwicklung als auch am realen System eingesetzt.

Ja. Die mit radCASE erzeugte PC-Visualisierung kann mit dem realen Embedded-Target verbunden werden. Dadurch lassen sich aktuelle Messwerte, Parameter und Systemzustände anzeigen, verändern und protokollieren.

Je nach Anwendung sind außerdem Remote-Bedienung, Monitoring und Design-Level-Debugging am laufenden System möglich. Dabei werden dieselben modellierten Daten und Metadaten verwendet wie in Simulation und Applikation.