Building Blocks for Control System Software

1999

Abstract Software components for embedded reactive real-time applications must satisfy tight code size and run-time constraints. Cooperating finite state machines provide convenient intermediate format for embedded system co-synthesis, between high-level specification languages and software or hardware implementations. We propose a software generation methodology that takes advantage of a restricted class of specifications and allows for tight control over the implementation cost.

2007

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

Emerging Technologies and …, 2005

2006 IEEE Conference on Computer-Aided Control Systems Design, 2006

Complex control software problems can be solved by using structured design methods that take advantage of hardware abstraction and concurrency. In our lab, a toolchain has been developed that facilitates such a design method. This paper presents two extensions to this toolchain. The first, a distributed simulation framework, enables one to simulate a complete distributed control system, prior to the actual implementation. Focus has been on the influence the network communication exerts on the overall behavior of the system. The second extension, a new communication framework, allows for a smooth transition from simulation to a real control system, by hiding all low-level communication details from the control software. This separates the concerns of the control software from distribution and inter-node communication issues, creating freedom in process allocation.

Innovations in Systems and Software Engineering, 2011

The widespread use of embedded systems requires the creation of industrial software technology that will make it possible to engineer systems being correct by construction. That can be achieved through the use of validated (trusted) components, verification of design models, and automatic configuration of applications from validated design models and trusted components. This design philosophy has been instrumental for developing COMDES-a component-based framework for distributed embedded control systems. A COMDES application is conceived as a network of embedded actors that are configured from instances of reusable, executable components-function blocks (FBs). System actors operate in accordance with a timed multitasking model of computation, whereby I/O signals are exchanged with the controlled plant at precisely specified time instants, resulting in the elimination of I/O jitter. The paper presents an analysis technique that can be used to validate COMDES design models in SIMULINK. It is based on a transformation of the COMDES design model

Communications of The ACM, 1996

Developing large control architectures is complex. It usually requires a decomposition in subsystems or control modules, which have to communicate in complex patterns in order to achieve a common objective. Furthermore, control modules operate concurrently, and are usually installed on a distributed computer platform. Analysis of the relationships between elements is of the utmost importance in the design of the architecture.

Because a real-time system combines control and data processing designers specify it using different languages. Such systems are often distributed and the problem is to obtain a distributed implementation from these distinct specifications. Indeed, the method based on separated code generation and manual distribution leads to inconsistent implementations. We propose to unify all these specifications into a unique one. The resulting specification is a conditioned data flow graph which exhibits the potential parallelism necessary to an efficient use of distributed resources. Finally, we use the SynDEx software in order to automatically produce a distributed and consistent implementation from the resulting specification

EFTA 2003. 2003 IEEE Conference on Emerging Technologies and Factory Automation. Proceedings (Cat. No.03TH8696)

− − − − This paper presents the Java version of the AOCS Framework. The AOCS Framework is an object-oriented software framework for real-time satellite control systems. It provides a set of design patterns, an adaptable architecture, and a set of configurable components that support the instantiation of satellite control applications. It was originally implemented in C++ but has now been ported to Java. The paper advocates the use of framework technology as the best way to promote software reuse in the control systems domain and discusses the precautions that must be taken to use this technology with Java as an implementation language in the presence of real-time constraints. It also presents two examples of instantiations of the AOCS Frameworks with two different Real-Time Java implementations.

Journal of Systems and Software, 2004

Rapid prototyping of complex systems embedded in even more complex environments raise the need of a multi-level design approach. Our example is taken from mechatronic design of the automotive industry and illustrate the rapid prototyping procedure of real-time critical control laws. Our approach is based on an object oriented structuring allowing not only central control units but supports distributed control units as needed in todays designs. The implementation of control laws is a stepwise refined hardwarein-the-loop simulation reducing the simulation part in each step. At the lower level common platforms as FPGAs, microcontrollers or specialised platforms can be instantiated. This is illustrated by an asynchronous data-flow processor for high performance rapid prototyping of cyclic iterated control laws.

4

2001

This paper presents AJACS (Applying Java to Automotive Control Systems), a two-year initiative to specify, develop and demonstrate an open technology allowing the use of Java in deeply embedded automotive systems such as engine control systems (http://www.ajacs.org). This initiative is jointly carried out within the High Integrity Profile working group of the J consortium with the objective to define a J consortium specification. It first discusses the trends in the automotive industry to go for global systems design : vehicle-level functions (e.g. cruise control) are viewed as a collection of collaborating sub-functions (e.g. measure speed, read brake pedal…) with very precise requirements. The basic aim is to reduce costs by being able to reuse the same sub-function for the implementation of several vehicle-level functions, and thereby to avoid hardware or software redundancies. A brief introduction on the OSEK/VDX initiative led by car manufacturers and OEMs to support this trend is then presented, followed by a discussion on how the Java technology could usefully complement it. Particular constraints for industrial acceptance are listed. One of them is adaptability to deeply-embedded configurations that are used in the industry today (e.g. system footprints with 256Kb ROM, 16Kb RAM). Technical issues are also presented. The paper then sketches the overall approach for the definition of a Java-based programming environment suitable to automotive control systems that is being defined in the High Integrity Profile for Automotive control (HIPA) specification work. It finally elaborates on the generation approach that will be used in AJACS.

2002

constrained resources devices used often in embedded systems are normally programmed using languages considered of low level. This has important implications in program development and maintenance. In fact, the code becomes less legible and the memory management in not an easy task. This problem can be overcome if the use of a high level language with garbage collector mechanism is considered. However, it is often a belief that from these high level languages results slowly programs, and so, they are unsuitable for embedded applications. In this paper this problem is addressed to show the applicability of Java to develop programs for constrained resources devices. An example of a control system for temperature control is presented to illustrate the advantages of the approach.

Proceedings of the 15th IFAC World Congress, 2002, 2002

Current tools for design and implementation of embedded systems lack sufficient support for handling the different development phases. These phases usually include design of control laws, supervision logic, real-time task scheduling, modeling of communication, etc. The heterogeneity of modern embedded control systems puts high demands on design and simulation tools. Many control systems are hybrid in the sense that they consist of a set of subcontrollers and some switching logic. The individual subcontrollers are conveniently described using discrete equations, the switching logic may be expressed using state machines, the complete controller is implemented as a task in a real-time operating system, the controlled plant is modeled as a system of differential equations, and so on. The Ptolemy project addresses the design, simulation and implementation of heterogeneous hierarchical systems. The design principles are demonstrated in the Ptolemy II software which advocates a component-based design methodology, and hierarchically integrates multiple models of computation, which can be used to capture different design perspectives. A Furuta pendulum control system is used as a motivating example. After designing a threemode hybrid controller under idealized assumptions, implementation effects, such as those caused by real-time scheduling and network communication, are taken into consideration to achieve a more realistic simulation.

Programmable Logic Controller, 2010