Search

Reading and writing is modelled in CSP using actions containing the symbols ? and !. These reading actions and writing actions are synchronous, and there is a one-to-one relationship between occurrences of pairs of these actions. In the CPA conference 2017, we introduced the extended half-synchronous alphabetised parallel operator X ⇕ Y , which disconnects the writing to and reading from a channel in time; the reading processes are divided into sets which are set-wise asynchronous, but intra-set-wise synchronous, giving full flexibility to the reads. In this paper, we allow multiple writers to write to the same channel set-wise asynchronously, but intra-set-wise synchronously and we study the impact on our (Extended) Vertex Removing Synchronised Product. The advantages we accomplish are that the extension of X ⇕ Y gives more flexibility by indexing the writing actions and the reading actions, leading to a straightforward majority vote design. Furthermore, the extension of X ⇕ Y preserves the advantages of the X ⇕ Y operator.

This publication is about simulating cyber-physical models with varying levels of detail, how to structure the models to make this possible and how to design the submodels required. A structured method is posed to select which signals of the model to use for the structure and how to determine the different parts of the models to abstract away when varying the detail of sub-models. This method is applied to two examples based on a lab setup available. One example shows hard limits due to encoder processing, the other example shows the effects of simplified dynamic models. The method is effective in both examples and shows a clear trade-off between accuracy and performance.

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.

In certain single-core mono-processor configurations, e.g. embedded control systems, like robotic applications, 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. Reducing the number of context switches decreases the execution time and thereby increases 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. These processes can be represented by finite directed acyclic labelled multi-graphs. The vertex-removing synchronised product of such graphs gives graphs that represent processes which have less context switches. To reduce the memory occupancy, the vertex-removing synchronised product removes vertices that are not reachable; i.e. represents states that can never occur. By means of a lattice, we show all possible products of a set of graphs, where the number of products is given by the Bell number. We finish with heuristics from which a set of graphs can be calculated that represents a set of processes that will not miss their deadline and which fits in the available memory.

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.

The aims of this workshop are to develop a range of interesting practical demonstrators showing the benefits and advantages to systems engineering of Com- municating Process Architectures (CPA). Examples range from essential, basic cases towards the challenging ones. Also, benchmark cases – or cases that are used so often that they grow towards a benchmark, like the commstime example – will be developed.

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.

Timed CSP can be used to model and analyse real-time and concurrent behaviour of embedded control systems. Practical CSP implementations combine the CSP model of a real-time control system with prioritized scheduling to achieve efficient and orderly use of limited resources. Schedulability analysis of a timed CSP model of a system with respect to a scheduling scheme and a particular execution platform is important to ensure that the system design satisfies its timing requirements. In this paper, we propose a framework to analyse schedulability of CSP-based designs for non-preemptive fixed-priority multiprocessor scheduling. The framework is based on the PAT model checker and the analysis is done with dense-time model checking on timed CSP models. We also provide a schedulability analysis workflow to construct and analyse, using the proposed framework, a timed CSP model with scheduling from an initial untimed CSP model without scheduling. We demonstrate our schedulability analysis workflow on a case study of control software design for a mobile robot. The proposed approach provides non-pessimistic schedulability results.

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.

This text book introduces systems engineering for designing systems in multidisciplinary projects. First an overview of the systems engineering process is given. Several systems thinking tracks are presented, to think about the system in a number of ways, its context, its user, its functionality, its past and its future. This to stimulate creativity of the system designer, and to force out-of-the-box thinking. Dynamic thinking, feedback thinking, specific-generic thinking project thinking, life-cylce thinking to name a few. A number of practical design tools are presented that support both the systems engineering process and the systems thinking tracks: 9-windows diagram, context diagram, system budgets, fun-key architecting, A3 architecture overview, risk management, modeling and simulation, documenting and reviewing. The message is exemplified using a case study throughout the text.

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 is about using templates and passing model-specific information between tools via parameterized 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. This is illustrated by the realization of the embedded software of a real system. We conclude that reuse is easier. However, the presented method can be generalized more, as to connect to other tools and platforms.

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).

Most motion control systems for mechatronic systems are implemented on digital computers. In this paper we present an FPGA based solution implemented on a low cost Xilinx Spartan III FPGA. A Production Cell setup with multiple parallel operating units is chosen as a test case. The embedded control software for this system is designed in gCSP using a reusable layered CSP based software structure. gCSP is extended with automatic Handel-C code generation for configuring the FPGA. Many motion control systems use floating point calculations for the loop controllers. Low cost general purpose FPGAs do not implement hardware-based floating point units. The loop controllers for this system are converted from floating point to integer based calculations using a stepwise refinement approach. The result is a complete FPGA based motion control system with better performance figures than previous CPU based implementations.

