Sprache:
deutsch

Zielgruppe:
Software-Architekten, Embedded Linux und FPGA-Entwickler, Entwicklungleiter

Voraussetzungen:
Erfahrung mit multi-core Embedded Linux Anwendungsprogrammierung und/oder FPGA Projekten. Interesse an modellbasierten Ansätzen für Embedded Software.

Überblick und Zusammenfassungen:
Kostengünstige Einplatinencomputer, welche Rechenkerne und programmierbare Logik vereinen, eröffnen nie da gewesene Möglichkeiten für Datenverarbeitung und Steuerung nahe am Geschehen.

Während Hardware-seitig die Funktionalität wächst, sind in gleichem Maße Fähigkeiten von Nöten um selbige Software-seitig in Szene zu setzen. Zu nennen wären low-level Beschreibungssprachen wie VHDL, die Programmierung von multi-core Embedded Linux Systemen in C++ unter Nutzung aktueller Programmbibliotheken (z.B. für Datenbankzugriff), sowie schließlich die Kommunikation nach außen - sei es in Form von Web-Bedienoberflächen mit XML/JSON-Kommunikation über HTTPS, oder mittels M2M-Protokollen wie OPC UA.

Whiznium, das hier vorgestellte Entwicklungswerkzeug, bietet einen holistischen Lösungsansatz, welcher keine Detailkenntnisse dieser zahlreichen Technologien erfordert. Es generiert und verwaltet modellbasiert alle wesentlichen Bestandteile moderner Embedded Software Projekte. Die generierten Komponenten, von FPGA- über Embedded Linux Ebene bis hin zu Web-Bedienoberfläche sind "out-of-the-box" einsatzfähig bzw. synthetisierbar/kompilierfähig und können manuell um spezifische Funktionalität erweitert werden. Bei Iterationen des Modells werden manuelle Anpassungen übernommen und es gelten die "all code in plain sight" und Open Source Prinzipien: Whiznium-generierter Code ist transparent und nicht an proprietäre Programmbibliotheken gebunden.

Das vorgestellte Beispielprojekt, ein kompakter 3D Laserscanner basierend auf Microchip's neuer PolarFire SoC Plattform mit RISC-V Rechenkernen, veranschaulicht Umfang und Einsatz der folgenden Aspekte:

- Bildaufnahme und -verarbeitung von CMOS-Bildsensor in FPGA-Subsystem, auch mit "pipelined" FPGA-Algorithmus
- Hardware-Steuerung und Aufbereitung der Sensordaten in multi-threaded Embedded Linux Anwendung, Abspeichern von Metadaten in SQLite Datenbank
- mehrsprachige Web-Bedienoberfläche mit verschiedenen Userlevels
- alternative Steuerung über OPC UA und DDS, sowie Java App, die sich auf eine automatisch generierte API Bibliothek stützt

Referenzen:
Whiznium auf GitHub: https://github.com/mpsitech/wznm-WhizniumSBE, https://github.com/mpsitech/wdbe-WhizniumDBE
Whiznium StarterKit auf GitHub: https://github.com/mpsitech/wzsk-Whiznium-StarterKit, https://github.com/mpsitech/wskd-Whiznium-StarterKit-Device
The Whiznium Developer Experience auf YouTube: https://www.youtube.com/playlist?list=PLYrNHebjziwvFniIOJc_9w1Mq561VqArv
MPSI Technologies Homepage: www.mpsitech.com


Art der Vermittlung:
Referenzprojekt 3D Laserscanner. Sämtliche projektspezifischen Informationen sind online frei verfügbar. Es wird im Detail auf den Modellierungsprozess und das Arbeiten mit Whiznium-generiertem Quellcode eingegangen, welches die Präsentation von ausgesuchten Code-Bausteinen beinhaltet.

Nutzen:
Vorstellung einer eleganten Methode, moderne FPGA-SoC Systeme zeitsparend zu programmieren, ohne Kompromisse bei der Code-Qualität und damit Test- und Wartbarkeit einzugehen.

Von industriellem Monitoring über Bildverarbeitung bis hin zu elektrooptischen Messgeräten - der Ansatz hat sich bereits in den unterschiedlichsten Kundenprojekten bewährt und wird stetig weiterentwickelt.

Whiznium ist als Open Source Projekt frei verfügbar und kann zahlreiche Anwendungsfelder ohne Modifikationen abdecken. Es kann aber auch als solide Basis für anwendungs- bzw. firmenspezifische Erweiterungen dienen, so können wiederholt auftretende Programmierarbeiten zeitsparend automatisiert werden.

Durch die Verwendung der PolarFire SoC Variante des 3D Laserscanners wird zudem ein Einblick in diese spannende neue Technologie, basierend auf RISC-V, gegeben.

Sprache:
Deutsch oder Englisch

Zielgruppe:
Entwickler von adaptiven, sicherheitskritischen, Echtzeit-CPS

Voraussetzungen:
Ausbildung in Software Engineering, Modelliererfahrung hilfreich

