Automotive systems provide sophisticated functionality and are controlled by networked electronic control units (ECUs). Nowadays, software engineers use component-based development approaches to develop their software. Moreover, software components have to be allocated to ECUs to be executed. Engineers have to cope with topology-, software-, and timing dependencies and memory-, scheduling-, and routing constraints. Currently, engineers use linear programming to specify allocation constraints manually and to compute a feasible allocation specification automatically. However, encoding the allocation problem as a linear program is a complex and error-prone task. This paper contributes a model-driven, object constraint language based, and graph pattern based allocation engineering approach for reducing the engineering effort and to avoid failures. We validate our approach with an automotive case study. We specify the software component model, the hardware platform model, and the allocation constraint specification with our engineering approach MechatronicUML. Our validation shows that we can specify allocation constraints with less engineering effort and are able to compute feasible allocation specifications automatically.

Systems and software engineers realize innovative functionality in cyber-physical systems by connecting previously independent systems. The development of these systems becomes more challenging because the systems’ complexity, the amount of the safety-critical software, the heterogeneity of the underlying platforms, and the connectivity of the systems increase steadily. However, existing model-driven approaches do not cover the different engineers’ concerns efficiently during the different development tasks. Many of these approaches have a focus on the formal design and the verification of safety and real-time properties. Though, the question how to retain the systems’ safety during following construction tasks remains open. This thesis focuses on the construction tasks: physical system integration validation, resource allocation, and the implementation. It presents a highly automated end-to-end modeldriven approach for the development of interacting cyber-physical systems that are realized on heterogeneous, distributed platforms. The approach covers the validation of the system integration via model-in-the-loop simulation, constraint-driven software to hardware allocation, and generative software construction. Consequently, the approach retains the system’s safety with respect to systematic errors through different development tasks. It enables engineers to detect and avoid design and implementation flaws. Thereby, it improves the reliability of systems during their operation. It enables an effective and efficient seamless development. This thesis evaluates the approach by providing an integrated development environment and conducting several case studies from the automotive and automation domain. The evaluation shows the effective and in comparison to state of the art approaches more efficient application of: (1) the model-in-the-loop simulation in the context of virtual prototypes, (2) the allocation constraint specification and the automated allocation planning, and (3) the generation of executables for heterogeneous, distributed embedded platforms.

Cyber-physical Systems are distributed, embedded systems that interact with their physical environment. Typically, these systems consist of several Electronic Control Units using multiple processing cores for the execution. Many systems are applied in safety-critical contexts and have to fulfill hard real-time requirements. The model-driven engineering paradigm enables system developers to consider all requirements in a systematical manner. In the software design phase, they prove the fulfillment of the requirements using model checking. When deploying the software to the executing platform, one important task is to ensure that the runtime scheduling does not violate the verified requirements by neglecting the model checking assumptions. Current model-driven approaches do not consider the problem of deriving feasible execution schedules for embedded multi-core platforms respecting hard real-time requirements. This paper extends the previous work on providing an approach for a semi-automatic synthesis of behavioral models into a deterministic real-time scheduling. We add an approach for the partitioning and mapping development tasks. This extended approach enables the utilization of parallel resources within a single ECU considering the verification assumptions by extending the open tool platform App4mc. We evaluate our approach using an example of a distributed automotive system with hard real-time requirements specified with the MechatronicUML method.

Cyber-physical systems provide sophisticated functionality and are controlled by networked electronic control units (ECUs). Nowadays, software engineers use componentbased development approaches for developing the software. Moreover, software components have to be allocated to an ECU in order to be executed. Engineers have to cope with topology, software, and timing dependencies and memory, scheduling, and routing constraints [Al13]. Currently, engineers use techniques like integer linear programming or SAT-based encodings to specify allocation constraints and to derive a feasible allocation automatically. However, encoding constraints manually is a complex task [ZP13].

