Krzysztof Sierszecki

COMDES-II: A Component-Based Framework for Generative Development of Distributed Real-Time Control Systems

The paper presents a generative development methodology and component models of COMDES-II, a component-based software framework for distributed embedded control systems with real-time constraints. The adopted methodology allows for rapid modeling and validation of control software at a higher level of abstraction, from which a system implementation in C can be automatically synthesized. To achieve this objective, COMDES-II defines formally various kinds of components to address the critical requirements of the targeted domain, taking into consideration both the architectural and behavioral aspects of the system. Accordingly, a system can be hierarchically composed from reusable components with heterogeneous models of computation, whereas behavioral aspects of interest are specified independently, following the principle of separation-of concerns. The paper introduces the established generative methodology for COMDES-II from a general perspective, describes the component models in details and demonstrates their application through a DC-Motor control system case study.

Design models for reusable and reconfigurable state machines

The widespread use of embedded systems mandates a rigorous engineering approach towards embedded software development, i.e. model-based design of embedded software. The paper presents design models of reusable and reconfigurable state machines that have been conceived in the context of the COMDES framework and in particular – the State Logic Controller and the Hybrid State Logic Controller, whose principles of operation are presented in the paper. The latter has been instrumental in developing a reconfigurable executable component, i.e. a function block of class State Machine, which can be used to implement a broad range of embedded applications such as sequential, continuous and hybrid control systems, as well as complex systems specified with hierarchical and concurrent state machines.

A Component-Based Framework for Distributed Control Systems

The paper presents a two-level software framework for distributed embedded applications. At the top level, an application is conceived as a composition of embedded actors that communicate transparently by exchanging labeled messages (signals), independent of their allocation onto network nodes. Signals are exchanged at precisely specified time instants, in accordance with the concept of distributed timed multitasking (DTM). The combination of actors, signal-based communication and DTM provides a framework for the development of open yet predictable embedded systems. At the lower level of specification, actors are modeled as software objects that are configured from executable components - basic, composite and modal function blocks, as well as supervisory state machines. Actor behaviour is specified with a hybrid executable model - a clocked event-driven state machine operating in conjunction with modal function blocks, which can be used to implement a broad range of applications such as sequential, continuous and hybrid control systems

A formal component framework for distributed embedded systems

The widespread use of embedded systems mandates the development of industrial software design methods based on formal models (frameworks) and prefabricated components. This paper presents a formal specification of the COMDES framework, focusing on the main architectural issues and the specific line of reasoning that was followed while developing a hierarchy of executable models describing relevant aspects of system structure and behaviour. The above framework has been used to systematically define a hierarchy of reusable and reconfigurable components – simple and composite function blocks, reconfigurable state machines and function units – implementing the executable models presented in the paper.

A software framework for component-based embedded applications

The widespread use of embedded systems mandates the development of industrial software design methods, i.e. computer-aided design and engineering of embedded applications using formal models (frameworks) and repositories of prefabricated components, much in the same way as in other mature areas of engineering such as mechanical engineering and electronics. These guidelines have been used to develop the COMDES framework and the associated software design method, which are presented in the paper. The framework has been used to systematically define a hierarchy of generic executable components, which can be used as standard building blocks for a broad variety of embedded applications.

Verification of COMDES-II Systems Using UPPAAL with Model Transformation

COMDES-II is a component-based software framework intended for model-integrated development of embedded control systems with hard real-time constraints. It provides various kinds of component models to address critical domain-specific issues, such as real-time concurrency and communication in a timed multitasking environment, modal continuous operation combining reactive control behavior with continuous data processing, etc., by following the principle of separation-of-concerns. In the paper we present a transformational approach to the formal verification of both timing and reactive behaviors of COMDES-II systems using UPPAAL, based on a semantic anchoring methodology. The proposed approach adopts UPPAAL timed automata as the semantic units, to which different behavioral concerns of COMDES-II are anchored, such that a COMDES-II system can be precisely specified in UPPAAL, and verified against a set of desired requirements with the preservation of system original operation semantics.

Component-Based design of embedded software: an analysis of design issues

Widespread use of embedded systems mandates the use of industrial production methods featuring model-based design and repositories of prefabricated software components. The main problem that has to be addressed in this context is to systematically develop a software architecture (framework) for embedded applications, taking into account the true nature of embedded systems, which are predominantly real-time control and monitoring systems. There are a great number of design issues and unresolved problems with existing architectures, which have to be carefully analyzed in order to develop a viable component-based design method for embedded applications. Such an analysis is presented in this paper, which focuses on a number of key issues: specification of system structure; specification of system behaviour; component scheduling and execution; program generation vs. system configuration. The analysis has been used to formulate the guidelines used to develop COMDES – a software framework for distributed embedded applications.

A Software Framework for Hard Real-Time Distributed Embedded Systems

The paper presents a framework for distributed embedded applications that can be used to engineer open, and the same time, predictable embedded systems. Applications are composed from components (actors), which communicate transparently by exchanging labeled messages (signals) over a real-time network. The signals are exchanged at precisely specified time instants, in accordance with the Distributed Timed Multitasking (DTM) model of computation, resulting in the elimination of task and transaction I/O jitter. DTM is supported by an operational environment, which has been integrated with application components in an implementation model specifying explicitly the composition of software nodes allocated to physical network nodes. The framework is characterized by complete separation of computation and communication, whereby communication is delegated to the timed-multitasking operational environment. This has resulted in a simplified application model in which actors have been reduced to actor tasks composed of prefabricated components, such as state machine and action function blocks.

A Run-Time Environment Supporting Real-Time Execution of Embedded Control Applications

Designing safe and predictable software for embedded applications is a considerable challenge, which has been addressed by the COMDES-II framework. This is a component-based software framework employing a timed multitasking model of computation supported by a run-time environment. This paper presents a real-time kernel implementing the run-time environment - the HARTEXmu kernel that has been specifically developed for COMDES-II systems. The design and implementation of the kernel take into account the limitations of embedded systems, e.g. a small memory footprint and reduced kernel overhead. It also features Boolean vector processing that eliminates the need for linked-list queues, resulting in constant execution time of kernel functions independent of the number of tasks involved.

A JITTER-FREE OPERATIONAL ENVIRONMENT FOR DEPENDABLE EMBEDDED SYSTEMS

The paper presents a new real-time kernel architecture featuring component-based design, as well as advanced algorithms based on Boolean vectors and bitwise vector processing of kernel data structures. These have been consistently applied to all aspects of task management, as well as task synchronization and communication. Hence, the execution time of system functions no longer depends on the number of tasks involved, resulting in predictable, jitter-free operation of kernel subsystems. This approach has been further extended to time management resulting in a new type of kernel component, which can be used to implement Distributed Timed Multitasking - a novel computational model providing for predictable jitter-free execution of hard real-time tasks as well as distributed transactions in a dynamic scheduling environment.