To improve feedback on how concurrent CSP-based programs run, the graphical CSP design tool has been extended with animation facilities. The state of processes, constructs, and channel ends are indicated with colours both in the gCSP diagrams and in the composition tree (hierarchical tree showing the structure of the total program). Furthermore, the contents of the channels are also shown. In the Fringe session, we will present and demonstrate this prototype animation facility, being the result of the MSc project of Hans van der Steen, and ask for feedback.

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 software design is one of the most challenging tasks during the design of a mechatronic system. On one hand, it has to provide solutions to deal with concurrency and timeliness issues of the system. On the other hand, it has to glue different disciplines (such as software, control and mechanical) of the system as a whole. In this paper, we propose a model-driven approach to design the software part of a mechatronic system, which consists of two major parts: systematic modeling and correctness-preserving synthesis. The modeling stage is divided into four steps, which focus on different aspects (such as concurrency, multiple disciplines and timeliness) of the system respectively. In particular, we propose a set of handshake patterns to capture the concurrent aspect of the system. These patterns assist designers to build up an adequate top-level model efficiently. Furthermore, they separate the system into a set of concurrent components, each of which can be further refined independently. Subsequently, the multidisciplinary and realtime aspects of the system are naturally specified and analyzed in a series of refinements. After the important aspects of the system are specified and analyzed in a unified model, a software implementation is automatically synthesized from the model, the correctness of which is ensured by construction. The effectiveness of the proposed approach is illustrated by a complex production cell system.

This paper deals with the applicability of CSP in general and SystemCSP, as a notation and design methodology based on CSP, in particular in the application area of real-time systems. The paper extends SystemCSP by introducing time-related operators as a way to specify time properties. Since SystemCSP aims to be used in practice of real-time systems development, achieving real-time in practice is also addressed. The mismatch between the classical scheduling theories and CSP paradigm is explored. Some practical ways to deal with this mismatch are presented.

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.

SystemCSP is a graphical modeling language based on both CSP and concepts of component-based software development. The component framework of SystemCSP enables specification of both interaction scenarios and relative execution ordering among components. Specification and implementation of interaction among participating components is formalized via the notion of interaction contract. The used approach enables incremental design of execution diagrams by adding restrictions in different interaction diagrams throughout the process of system design. In this way all different diagrams are related into a single formally verifiable system. The concept of reusable formally verifiable interaction contracts is illustrated by designing set of design patterns for typical fault tolerance interaction scenarios.

This paper introduces SystemCSP – a design methodology based on a visual notation that can be mapped onto CSP expressions. SystemCSP is a graphical design specification language aimed to serve as a basis for the specification of formally verifiable component-based designs of distributed real-time systems. It aims to be a graphical formalism that covers various aspects needed for the design of distributed real-time systems in single framework. Keywords. CSP, Formal methods, Graphical modeling

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 discusses issues, possibilities and existing approaches for fitting an exception handling mechanism (EHM) in CSP-based process-oriented software architectures. After giving a survey on properties desired for a concurrent EHM, specific problems and a few principal ideas for including exception handling facilities in CSP-designs are discussed. As one of the CSP-based frameworks for concurrent software, we extend CT (Communicating Threads) library with the exception handling facilities. The extensions result in two different EHM models whose compliance with the most important demands of concurrent EHMs (handling simultaneous exceptions, the mechanism formalization and efficient implementation) are observed.

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.

The aim of this project is to get insight how Real-time Ethernet behaves with respect to the field bus called Locbus. By writing a benchmarks for both systems the characterisations of both buses is performed. The transmission is time, the time which necessary to get the data to and of the card. Variability of measured data or so-called jitter is also determined. From the research it becomes clear that Ethernet is faster than Locbus. Locbus however is assumed more stable because the protocol is generated in the hardware. The test for this statement could not be performed because interrupts are not supported by the Locbus hardware. For large quantities of data Real-time Ethernet is recommended using, because then the speed will play a larger role. To get a better insight if it is realisable for a field bus to be replaced by Real-time Ethernet it is advised to build a test set-up which uses Real-time Ethernet.

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.

Closed loop control systems typically contain multitude of spatially distributed sensors and actuators operated simultaneously. So those systems are parallel and distributed in their essence. But mapping this parallelism onto the given distributed hardware architecture, brings in some additional requirements: safe multithreading, optimal process allocation, real-time scheduling of bus and network resources. Nowadays, fault tolerance methods and fast even online reconfiguration are becoming increasingly important. All those often conflicting requirements, make design and implementation of real-time distributed control systems an extremely difficult task, that requires substantial knowledge in several areas of control and computer science. Although many design methods have been proposed so far, none of them had succeeded to cover all important aspects of the problem at hand. [1] Continuous increase of production in embedded market, makes a simple and natural design methodology for real-time systems needed more then ever.

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.