Sven Burmester

Towards the compositional verification of real-time UML designs

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.

Modular design and verification of component-based mechatronic systems with online-reconfiguration

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.

Tool integration at the meta-model level: the Fujaba approach

Today’s development processes employ a variety of notations and tools, e.g., the Unified Modeling Language UML, the Standard Description Language SDL, requirements databases, design tools, code generators, model checkers, etc. For better process support, the employed tools may be organized within a tool suite or integration platform, e.g., Rational Rose or Eclipse. While these tool-integration platforms usually provide GUI adaption mechanisms and functional adaption via application programming interfaces, they frequently do not provide appropriate means for data integration at the meta-model level. Thus, overlapping and redundant data from different “integrated” tools may easily become inconsistent and unusable. We propose two design patterns that provide a flexible basis for the integration of different tool data at the meta-model level. To achieve consistency between meta-models, we describe rule-based mechanisms providing generic solutions for managing overlapping and redundant data. The proposed mechanisms are widely used within the Fujaba Tool Suite. We report about our implementation and application experiences .

The Fujaba real-time tool suites: model-driven development of safety-critical, real-time systems

More and more complex functionality is today realized with complex, networked, real-time systems. The majority of the costs and time in development is required to design and verify the control software. As these systems are often used in a safety-critical environment, the Fujaba real-time tool suite aims at supporting the model-driven development of correct software for such safety-critical, networked, real-time systems. This paper presents an overview of this Unified Modeling Language (UML) tool, its framework and processes.

Model-driven development of reconfigurable mechatronic systems with MECHATRNOIC UML

Today, advanced technical systems are complex, reconfigurable mechatronic systems where most control and reconfiguration functionality is realized in software. A number of requirements have to be satisfied in order to apply the model-driven development approach and the UML for mechatronic systems: The UML design models must support the specification of the required hard real-time event processing. The real-time coordination in the UML models must embed the continuous control behavior in form of feedback-controllers to allow for the specification of discrete and continuous hybrid systems. Advanced solutions further require the dynamic exchange of feedback controllers at run-time (reconfiguration). Thus, a modeling of rather complex interplays between the information processing and the control is essential. Due to the safety-critical character of mechatronic systems, the resulting UML models of complex, distributed systems and their real-time behavior must be verifiable in spite of the complex structure and the embedded reconfigurable control elements. Finally, an automatic code synthesis has to map the specification correctly to code. In this paper, we will present our MECHATRONIC UML approach, which fulfills all these requirements. The approach is motivated and illustrated by means of a running example.

HYBRID UML COMPONENTS FOR THE DESIGN OF COMPLEX SELF-OPTIMIZING MECHATRONIC SYSTEMS

Language (UML), Real-Time Abstract: Complex technical systems, such as mechatronic systems, can exploit the computational power available to- day to achieve an automatic improvement of the technical system performance at run-time by means of self- optimization. To realize this vision appropriate means for the design of such systems are required. To support self-optimization it is not enough just to permit to alter some free parameters of the controllers. Furthermore, support for the modular reconfiguration of the internal structures of the controllers is required. Thereby it makes sense to find a representation for reconfigurable systems which includes classical, non-reconfigurable block diagrams. We therefore propose hybrid components and a related hybrid Statechart extension for the Unified Modeling Language (UML); it is to support the design of self-optimizing mechatronic systems by al- lowing specification of the necessary flexible reconfiguration of the system as well as of its hybrid subsystems in a modular manner.

Model-Driven architecture for hard real-time systems: from platform independent models to code

The model-driven software development for hard real-time systems promotes the usage of the platform independent model as major design artifact. It is used to develop the software logic at a high level of abstraction and enables analysis like for example model checking of critical model properties. Ideally, starting with the platform independent model, the platform specific model serves only as an intermediate artifact which is derived automatically, and will finally result in a set of threads whose implementations guarantee the behavior, specified in the platform independent model. However, the current MDA approaches and tools for hard real-time software do not provide this ideal: While some of the MDA approaches could in principle support this vision, most approaches simply do not support an appropriate specification of time constraints in the platform independent model which have to be respected in the platform specific model or in the code. This is also true for UML models and UML State Machines in particular. Our approach overcomes those UML specific limitations by firstly proposing a syntactic extension and semantic definition of UML State Machines which provides enough details to synthesize an appropriate platform specific model that can be mapped to code for hard real-time systems automatically. Secondly, a new partitioning algorithm is outlined, which calculates an appropriate mapping onto a platform specific model by means of real-time threads with their scheduling parameters which can be straight forward transformed to code for the hard real-time system.

Tool support for the design of self-optimizing mechatronic multi-agent systems

Complex technical systems, such as mechatronic systems, can exploit networking as well as the computational power available today to achieve an automatic improvement of the technical system performance at run-time through self-optimization. To realize this vision, appropriate means for the design of such self-optimizing mechatronic systems are required. Well-established techniques and tools for the modeling of cognitive behavior, reflective behavior, and control behavior exist. However, to really enable self-optimization and its full potential, these different aspects have to be safely integrated in a manner that remains comprehensible to the designer. In this article, we present how this required integration has been realized at the semantic level by extending the unified modeling language (UML), and at the tool level by integrating the CAE tool CAMeL and the CASE tool Fujaba real-time tool suite. The presented Mechatronic UML approach supports the design of verifiable, complex, reconfigurable mechatronic systems using the multi-agent system metaphor.

Tool Support for Developing Advanced Mechatronic Systems: Integrating the Fujaba Real-Time Tool Suite with CAMeL-View

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.

Making mechatronic agents resource-aware in order to enable safe dynamic resource allocation

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.