Search

Reading and writing is modelled in CSP using actions containing the symbols ? and !. These reading and writing actions are synchronous and there is a oneto-one relationship between occurrences of pairs of these actions. It is cumbersome to ease the restriction of synchronous execution of the read and write actions. For this reason we introduce the half-asynchronous parallel operator that acts on actions containing the symbols ¿ and ¡ and study the impact on a Vertex Removing Synchronised Product.

Modern embedded systems are designed for multiple and increasingly demanding tasks. Complex concurrent software is required by multi-task automated service robotics for implementing their challenging (control) algorithms. TERRA is a communicating Sequential Processes (CSP) algebra-based Eclipse graphical modelling tool suite which is capable of C++ code generation. It is designed to ease tedious and error-prone concurrent software development for robotics. However, sufficient simulation and visualization supports are not provided yet in TERRA. A hybrid simulation approach is proposed in this paper to provide simulation capabilities for the TERRA tool suite with respect to the Cyber-Physical Systems (CPS) co-design. Moreover, a visualization for the simulation is designed as well to provide animation facilities which enable users to visually trace simulated execution flows. Finally, we use an example to test the hybrid simulation approach as well as visualization facilities. The simulation approach is shown to be sufficient and the visualization works as intended.

The last decades have seen the emergence of truly complex, designed systems, known as Cyber-Physical Systems (CPS). Engineering such systems requires integrating physical, software, and network aspects. To date, neither a unifying theory nor systematic design methods, techniques and tools exist to meet this challenge. Individual engineering disciplines, such as mechanical, electrical, network and software engineering offer only partial solutions. Multi-Paradigm Modelling (MPM) proposes to model every part and aspect of a system, including development processes, explicitly, at the most appropriate level(s) of abstraction, using the most appropriate modelling formalism(s). Modelling language engineering, including model transformation, and the study of their semantics, are used to realize MPM. MPM is seen as an effective answer to the challenges of designing Cyber-Physical Systems. Research on modelling CPS is typically based on national activities with loose international interaction. To establish an interdisciplinary and inter-institutional platform for scientific information exchange, consensus building, and collaboration, the COST Action MPM4CPS, funded by the EU Framework Programme for Research and Innovation, has been initiated. MPM4CPS aims to develop and share foundations, techniques, and tools related to Multi-Paradigm Modelling for Cyber-Physical Systems (MPM4CPS) and to provide educational resources. In this paper we describe the overall MPM4CPS approach and its current status.

Model-Driven Development (MDD) – based on the concepts of model, meta-model and model transformation – is an approach to develop predictable and re- liable software for Cyber-Physical Systems (CPS). The work presented here concerns a methodology to design simulation software based on MDD techniques, supporting the TERRA tool suite to describe and simulate process communication flows. TERRA is implemented using MDD techniques and Communicating Sequential Process algebra (CSP). Simulation support for TERRA helps the designer to understand the semantics of the designed model and, hence, to increase the probability of first-time-right software implementation. A new simulation meta-model is proposed, abstracting the simulation process of a TERRA model. With this new meta-model and our previously designed CSP meta-model, a simulation model can be transformed from its TERRA source. The Eclipse Modelling Framework (EMF) is used to implement the meta-model. The Eclipse Epsilon Framework includes the Epsilon Transformation Language (ETL) and the Epsilon Generation Language (EGL), used for model-to-model and model-to-text transformation. The simulation support is shown using an example, in which the generated trace text is shown as well. Further work is to implement an animation facility showing the trace text in the TERRA graphical model using colours.

Robots are versatile machines that are increasingly being used not only to per- form dirty, dangerous, and dull tasks in manufacturing industries, but also to achieve societal objectives, such as enhancing safety in transportation, reducing the use of pesticide in agriculture, helping people with health conditions, provid- ing companionship, and improving efficacy in the fight against crime and civilian protection. The 2014 event of SIMPAR was held at the “Giovanni XXIII‿ Conference Center in Bergamo, Italy during October 20–23. It followed the previous works of the first SIMPAR 2008 in Venice, Italy, the second SIMPAR 2010 in Darmstadt, Germany, and the third SIMPAR 2012 in Tsukuba, Japan and provided a forum for concentrated discussions on the topics of interest.

