Stefan Dziwok

The MechatronicUML method: model-driven software engineering of self-adaptive mechatronic systems

The software of mechatronic systems interacts with the systems 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.

Model-Based Design of Mechatronic Systems by Means of Semantic Web Ontologies and Reusable Solution Elements

When designing complex mechatronic systems, a team of developers will be facing many challenges that can impede progress and innovation if not tackled properly. In meeting them simulation tools play a central role. Yet it is often impossible for a single developer to foresee the overall impact a design decision will have on the system and on the other domains involved. For this task multi-domain simulation tools exists, but because of its complexity and the different levels of detail that are needed, the effort to specify a complete system from scratch is very high. Another challenge is the selection of the most suitable solution elements provided by the manufacturers. Currently they are often chosen manually from catalogues. The development engineer is therefore usually inclined to employ well-known solution elements and suppliers. To tackle both challenges our aim is an increase in efficiency and innovation by means of generally available solution knowledge, such as well-proven solution patterns, ready-to-use solution elements, and established simulation models [1].Our paper presents a tool-supported, sequential design process. From the outset, the comprehensive functional capability of the designed system is supervised by means of multi-domain simulation. At significant points in the design process, solution knowledge can be accessed as it is stored in ontologies and therefore available via Semantic Web [2]. Thus, one can overcome barriers resulting from different terminologies or referential systems and furthermore infer further knowledge from the stored knowledge. The paper focuses on an early testing in the conceptual design stage and on the subsequent semantic search for suitable solution elements. After the specification of a principle solution for the mechatronic system by combining solution patterns, an initial multi-domain model of the system is created. This is done on the basis of the active structure and of idealized simulation models which are part of a free library and associated with the chosen solution patterns via the ontologies. In further designing the controlled system and its parameters with the completed model, the developer defines additional criteria to be fed into the subsequent semantic search for solution elements. Information on the latter is provided by the manufacturers as well as detailed simulation models, which are used to analyze the functional capability of the concretized system. Therefore, the corresponding idealized models are replaced automatically with the parameterized models of the solution elements containing for example the specific friction model for the chosen motor. We show this process using the concrete example of a dough-production system. In particular, we focus on its transport system. Resulting requirements for the simulation models and their level of detail are expound, as well as the architecture and benefits of the ontologies.Copyright

A tool suite for the model-driven software engineering of cyber-physical systems

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.

Automata-based refinement checking for real-time systems

Today’s mechatronic systems are increasingly interconnected using communication protocols for realizing advanced functionality. Communication protocols underlie hard real-time constraints and need to meet high quality standards for ensuring the safety of the system. A common approach for achieving their necessary quality and mastering their impending complexity is model-driven development. Applying this approach, a developer builds formal models of the communication protocols and applies formal verification techniques (e.g., model checking) for proving that the communication is safe. However, these techniques typically face the state-explosion problem that prevents proofs for large systems like interconnected mechatronic systems. In previous publications, we introduced the MechatronicUML method that provides a compositional verification approach for tackling the state-explosion problem. A key enabler for such an approach is a definition of refinement. In this paper, we extend the compositional verification approach of MechatronicUML in particular by using different kinds of refinement definitions including an automatic selection of the most suitable refinement definition. In addition, we significantly extend an existing approach of test automata construction for refinement checking. Using this approach we can also guarantee that a refined model is constructed correctly concerning the selected and applied refinement definition. We evaluate our approach by an example of an advanced railway transportation system.

Real-Time coordination patterns for advanced mechatronic systems

Innovation in todays mechanical systems is often only possible due to the embedded software. Particularly, the software connects previously isolated systems resulting in, so-called, advanced mechatronic systems. Mechatronic systems are often employed in a safety-critical context, where hazards that are caused by faults in the software have to be prevented. Preferably, this is achieved by already avoiding these faults during development. A major source of faults is the complex coordination between the connected mechatronic systems. In this paper, we present Real-Time Coordination Patterns for advanced mechatronic systems. These patterns formalize proven communication protocols for the coordination between mechatronic systems as reusable entities. Furthermore, our approach exploits the patterns in the decomposition of the system to enable a scalable formal verification for the detection of faults. We illustrate the patterns with examples from different case studies.

How to Efficiently Build a Front-End Tool for UPPAAL: A Model-Driven Approach

We propose a model-driven engineering approach that facilitates the production of tool chains that use the popular model checker Uppaal as a back-end analysis tool. In this approach, we introduce a metamodel for Uppaal ’s input model, containing both timed-automata concepts and syntax-related elements for C-like expressions. We also introduce a metamodel for Uppaal ’s query language to specify temporal properties; as well as a metamodel for traces to interpret Uppaal ’s counterexamples and witnesses. The approach provides a systematic way to build software bridging tools (i.e., tools that translate from a domain-specific language to Uppaal ’s input language) such that these tools become easier to debug, extend, reuse and maintain. We demonstrate our approach on five different domains: cyber-physical systems, hardware-software co-design, cyber-security, reliability engineering and software timing analysis.

Solution patterns of software engineering for the system design of advanced mechatronic systems

Recently, mechatronics as a self-contained discipline has doubtlessly shaped the development of technical systems. Mechatronics means the close interaction of mechanics, electronics, control engineering and software engineering in order to achieve a better systems behavior. Due to the advancement of information and communication technologies, the functionality of mechatronic systems will go far beyond current standards along with the potential to increase their robustness, flexibility and reliability. The design of such advanced mechatronic systems is a challenge. The increasing complexity requires a consistent comprehension of the tasks between all the developers involved. Especially during the early design phases (conceptual design/ system design), the communication and cooperation between the mechanical, electrical, control and software engineers is necessary to design a first overall system model. In this context, the main difficulty is how to integrate into a system model the solutions that have already been successfully used and described in detail. Currently, the reuse is partially established during discipline-specific engineering - in areas such as mechanics and software engineering. Nevertheless, a catalogue of domain-spanning reusable abstracts that may describe solution patterns for holistic system designs does not exist. Hence, to create a collective solution space as wide as possible, it is necessary to abstract gradually the discipline-specific described solutions on a generic level. The precondition is a functional description. It is easy to see that a function has to depict the solution in a neutral and abstract way as well as the volitional relation between the input and the output of a system. In our work, we present the necessary abstraction of domain specific solutions exemplified by reusable and detailed described solutions of software engineering.

Application of an intelligent network architecture on a cooperative cyber-physical system: An experience report

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.