Cyber-physical systems (CPSs) provide sophisticated functionality and are controlled by networked electronic control units (ECUs). Nowadays, software engineers use component-based development approaches to develop their software. Moreover, software components have to be allocated to an ECU to be executed. Engineers have to cope with topology-, software-, and timing-dependencies and memory-, scheduling-, and routing-constraints. Currently, engineers use linear programs to specify allocation constraints and to derive a feasible allocation automatically. However, encoding the allocation problem as a linear program is a complex and error-prone task. This paper contributes a model-driven, OCL-based allocation engineering approach for reducing the engineering effort and to avoid failures. We validate our approach with an automotive case study modeled with MechatronicUML. Our validation shows that we can specify allocation constraints with less engineering effort and are able to derive feasible allocations automatically.

Future smart systems will provide functionality by dynamically interacting with each other in cyber-physical systems. Such interactions require a message-based coordination under hard real-time constraints. This is realized by complex software, which combines discrete, state-based behavior with continuous behavior controlling the dynamics of the physical system parts. The development methods and tools for these kinds of software are not well integrated so far. For the modeling and simulation of physical and continuous control behavior, Modelica can be used. For modeling the discrete coordination behavior, MECHATRONICUML (MUML) can be used, which in addition offers a formal verification of safety requirements like deadlock-freedom of interactions, for example. We introduce in this paper an automatic transformation for formally verified MUML models into Modelica to ensure that the discrete state-based software correctly interacts with the continuous control software, physical parts, and a plant model. We illustrate this concept by means of a car-to-car coordination scenario.

Future cyber-physical systems will behave smart, i.e., they will provide self-* properties and collaborate with each other. Software realizes this smart behavior. In modern cars, a hardware platform consists of up to 100 networked electronic control units (ECUs) that execute the software. As the amount of safety-critical software increases, the task of describing a suitable hardware platform for deploying safety-critical software components to ECUs becomes more complicated. Existing approaches for the definition of a hardware platform do not address the different stakeholder's concerns and do not provide a systematic method. This leads to an error-prone development. In this paper, we identify viewpoints for the stakeholder's concerns and provide a method for the multi-view modeling of hardware platforms. In addition, we support hierarchical and variable horizontal composition of hardware platforms by transferring concepts from component-based software engineering. To test our method, we use an Arduino-based cooperative adaptive cruise control system.

Today's embedded systems often do not operate individually anymore. Instead, they form so called cyber-physical systems, where the overall functionality is provided by the collaboration of systems. Consequently, the design of this collaboration is an important activity during development and strongly affects system quality. In previous work, we presented a catalog of reusable message-based real-time coordination patterns to avoid manual creation of new and, thus, error-prone designs. In this paper, we present an implementation of this catalog by a library in the Modelica language and an appropriate development process. The library stores ready to reuse solutions for common coordination activities and, thus, increases efficiency and effectiveness for use. Furthermore, the use of Modelica enables early holistic simulation of cyber-physical systems including feedback controllers and message-based coordination. We illustrate the library with examples from an autonomous railway vehicle and present an early evaluation.

The software of mechatronic systems interacts with the system's physical environment. In such systems, an incorrect software may cause harm to human life. As a consequence, software engineering methods for developing such software need to enable developers to effectively and efficiently proof their correctness. This is further complicated by additional characteristics of mechatronic systems as self-adaptation and coordination with other systems. In this poster, we present MechatronicUML which is a model-driven software engineering method that especially considers these characteristics of self-adaptive mechatronic systems.

Cooperative cyber-physical systems (CCPS) are driven by the tight coordination between computational components, physical sensors and actuators, and the interaction with each other over system bounds. The software development of CCPS is getting more complex because of the tight integration, heterogeneous technologies, as well as safety and timing requirements. Therefore, new engineering approaches, such as model-driven development methods, are required, along with communication architectures with self-* capabilities. Both will support the developer in specifying such a system effectively and efficiently. However, the application of such techniques for the development of CCPS has not been addressed sufficiently so far. This paper presents an experience report of developing a cooperative delta-robot system that juggles a ball without a central control or camera system. For the development, an intelligent network architecture and model-driven development method for CCPS are applied.

