Christo Angelov

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.

The synergistic integration of mathematics, software engineering, and user-centred design: exploring new trends in education

There is an increasing recognition in the society that interdisciplinary challenges must be part of new educational practices. In this paper, we describe the key curriculum activities at the University of Southern Denmark that combine mathematical modelling, software engineering, and user-centred design courses. These three disciplines represent a core of our graduate program, aiming at educating the professionals that will be capable of not only using but also further developing new technologies, and therefore, will be capable of fostering further the progress in computational science and engineering. Finally, we show how the learning environment, with emphases on broadening the student experience by industrial links, affects the student career aspiration.

Graphical model debugger framework for embedded systems

Model Driven Software Development has offered a faster way to design and implement embedded real-time software by moving the design to a model level, and by transforming models to code. However, the testing of embedded systems has remained at the code level. This paper presents a Graphical Model Debugger Framework, providing an auxiliary avenue of analysis of system models at runtime by executing generated code and updating models synchronously, which allows embedded developers to focus on the model level. With the model debugger, embedded developers can graphically test their design model and check the running status of the system, which offers a debugging capability on a higher level of abstraction. The framework intends to contribute a tool to the Eclipse society, especially suitable for model-driven development of embedded systems.

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.