Software that is used to control machines and robots must be predictable and reliable. Model-Driven Design (MDD) techniques are used to comply with both the technical and business needs. This paper introduces a CSP meta-model that is suitable for these MDD techniques. The meta-model describes the structure of CSP models that are designed; using this meta-model it is possible to use all regular CSP constructs when constructing a CSP model. The paper also presents a new tool suite, called TERRA, based on Eclipse and its frameworks. TERRA contains a graphical CSP model editor (using the new CSP meta-model), model validation tools and code generation tools. The model validation tools check whether the model conforms to the meta-model definition as well as to additional rules. Models without any validation problems result in proper code generation, otherwise the developer needs to address the found problems to be sure code generation will succeed. The code generation tools are able to generate CSPm code that is readable by FDR and to generate C++/LUNA code that is executable on embedded targets. The meta-model and the TERRA tool suite are tested by designing CSP models for several of our laboratory setups. The generated C++/LUNA code for the laboratory setups is able to control them as expected. Additionally, the paper contains an example model containing all supported CSP constructs to show the CSPm code generation results. So it can be concluded that the meta-model and TERRA are usable for these kind of tasks.

This chapter presents motivation for taking a collaborative multi-disciplinary approach to the model-based development of embedded systems. Starting from a consideration of the ubiquity of embedded systems in daily life it identifies challenges faced by industry in developing products in a timely manner, but to sufficient quality to merit the reliance of their users. Using a fictional story of product development, it presents the perspectives of both the control engineer and the software designer. We describe an approach—realised using the Crescendo tool—that promotes collaborative modelling and co-simulation, taking account of existing technology and current industry practice

In this article, we present the process of modeling control algorithms as means to increase reliability of software components. The approach to developing Embedded Control Software (ECS) is tailored to Component-Based Software Development (CBSD). Such tailoring allows to re-use the ECS development process tools in a development process for robotics software. Model-to-text transformation of the ECS design tool is extended to model-to-component transformation suitable for CBSD frameworks. The development process and tools are demonstrated by a use case.

In this paper the performance gain obtained by combining parallel periodic real-time processes is elaborated. In certain single-core mono-processor configurations, for example embedded control systems in robotics comprising many short processes, process context switches may consume a considerable amount of the available processing power. For this reason it can be advantageous to combine processes, to reduce the number of context switches and thereby increase the performance of the application. As we consider robotic applications only, often consisting of processes with identical periods, release times and deadlines, we restrict these configurations to periodic real-time processes executing on a single-core mono-processor. By graph theoretical concepts and means, we provide necessary and sufficient conditions so that the number of context switches can be reduced by combining synchronising processes.

Cyber-physical systems are multidisciplinary systems which involve different engineering disciplines in their design. Each engineering discipline tends to use its own domain-speci﬿c languages and tools to model different aspects of a system concurrently. The concurrent modelling process may introduce inconsistencies due to lack of common knowledge and communication among domain experts. Especially for co-modelling and co-simulation developments, a huge amount of models, versions of models and design alternatives may be produced, which highly increases the design space and the chance of having inconsistent models. This paper introduces a model management support and concurrent design flow to prevent inconsistencies and maintain synchronization among models. Besides the consistency checking scheme, a co-evolution graph can be generated by the model management system to visualize the concurrent development process and prevent inconsistencies. The model management system and concurrent design flow have been applied on a line following robot to show how to use this approach and its advantages.

This paper introduces the modelling methodology and tooling in DESTECS (www.destecs.org) - Design Support and Tooling for Embedded Control Software - project as a novel modelling approach for hybrid systems from an executable model perspective. It provides a top-level structure for the system model which is a good guidance for designers to construct the initial system model. Furthermore, the details about the co-simulation synchronization scheme between two domain-specific tools are discussed. At last, an example is given to illustrate the benefits of using DESTECS modelling methodology introduced in this paper.

The work presented here is on a methodology for design of hard real-time embedded control software for robots, i.e. mechatronic products. The behavior of the total robot system (machine, control, software and I/O) is relevant, because the dynamics of the machine influences the robot software. Therefore, we use two appropriate Models of Computation, which represent continuous-time equations for the machine / robot part, and discrete event / discrete time equations for the control software part. To compute (simulate) such combined models, co-simulation of these models is used. The design work can be done as a stepwise refinement process, whereby each step is verified via co-simulation. This in general yields a shorter design time, and a better quality product. The tools pass model-specific information between each other via parametrized tokens in the generated, high-level code to get a better separation of design steps. This allows for better quality of the models and more reuse, thus enhancing the efficiency of model-driven design for the (industrial) end user. The method is illustrated with a case study using the tools, some of which are at the prototype level. Especially the structuring of the models and regularly doing simulations (of which some can be ’repeated’ as real experiments), is beneficial, shortening the development time and producing better models. Future work is to test the method on more complex cases, and to extend the method by detailing out the electronics and mechanics sub design flows.

