| Chair | Hans Vangheluwe
School of Computer Science McGill University Tel. 514 398 44 46 |
Co-Chair | Jan F. Broenink
Control Laboratory University of Twente Tel. +31-53-489 2793 |
| Acting Chair | Pieter J. Mosterman
Institute of Robotics and Mechatronics DLR Oberpfaffenhofen Tel. +49 8153 282434 |
The use of models in systems engineering is rapidly increasing. For example, models are used for knowledge representation, structured analysis, to manage complexity and achieve high quality of engineered systems, to handle the heterogeneous nature of embedded systems, as a high level programming method to analyze safety and reliability, and to bridge conceptual differences between domains, e.g., to facilitate hardware/software co-design. With the advent of ubiquitous computing, model-based applications, e.g., in control, diagnosis, and maintenance, will become pervasive and ultimately become as proliferated as embedded computing power.
To handle the multitude of formalisms for model design and analysis (e.g., VHDL, Verilog RTL, statecharts, Petri nets, and bond graphs) and to combine and relate these, the emerging field of computer automated multi-paradigm modeling relies on the notion of meta-modeling, i.e., modeling the model. This is a powerful approach that allows the generation (instantiation) of domain and problem specific methods, formalisms, and tools and because of a common meta language, these different instances can be integrated by combination, layering, heterogeneous refinement, and multiple views. This session gives an overview of recent developments in the three orthogonal directions of computer automated multi-paradigm modeling: (i) handling multiple formalisms, (ii) the use of multiple levels of abstraction, and (iii) formalism modeling, or meta-modeling.
Paper 1 [Hans Vangheluwe] presents
Paper 2 [Manuel Remelhe] presents an approach to integrate discrete event models into the Modelica language for modeling physical systems. Modelica is based on a differential equation computational model with some rudimentary finite state machine support. Sophisticated discrete event behavior is therefore encapsulated by user defined functions. The Domain Modeling Environment meta-tool (DOME) is used to instantiate tailored discrete event modeling formalisms with dynamic semantics specified by a mapping onto Modelica functions. It is shown how a statechart editor can be designed using a meta-specification, including visualization features to automatically animate execution behavior performed by a Modelica simulator. The use of meta-modeling principles allow rapid creation of modeling and simulation environments for different formalisms, illustrated by introducing a new formalism with substantial syntactic and semantic extensions. For this formalism, an editor is specified along with two formalism transformations; one to generate the executable Modelica code and the other to translate execution traces into visualization features. The formalism transformations are specified using DOME's Scheme- or Lisp-like textual extension language Alter. The combination of meta-modeling techniques and formalism transformation proves to support domain-specific and user-defined formalisms with graphical editors and with capabilities for simulation, analysis, visualization and code generation.
Paper 3 [Akos Ledeczi, Greg Nordstrom, Gabor Karsai, Peter Volgyesi and Miklos Maroti] discusses the Generic Modeling Environment (GME) under development at Vanderbilt University's Institute of Software Integrated Systems. This is a metaprogrammable graphical modeling environment for constructing domain-specific models of engineering systems. As such, it supports the rapid development of domain-specific modeling environments (more formally, modeling languages). Furthermore, it is easy to interface a domain-specific GME with model analysis tools and provide code synthesis/generation capabilities. The GME metamodeling language, used to formally specify the particular domain-specific modeling language of interest, is based on UML class diagrams and OCL constraints. Recently, the metamodeling environment has been extended for composability, making it possible to take existing disparate meta-models and compose them together to create complex meta-models while leaving the originals intact. This has a three-fold benefit. First, meta-models can be reused. Second, new and more complex modeling languages can be rapidly and efficiently created by combining previously developed meta-models. These ``component" meta-models can, of course, function in their own right as well. Which leads to the third benefit. Any end-user (i.e. domain-specific) models created using modeling languages synthesized from these component meta-models can be read and modified directly using the new modeling language resulting from the composed meta-models. This has the effect of creating an inheritance structure around the modeling language definitions, allowing generalization- and specialization-based design approaches to modeling language design using libraries of reusable ``sublanguages" or component meta-models. This paper describes the formalization and development of this metamodel composition.
Paper 4 [Jan F. Broenink and Gerald H. Hilderink] presents a method that considers the embedded systems implementation process as a stepwise refinement from physical system models and control laws to efficient control computer code. A building-block approach at all the parts, enables an efficient and fast design process and supports plug-and-play as well as integrated simulation. Simulation is also used as verification tool throughout the design process and during physical system modeling and control law design. It applies an object-oriented approach for modeling all three parts of embedded control systems: (i) Compositional programming techniques for the embedded software parts, using CSP-based channels for information exchange between processes using data flow diagrams. (ii) VHDL for the specific I/O hardware parts, which remain configurable when using FPGA's. (iii) Bond graphs (directed graphs describing both the dynamic structure and dynamic behavior of the device) for the device to be controlled. The use of channels hides threads and priority indexing from the user, thus alleviating the distributed programming problem significantly. Moreover, scheduling is no longer connected to the operating system but has become part of the application instead. Furthermore, CSP allows reasoning about correctness.
Paper
5 [Robert Höpler and Pieter J. Mosterman] presents a model
integrated approach to embedded code synthesis for manufacturing robot control.
Manufacturing robots present a class of embedded systems with hard real-time
constraints. On the one hand controller software has to satisfy tight
timing constraints and rigorous memory requirements. Especially non-linear
dynamics and kinematics models are vital to modern model-based controllers and
trajectory planning algorithms. Often this is still realized by manually coding
and optimizing the software, a labor intensive and error-prone repetitive
process. On the other hand shorter design-cycles and a growing number of
customer-specific robots demand more flexibility in modeling. This paper
presents a model-integrated computing approach to automated code synthesis
of dynamics models that satisfies the harsh demands by including domain and
problem specific constraints prescribed by the robotics application. It is shown
that the use of such tailored formalisms leads to very efficient embedded
software, competitive with the hand optimized alternative. At the same time it
combines flexiblity in model specification and usage with the potential for
dynamic adaptation and reconfiguration of the model.