The next generation of advanced mechatronic systems is expected to use its software to exploit local and global networking capabilities to enhance their functionality and to adapt their local behavior when beneficial. Such systems will therefore include complex hard real-time coordination at the network level. This coordination is further reflected locally by complex reconfiguration in form of mode management and control algorithms. We present in this paper the integration of two tools which allow the integrated specification of real-time coordination and traditional control engineering specifically targeting the required complex reconfiguration of the local behavior.

No abstract available

Today, complex, networked, self-adaptive mechatronic systems which integrate advanced control engineering and software engineering concepts within a single software system are envisioned. These systems adapt their structures at runtime to react to detected environmental changes, to change their system goals, or to react to a change of the system structure. To enable the development of such systems, an integration of object-oriented modeling techniques such as UML and control theory approaches such as functional block modeling is required. Thereby, the successful visual modeling concepts of control engineering should be preserved, as otherwise wide acceptance in industry, which is mainly dominated by control engineers, is very unlikely. In this paper, we present such a visual integration for UML 2.0 components, statecharts, and block diagrams developed within the MECHATRONlC UML approach. It permits to graphically model reconfiguration between several pre-defined configurations with statecharts and instance diagrams as well as to specify the flexible assembly of control configuration if needed by means of visual reconfiguration rules.

Mechatronic systems are embedded software systems with hard real-time requirements. Predictability is of paramount importance for these systems. Thus, their design has to take the worst-case into account and the maximal required resources are usually allocated upfront by each process. This is safe, but usually results in a rather poor resource utilization. If in contrast resource-aware agents, which are able to allocate and free resources in a controllable safe manner, instead of thumb processes are present, then a resource manager will coordinate their safe dynamic resource allocation at run time. But given such a resource manager, how can we transform thumb processes into smart resource-aware agents? Starting with mechatronic components that describe their reconfiguration by means of statecharts, we present how to automatically synthesize the additional information and code, which enables a process to become a resource-aware agent.

The development of complex mechatronic systems requires a careful and ideally verifiable design. In addition, engineers from different disciplines, namely mechanical, electrical and software engineering, have to cooperate. The current technology is to use block diagrams including discrete blocks with statecharts for the design and verification of such systems. This does not adequately support the verification of large systems which improve the system behavior at run-time by means of online reconfiguration of its controllers because the system as whole has to be verified. It also does not support cooperative interdisciplinary work because a white-box view on all blocks involved in the online reconfiguration is required. This paper proposes a rigorous component concept based on the notion of UML component diagrams which enables modular composition and decomposition of complex systems with online reconfiguration given by hierarchical hybrid component specifications. The approach enables compatibility checks between components that are often independently developed (across the different disciplines) and supports compositional model checking based on a rigorously defined semantics.

Current techniques for the verification of software as e.g. model checking are limited when it comes to the verification of complex distributed embedded real-time systems. Our approach addresses this problem and in particular the state explosion problem for the software controlling mechatronic systems, as we provide a domain specific formal semantic definition for a subset of the UML 2.0 component model and an integrated sequence of design steps. These steps prescribe how to compose complex software systems from domain-specific patterns which model a particular part of the system behavior in a well-defined context. The correctness of these patterns can be verified individually because they have only simple communication behavior and have only a fixed number of participating roles. The composition of these patterns to describe the complete component behavior and the overall system behavior is prescribed by a rigorous syntactic definition which guarantees that the verification of component and system behavior can exploit the results of the verification of individual patterns.