Ihr schnellster Weg
zur individuellen Embedded-Steuerung
Mit radCASE entwickeln und testen Sie die Zielapplikation bereits am PC – bevor die finale Hardware verfügbar ist.
Aus derselben Modellbasis entsteht später automatisch der Seriencode für das Embedded-Target.
Was ist radCASE?
Nicht nur modellieren.
Die Applikation vollständig entwickeln.
Mit radCASE werden Daten, I/Os, Funktionen, Abläufe, Bedienoberflächen und Metadaten in einem zentralen Modell beschrieben. Daraus entstehen die ausführbare Applikation für das Embedded-Target sowie die zugehörigen Entwicklungsfunktionen und die PC-Simulation.
Mehr als ein reines UML-Tool
Das Modell enthält nicht nur Diagramme und Architekturinformationen. Funktionalität kann direkt mit C/C++, Zustandsmaschinen, Sequenz- oder Signalplänen implementiert werden.
Mehr als ein reiner Code-Generator
radCASE erzeugt nicht nur Funktionscode, sondern nutzt dieselben Modellinformationen auch für HMI, Simulation, Monitoring und weitere Systemfunktionen.
Inklusive Testumgebung
Die PC-Simulation basiert auf der eigentlichen Applikationslogik. Hardwareein- und ausgänge und externe Prozesse werden am PC nachgebildet oder stimuliert.
Für wen ist radCASE?
Embedded entwickeln – auf Ebene der Applikation
Applikationsnahe Entwickler wählen vorhandene Module aus, instanziieren und konfigurieren sie und ergänzen die anwendungsspezifische Funktionalität. Hardwarenahe Details werden über definierte Schnittstellen getrennt angebunden.
- mehr Details zur applikationsnahen Umsetzung
Mit radCASE können Entwickler die konkrete Geräte- oder Steuerungsfunktion umsetzen, ohne sich mit allen hardwarenahen Details befassen zu müssen.
- vorhandene Module auswählen und instanziieren
- Module für die konkrete Anwendung konfigurieren
- Funktionen und Abläufe applikationsnah beschreiben
- Daten, I/Os und Bedienung im selben Modell festlegen
- HMI, Simulation und Seriencode daraus erzeugen
- Zielhardware über eine definierte API und HAL anbinden
Vorteile
Embedded-Steuergeräte inhouse entwickeln
Embedded-Applikationen entwickeln – ohne tiefes Spezialwissen über die Zielhardware.
- Technische Details
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
Sofort testen beim Entwickeln
Ihre Applikation läuft bereits realitätsgetreu als Simulation auf dem PC, bevor die Hardware verfügbar ist.
- Technische Details
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
Systemverhalten sichtbar machen
Anlagenverhalten, HMI, Messwerte und interne Zustände werden auf Applikationsebene – separat am PC – sichtbar und nachvollziehbar.
- Technische Details
- 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
Dokumentationen automatisch erzeugen
Die Entwickler- sowie Endanwender-Dokumentationen entstehen direkt aus dem aktuellen Applikationsmodell.
- Technische Details
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
Embedded-Steuergeräte selber entwickeln
Applikationsnahe Entwickler setzen die Geräte- oder Steuerungsfunktion aus vorhandenen Modulen zusammen. Hardwarenahe Details werden über definierte Schnittstellen angebunden.
1. Modellbasis erstellen
Die Grundlage bildet ein gemeinsames Modell mit wiederverwendbaren Modulen.
In der Modulbibliothek stehen definierte Bausteine bereit, die von IMACS gepflegt, erweitert und bei Bedarf um eigene Module ergänzt werden können.
2. Module instanziieren
Benötigte Module werden aus der Library übernommen und für die konkrete Anwendung ausgeprägt.
Sie werden instanziiert, parametriert und in ihrem Zusammenspiel festgelegt.
3. Applikation ausprägen
Aus den konfigurierten Modulen entsteht die konkrete Applikation.
Hier werden Funktionalität, Daten, I/Os sowie die anwendungsspezifische Ausprägung im Modell beschrieben.
4. Applikation ausführen
Aus dem Modell entstehen automatisch nutzbare Ergebnisse für das reale System.
Dazu gehören Target-Software, HMI, Visualisierung, Simulation, Testunterstützung und Dokumentation.
Vom Modell zum laufenden Serien-Code
So funktioniert radCASE
1. Anforderungen
Am Anfang stehen Spezifikation, Analyse und Nachverfolgbarkeit.
Die Anforderungen der Anwendung werden strukturiert erfasst und bilden die Grundlage für die weitere Modellierung.
2. Modellieren
Auf dieser Basis wird die Anwendung modelliert.
Dazu gehören Design, Struktur und Implementierung der Applikation in radCASE.
4. Integrieren
Die generierten Ergebnisse werden auf dem Zielsystem eingebunden.
Die Integration erfolgt über die Zielplattform, einschließlich API und BSP.
3. Generieren
Aus dem Modell erzeugt radCASE die benötigten Artefakte.
Dazu zählen insbesondere Produktionscode und Dokumentation.
5. Testen
Die integrierte Anwendung wird geprüft und freigegeben.
Dazu gehören Test, Verifikation sowie – je nach Anwendung – Freigabe und Zertifizierung.
Das Werkzeug
Modellierung
Strukturhierarchie
Modul- und Dateneditor
Code-Editor
Diagrammeditor
HMI-Editor
Simulation
Applikationssimulation
Sequenzer
Design-Level-Debugging
HMI
Visualisierung
Anlagenvisualisieurng
Recorder
Messwertdarstellung
Target-Monitoring
Ihr Ansprechpartner
Marco Paulus