Überblick und Zusammenfassungen:
Moderne CPS bestehen intern aus Softwarekomponenten, die sich zur Laufzeit an ihre Umgebung adaptieren können. Solche Adaptionen führen in der Software zu transienten Phasen während sich die Software umkonfiguriert. Als Beispiel sie hier das Manöver eines blinden Überholvorgangs genannt, bei dem das überholende Auto kurzzeitig vom Adaptive Cruise Control zu maximaler Beschleunigung umschalten muss, um dann wieder weich einzuscheeren. Ein solches Manöver unterliegt Echtzeitschranken, da der Überholvorgang beendet sein muss, bevor wieder Verkehr auf der Gegenfahrbahn auftritt.

In diesem Talk wird eine Methode aufgezeigt, wie man solche Szenarien mit der Modelliersprache MechatronicUML modellieren kann. Auf Basis solcher Modelle kann dann die funktionale Sicherheit garantiert werden - zumindest so lange, wie die Hardware nicht versagt.

Art der Vermittlung:
Methodenerklärung

Nutzen:
Teilnehmer lernen eine neue Methode aus der Forschung kennen, die im Kontext von immer stärker vordringender CPS, autonomen Fahren, etc. genutzt werden kann, um funktionale Sicherheit zu garantieren.

Sprache:
deutsch

Zielgruppe:
Embedded Systems- und Software-Entwickler / Führungskräfte

Voraussetzungen:
Grundkenntnisse in modellbasierter Entwicklung

Überblick und Zusammenfassungen:
UML (Unified Modeling Language) und SysML (Systems Modeling Language) sind Industriestandard-Notationen für die Modellierung, die schon seit langer Zeit entwickelt werden. An Universitäten lernen die Studenten den Umgang damit und sie werden heute breitflächig in Industrieprojekten eingesetzt.

Die UML entstand durch Zusammenführung von mehreren Notationen, die separat als de-facto Standards verwendet wurden und sich bereits bewährt hatten. Daher das "Unified" im Namen. Sie wurde speziell für den Umgang mit der wachsenden Komplexität von Software-Projekten geschaffen. Quellcode (Generierung) spielte natürlich auch eine Rolle, aber der Schwerpunkt lag und liegt nach wie vor auf dem Umgang mit der Komplexität, die durch Anwendung unterschiedlicher Diagrammtypen für verschiedene Aspekte des zu entwickelnden Software-Systems adressiert wird. Jeder am Projekt beteiligte Entwickler kann ein Modell mit Daten anreichern und Daten extrahieren, ohne durch für ihn gerade nicht relevante Informationen gestört zu werden. Für sicherheitskritische Software hat sich die Modellierung mit UML industriell verbreitet.

Die SysML ist die neuere Notation und auf Basis der UML entstanden, um Systeme (CPS) geeigneter modellieren zu können. Weil diese mächtig komplex geworden sind und deren Funktionalität fast ausschliesslich durch Software bestimmt wird, erleben wir in der Industrie gerade einen starken Anstieg der Verwendung von SysML in den Entwicklungsprojekten.

Doch wie können die resultierenden SysML-Modelle des CPS mit UML-Modellen der Software so in Beziehung gesetzt werden, dass sie innerhalb ihrer jeweiligen Domänen unabhängig voneinander entwickelt und gepflegt werden können? Dies ist nicht trivial, aber zwingend notwendig für eine nahtlose Systems-to-Software-"Übergabe". Erst eine entsprechende Automatisierung macht die Methode wirtschaftlich. Ein weiteres gutes Beispiel ist spezifisch für die Automobilindustrie, wo extrem komplexe Systeme für autonomes Fahren in SysML modelliert werden, während die Software mit Autosar-Modellierung implementiert werden muss. Die Domänenmodelle müssen irgendwie automatisch verbunden werden.

Art der Vermittlung:
Methodenerklärung, Projektbeispiel, Video, praktische Demonstration

Nutzen:
Eine pragmatische Lösung für ein lange existierendes Problem im Modeling-Umfeld, die gerade aktuell entwickelt wurde, wird gezeigt und zukünftige Möglichkeiten und Optimierungen werden diskutiert.

Entwickler mit Modeling-Ambitionen erhalten praktische Hinweise für eine Optimierung bestehender Vorgehensweisen.

Sprache:
deutsch

Zielgruppe:
Software Architekten, Entwickler, Technisches Management

Voraussetzungen:
keine

Überblick und Zusammenfassungen:
Wie sieht meine Architektur eigentlich aus und wie sollte sie aussehen?
Die Beantwortung dieser Frage ist äußerst wichtig für jedes Embedded Software Projekt.
Im Vortrag werden zunächst die zu Grunde liegenden Fragen beleuchtet:
* Was ist wichtig für eine gute Architektur?
* Welche Abstraktionen will ich in meiner Architektur sehen?
* Wie stelle ich diese dar?
* Welche Methoden und Tools unterstützen mich dabei?
Im Anschluss werden zwei gegensätzliche Vorgehensweisen zur Problemlösung vorgestellt. Beim generativen top-down Ansatz wird aus Architekturmodellen der Code für architekturrelevante Struktur und Verhalten generiert. Beim analytischen bottom-up Ansatz werden aus existierendem Code Abstraktionen in die Modelle gebracht und dargestellt. Die Vor- und Nachteile der beiden Wege für existierende und neue Projekte werden anhand von Beispielen erläutert und live demonstriert.


Art der Vermittlung:
Methodenerklärung, Beispiel und Demonstration

Nutzen:
Verständnis für die Verwendung von Modellen für die Architekturbeschreibung
Kennenlernen von Methoden für die Analyse und Generierung von Architekturen