Modern embedded systems have multiple cores available. The CTC++ library is not able to make use of these cores, so a new framework is required to control the robotic setups in our lab. This paper first looks into the available frameworks and compares them to the requirements for controlling the setups. It concludes that none of the available frameworks meet the requirements, so a new framework is developed, called LUNA. The LUNA architecture is component based, resulting in a modular structure. The core components take care of the platform related issues. For each supported platform, these components have a different implementation, effectively providing a platform abstraction layer. High-level components take care of platform-independent tasks, using the core components. Execution engine components implement the algorithms taking care of the execution flow, like a CSP implementation. The paper describes some interesting architectural challenges encountered during the LUNA development and their solutions. It concludes with a comparison between LUNA, C++CSP2 and CTC++. LUNA is shown to be more efficient than CTC++ and C++CSP2 with respect to switching between threads. Also, running a benchmark using CSP constructs, shows that LUNA is more efficient compared to the other two. Furthermore, LUNA is also capable of controlling actual robotic setups with good timing properties.

Embedded targets normally do not have much resources to aid developing and debugging the software. So model-driven development (MDD) is used for designing embedded software with a `first time right' approach. For such an approach, a good way of working (WoW) is required for embedded software development using MDD techniques. This paper discusses the preferred way of working for the development of embedded control software. Control software requires hard real-time support for the loop controllers. These controllers directly control the motor output. Soft and non real-time levels can be used for non loop control related software tasks. The paper also discusses model structure optimisation techniques, which prevent the complexity of resource scheduling for large robotic setups, These techniques allow the designer to keep his own preferred point of view, as the techniques try to optimise the model into efficient software from a execution point of view. This saves a huge amount of design effort, especially for distributed targets.

Simulating formal models is a common means for validating the correctness of the system design and reduce the time-to-market. In most of the embedded control system design, multiple engineering disciplines and various domain-specific models are often involved, such as mechanical, control, software and hardware models. Close collaboration and well integration between all domain-specific models become more and more important for developing dependable and cost-efficient systems. Moreover, each disciplinary model can be de- veloped and evolved following its own semantics and development tools in different rates. The inconsistency between models and the evolution of the collection of models will increase the complexity of design as well as the difficulty of maintaining several models under simultaneous development and changes. Therefore, this paper introduces a model management approach for multi-disciplinary systems and co- simulation. Such model management approach can ensure the model integration and consistency, keep track of model evolution, and support decision making. The concepts of the DESTECS co-simulation framework (?) and the corresponding model evolution process are also explained.

In this paper we show that using co-simulation for robot software design will be more efficient than without co-simulation. We will show an example of the plotter how the co-simulation is helping with the design process. We believe that a collaborative methodology based on model-driven design will improve the chances of closing the design loop early, improving cross-discipline design dialog, and reduce errors, saving cost and time.

The TUlip robot was created to participate in the teensize league of Robocup. The TUlip robot is a bipedal robot intended for dynamic walking. It has six degrees of freedom for each leg: three for the hip, one for the knee and two for the ankle. This paper elaborates on the algorithm for the sideways control during gait. The algorithm uses the extrapolated center of mass (XcoM) to achieve limit cycle stability. The algorithm is tested in simulation using a linear inverted pendulum and, then, experimentally applied to the TUlip robot. The result is an adaptive behavior of the TUlip robot, promising for future application to legged robot stability.

This paper describes and compares five CSP based and two CSP related process-oriented motion control system implementations that are made for our Production Cell demonstration setup. Five implementations are software-based and two are FPGA hardware-based. All implementations were originally made with different purposes and investigating different areas of the design space for embedded control software resulting in an interesting comparison between approaches, tools and software and hardware implementations. Common for all implementations is the usage of a model-driven design method, a communicating process structure, the combination of discrete event and continuous time and that real-time behaviour is essential. This paper shows that many small decisions made during the design of all these embedded control software implementations influence our route through the design space for the same setup, resulting in seven different solutions with different key properties. None of the implementations is perfect, but they give us valuable information for future improvements of our design methods and tools.

Embedded software design for mechatronic systems is becoming an increasingly time-consuming and error-prone task. In order to cope with the heterogeneity and complexity, a systematic model-driven design approach is needed, where several parts of the system can be designed concurrently. There is however a trade-off between concurrency efficiency and integration efficiency. In this paper, we present a case study on the development of the embedded control software for a real-world mechatronic system in order to evaluate how we can integrate concurrent and largely independent designed embedded system software parts in an efficient way. The case study was executed using our embedded control system design methodology which employs a concurrent systematic model-based design approach that ensures a concurrent design process, while it still allows a fast integration phase by using automatic code synthesis. The result was a predictable concurrently designed embedded software realization with a short integration time.

This paper presents two algorithms for analysing gCSP models in order to improve their execution performance. Designers tend to create many small separate processes for each task, which results in many (resource intensive) context switches. The research challenge is to convert the model created from a design point of view to models which have better performance during execution, without limiting the designers in their ways of working. The first algorithm analyses the model during run-time execution in order to find static sequential execution traces that allow for optimisation. The second algorithm analyses the gCSP model for multi-core execution. It tries to find a resource-efficient placement on the available cores for the given target systems. Both algorithms are implemented in two tools and are tested. We conclude that both algorithms complement each other and the analysis results are suitable to create optimised models.

We prove the correctness of a two-way sliding window protocol with piggybacking, where the acknowledgments of the latest received data are attached to the next data transmitted back into the channel. The window size of both parties are considered to be finite, though they can be of different sizes. We show that this protocol is equivalent (branching bisimilar) to a pair of FIFO queues of finite capacities. The protocol is first modeled and manually proved for its correctness in the process algebraic language of muCRL. We use the theorem prover PVS to formalize and to mechanically prove the correctness. This implies both safety and liveness (under the assumption of fairness).

Development of computerized embedded control systems is difficult because it brings together systems theory, electrical engineering and computer science. The engineering and analysis approaches advocated by these disciplines are fundamentally different which complicates reasoning about e.g. performance at the system level. We propose a light-weight approach that alleviates this problem to some extent. An existing formal semantic framework for discrete event models is extended to allow for consistent co-simulation of continuous time models from within this framework. It enables integrated models that can be checked by simulation in addition to the verification and validation techniques already offered by each discipline individually. The level of confidence in the design can now be raised in the very early stages of the system design life-cycle instead of postponing system-level design issues until the integration and test phase is reached. We demonstrate the extended semantic framework by co-simulation of VDM++ and bond-graph models on a case study, the level control of a water tank.

The work presented here is on setting up methodological support, including (prototype) tools, for the design of distributed hard real-time embedded control software for mechatronic products. The use of parallel hardware (CPUs, FPGAs) and parallel software is investigated, to exploit the inherent parallel nature of embedded systems and their control. Two core models of computation are used to describe the behavior of the total mechatronic system (plant, control, software and I/O): discrete event system (DES) and continuous time system (CTS). Thesemodels of computation are coupled via co-simulation, to be able to do consistency checking at the boundaries. This allows for integration of discipline-specific parts on the model level (during design phases) instead of on the code level (during realization and test phases). Crossview design-change influences get specific attention, to allow for relaxation of the tension between several dependability issues (like reliability and robustness), while keeping design time (and thus design costs) under control. Furthermore, the design work can be done as a stepwise refinement process. This yields a shorter design time, and a better quality product. The method is illustrated with a case using the tools being prototyped.

The design of embedded control systems for monitoring and control of mechatronic systems has a multidisciplinary development trajectory. These systems consist of heterogeneous components developed by different disciplines (control engineering, electrical engineering, software engineering and often many more). The design trajectory needs therefore a multi-disciplinary design methodology that enables concurrent design and interactions between all involved disciplines, reducing inconsistencies and conflicts that occur during the design phase. This paper proposes a multi-view methodology to address the above-mentioned issues. The main purpose is to shorten the design time and at the same time increasing the reliability and predictability of embedded (computer) control systems.

gCSP is a graphical tool for creating and editing CSP diagrams. gCSP is used in our labs to generate the embedded software framework for our control systems. As a further extension to our gCSP tool, an occam code generator has been constructed. Generating occam from CSP diagrams gives opportunities to use the Raw-Metal occam eXperiment (RMoX) as a minimal operating system on the embedded control PCs in our mechatronics laboratory. In addition, all processors supported by KRoC can be reached from our graphical CSP tool. The commstime benchmark is used to show the trajectory for gCSP code generation for the RMoX operating system. The result is a simple means for using RMoX in our laboratory for our control systems. We want to use RMoX for future research on distributed control and for performance comparisons between a minimal operating system and our CTC++/RT-linux systems.

In this paper a data sharing framework for multi-threaded, distributed control programs is described that is realized in C++ by means of only a few, powerful classes and templates. Fast data exchange of entire data structures is supported using sockets as communication medium. Access methods are provided that preserve data consistency and synchronize the data exchange. The framework has been successfully used to build a distributed robot soccer control system running on as many computers as needed.

This paper presents in a nutshell a procedure for producing formally verified concurrent software. The design paradigm provides means for translating block-diagrammed models of systems from various problem domains in a graphical notation for process-oriented architectures. Briefly presented CASE tool allows code generation both for formal analysis of the models of software and code generation in a target implementation language. For formal analysis a high- quality commercial formal checker is used.

The occam programming language, based on the CSP formal algebra and tied to a specific hardware platform (transputers), offered a structured way to organize concurrency. The CT library [1], developed at University of Twente, inspired by occam is a kernel library implementing occam primitives in modern programming languages and for general purpose microprocessors. In this paper, a practical implementation of the CT library is explained and some aspects are compared to similar occam-like library developed at the University of Kent. The design of the CT-library internals is then revisited and proposed changes are implemented in the C++ version of the library.

For broad acceptance of an engineering paradigm, a graphical notation and a supporting design tool seem necessary. This paper discusses certain issues of developing a design environment for building systems based on CSP. Some of the issues discussed depend specifically on the underlying theory of CSP, while a number of them are common for any graphical notation and supporting tools, such as provisions for complexity management and design overview.

This paper describes a method using Hardware-in-the-Loop Simulation as a means for multidisciplinary design support. The method presented here, aims at supporting the design of heterogeneous embedded control systems. The method considers the implementation process as a stepwise refinement from physical system models and control laws to efficient control computer code, and that all phases are verified by simulation. Since many systems are distributed in nature we use a link driver library based on the CSP channel concept to support this. Communication peculiarities are encapsulated by these link drivers. Experiments with a basic mechatronic set up show that the HIL Simulated system behaves as the real system and can be successfully incorporated.

We use several formal methodologies for developing control applications at our Control Engineering research group. An important methodology we use for designing and implementing control software architecture is based on CSP concepts. These concepts allow us to glue multidisciplinary activities together and allow for formal stepwise refinement from design down to its implementation. This paper illustrates a trajectory and shows the usefulness of CSP diagrams for a simple mechatronic system. The simulation tool 20-SIM is used for creating the control laws and our CTC++ package is used for coding in C++.

Sampling and timing is considered a responsibility of the environment of controller software. In this paper we will illustrate a concept whereby an environmental process and multi-way events play an important role in applying timing for untimed CSP software architectures. We use this timing concept for building our control applications based on CSP concepts and with our CSP for C++ (CTC++) library. We present a concept of sampling of control applications that is orthogonal to the application. This implies global timing on the basis of timed events. We also support traditional local timing on the based of timed processes.

This paper provides a description of an approach based on our 20-sim modelling and simulation PC software package in combination with various hardware targets with an Analog Devices Inc. DSP board as an instance. The main virtue of this approach is support for a number of (virtually any decent) hardware platforms for, in this case, a price less than a few percent compared to existing market solutions.

This research project is motivated by the fact that nowadays it is impossible to separate control engineering from software engineering. Besides that both of them can be found in definitions of mechatronics, this project deals with exploitation and improvement of their strong natural interdependency. In all modern reactive systems, what all mechatronics systems are, one will always find one or more embedded computers. The functionality of these computers, and in turn controlled systems, is powered by embedded software [1].

Closed loop control systems are in essence parallel and distributed. But when implementing this parallelism in software, lot of obstacles concerning multithreading communication and synchronization issues arise. Using multithreading in safe and structured way is possible if the program is built such that it can be checked using some formal mathematical algebra (e.g. CSP). Fortunately, several formal checking tools and libraries implementing CSP based constructs are available for most widely used general purpose programming languages. One of those libraries is the CT library [1, 2], developed at University of Twente.

This paper reports a design trajectory for rapid prototyping embedded software that is motivated by an obvious fact that nowadays it is impossible to separate control engineering from the software production. Besides these two are found in definitions of mechatronics, this approach deals with refinement and a thorough exploitation of their strong natural interdependency. It is another truism that in an engineering cycle of a mechatronic or, more general, automatically controlled product, a time span from a concept to the first prototype is too large. An idea of an immediate real-world validation of a modelled and simulated control system is inarguably attractive. The paper provides a detailed description of the framework that makes migration from a modelled and simulated controller design to an implementation on a chosen processing unit a few mouse clicks far-off. Moreover, a debugging facility by off-line monitoring the execution of the automatically generated code is documented. Described trajectory is based on our 20-sim modelling and simulation PC software package in combination with various hardware targets, with an Analog Devices Inc. DSP board as an instance

Closed loop control system typically contains multitude of sensors and actuators operated simultaneously. So they are parallel and distributed in its essence. But when mapping this parallelism to software, lot of obstacles concerning multithreading communication and synchronization issues arise. To overcome this problem, the CT kernel/library based on CSP algebra has been developed. This project (TES.5410) is about developing communication extension to the CT library to make it applicable in distributed systems. Since the library is tailored for control systems, properties and requirements of control systems are taken into special consideration. Applicability of existing middleware solutions is examined. A comparison of applicable fieldbus protocols is done in order to determine most suitable ones and CAN fieldbus is chosen to be first fieldbus used. Brief overview of CSP and existing CSP based libraries is given. Middleware architecture is proposed along with few novel ideas.

This JIWY demonstrator is constructed in the context of the development of a design framework and software tools to efficiently support mechatronic engineers in developing sophisticated control computer code out of a set control laws. We use the CSP-based Communicating Threads -CT- library as the software communication layer, our hard real-time "virtual machine". JIWY (just a soundful name) is a little tabletop robot with 2 rotational degrees of freedom and a camera as its "end effector", controlled via a joystick on a PC running Real-Time Linux. The control laws are stepwise refined to obtain the control software, enhancing the control-law block diagrams to CSP-diagrams, showing the communication and composition properties of the control software. Enhancements like adding homing and end stops for safety can easily be added in the CSP-diagrams, without adapting the control law design. This shows the orthogonality of the design steps. State charts were not needed to express all functionality, which leaves the design simple. The prize of this elegance, namely performance, has as yet not been investigated.

In the context of a trajectory for analysis and design of embedded control systems (ECS), the main focus is put on an approach to concurrent programming in the light of process orientation, in a way which is transparent for the designer - typically a system engineer with a background in control engineering. Due to the nature of real-time applications of ECS's, developers resort to concurrent implementations by the means of multithreaded programming, which leads to unavoidable complexity. The approach presented here relies on a paradigm of compositional programming - in essence, an object-oriented philosophy based on properties of encapsulated, reusable building-blocks applicable not only for software engineering, but as well as for modeling controlled plant and hardware design, actually supporting hardware-software co-design. The building-blocks approach is believed to be capable to manage complexity inherent to ECS's.

The development of control software for mechatronic systems is presented by means of a case study: a 2 DOF mechanical rotational set-up usable as a camera-positioning device. The control software is generated using the code generation facility of 20-SIM, thus guaranteeing the generated code being the same as verified by simulation during the controller design phase. We use CTC++ (Communicating Threads for C++) as Communication Abstraction Layer to facilitate the conversion process from the block diagram describing the controller towards the control computer code. Furthermore, CTC++ enables the use of distributed and different processors as target computer, since distributivity and heterogeneity are explicitly accounted for in the CTC++ library. CTC++ provides the tools to make the application realtime. Real-time Linux provides us the real-time operating system resources that are needed to create a real-time environment for the real-time application.

The method presented aims at supporting the development of control software for embedded control systems. The method considers the implementation process as a stepwise refinement from physical system models and control laws to efficient control computer code, and that all phases are verified by simulation. Simulation is also used as a verification tool during physical system modeling and control law development. Data flow diagrams are used to describe the control software throughout the whole implementation process. Since we aim at heterogeneous distributed processors as target hardware, we use a link driver library based on the CSP channel concept. Communication peculiarities are encapsulated by the link drivers

The research of our team deals with the realization of control schemes on digital computers. As such the emphasis is on embedded control software implementation. Applications are in the field of mechatronic devices, using a mechatronic design approach (the integrated and optimal design of a mechanical system and its embedded control system). The ultimate goal is to support the application developer (i.e. mechatronic design engineer) such that implementing control software according to ðo it the first time right¿ becomes business as usual.