Cyber-physical systems, e.g., autonomous cars or trains, interact with their physical environment. As a consequence, they commonly have to coordinate with other systems via complex message communication while realizing safety-critical and real-time tasks. As a result, those systems should be correct by construction. Software architects can achieve this by using the MechatronicUML process and language. This paper presents the MechatronicUML Tool Suite that offers unique features to support the MechatronicUML modeling and analyses tasks.

No AccessTag des Systems EngineeringJan 2013Modellbasierter Entwurf zweier kooperierender Delta-RoboterHeinrich Teichrieb, Viktor Just, Stefan Dziwok, Uwe Pohlmann, Thomas Schierbaum, Ansgar TrächtlerHeinrich Teichrieb, Viktor Just, Stefan Dziwok, Uwe Pohlmann, Thomas Schierbaum, Ansgar TrächtlerReglungstechnik und Mechatronik, Heinz Nixdorf Institut, Universität Paderborn, Fürstenallee 11, 33102 Paderborn, [heinrickteichrieb, viktor.just, ansgar.traechtler]@hni.upb.dehttps://doi.org/10.3139/9783446436039.022SectionsAboutPDF ToolsAdd to FavoritesDownload CitationTrack CitationsCopy LTI LinkPDF key 'share (en)' returned an object instead of string.FacebookTwitterEmailLinkedIn previous chapternext chapter FiguresReferencesRelatedDetails 2013Pages: 217-228Print ISBN: 978-3-446-43435-6eISBN: 978-3-446-43603-9 Copyright & Permissions© 2012 Carl Hanser Verlag GmbH & Co. KGPDF downloadLoading ...

The number of software components within a cyber-physical systems increases continuously. However, not all components are needed at all time. Because of structural changes of software and hardware it is possible to use resources more efficiently. For example, energy is saved by shutting down currently not needed ECUs. Software component instances (SCIs) must be deployed to an electronic control unit (ECU) to be executed. A safe deployment must consider the changes of the software and hardware structure. State-of-the-art deployment algorithms are not designed for reconfigurable software applications and reconfigurable hardware platforms. This paper presents first ideas how to specify reconfigurable hardware platforms and how to consider software and hardware changes for a safe deployment at design time. We demonstrate the properties of our deployment approach for reconfigurable cyber-physical systems by using Lego mindstorms robots.

Much of the innovation in today’s technical systems is only possible by the use of embedded software. This is especially true in the case of system of systems where autonomous systems coordinate using complex message-based communication protocols. Mechatr

Increasingly, innovative functionality in embedded systems is realized by connecting previously autonomous embedded systems.This requires real-time communication and coordination between these connected systems.Modelica and the StateGraph2 library provide a good environment for modeling embedded systems including controllers and physics.However, it lacks appropriate support for modeling the communication and coordination part.In this paper, we present an extension to the State-Graph2 library that enables modeling asynchronous and synchronous communication and rich real-time constraints.We illustrate our extension of the State-Graph2 library by modeling and simulating two miniature robots driving in a platoon.

This paper presents an approach to use the Functional Mockup Interface (FMI) for integration of classical controller specifications and statechartbased specifications of real-time critical message exchange protocols.The Functional Mockup Unit (FMU) is automatically generated from the specification.Using the generated FMU we are able to exploit simulation facilities as provided by Modelica/Dymola.

Innovation in cyber-physical systems is today largely driven by embedded software. Thus, appropriate approaches have to be employed to handle the complexity that results from the multi-discipline nature of these innovative cyberphysical systems. Modelica as modeling language specifically targets these multi-discipline systems. The UML profile ModelicaML combines the graphical notation of the UML with the sound formal modeling provided by Modelica. ModelicaML currently does not support modeling asynchronous communication which is increasingly required when cyber-physical systems have to coordinate their behavior. In this paper, we present our approach for Modelica code generation from ModelicaML state machines which have been extended by asynchronous communication. We illustrate our approach by an extended two tanks system that contains two distributed controllers which coordinate themselves by message exchange.