Enabling Component-Based Design for Embedded Real-Time Software

ACM SIGBED Review, 2011

When the task befalls you to devise a novel component-oriented approach for real-time embedded systems you first dutifully undertake a thorough scrutiny of the import and pitfalls of previous attempts. This is what we have done for the last couple of years, in the context of an initiative promoted by the European Space Agency for the creation of a component model to serve the development of new-generation on-board software. In this paper we recapitulate the lessons we learned in that effort.

2001

This paper discusses the principles of developing software components for real-time systems. The procedure i s b ased on the fundamental concept of a real-time architecture rooted in the feedback control paradigm in control engineering. Generic design patterns for real-time software c omponents are presented, valid for all relevant real-time architectures. Finally, a case study of an air trafc control system based on the CORBA framework is discussed. Tool support for componentbased design and implementation is presented, including industry-strength commercial o -the-shelf software.

2009

As embedded systems must constantly integrate new functionalities, their developement cycles must be based on high-level abstractions, making the software design more flexible. CBSE provides an approach to these new requirements. However, low-level services provided by operating systems are an integral part of embedded applications, furthermore deployed on resource-limited devices. Therefore, the expected benefits of CBSE must not impact on the constraints imposed by the targetted domain, such as memory footprint, energy consumption, and execution time. In this paper, we present the componentization of a legacy industry-established Real-Time Operating System, and how componentbased applications are built on top of it. We use the Think framework that allows to produce flexible systems while paying for flexibility only where desired. Performed experimentions show that the induced overhead is negligeable.

Journal of Systems and Software, 2014

Please cite this article in press as: Panunzio, M., Vardanega, T., A component-based process with separation of concerns for the development of embedded real-time software systems. J. Syst. Software (2014), http://dx.a b s t r a c t Numerous component models have been proposed in the literature, a testimony of a subject domain rich with technical and scientific challenges, and considerable potential. Unfortunately however, the reported level of adoption has been comparatively low. Where successes were had, they were largely facilitated by the manifest endorsement, where not the mandate, by relevant stakeholders, either internal to the industrial adopter or with authority over the application domain. The work presented in this paper stems from a comprehensive initiative taken by the European Space Agency (ESA) and its industrial suppliers. This initiative also enjoyed significant synergy with interests shown for similar goals by the telecommunications and railways domain, thanks to the interaction between two parallel project frameworks. The ESA effort aimed at favouring the adoption of a software reference architecture across its software supply chain. The center of that strategy revolves around a component model and the software development process that builds on it. This paper presents the rationale, the design and implementation choices made in their conception, as well as the feedback obtained from a number of industrial case studies that assessed them. (M. Panunzio), [email protected] (T. Vardanega).

2011

Settling down the software architecture for embedded system is a complex and time consuming task. Specific concerns that are generally issued from implementation details must be captured in the software architecture and assessed to ensure system correctness. The matter is further complicated by the inherent complexity and heterogeneity of the targeted systems, platforms and concerns. In addition, tools capable of conjointly catering for the complete design-verificationdeployment cycle, extra-functional properties and reuse are currently lacking. To address this, we have developed Pride, an integrated development environment for component-based development of embedded systems. Pride is based on an architecture relying on components with well-defined semantics that serve as the central development entity, and as means to support and aggregate various analysis and verification techniques throughout the development -from early specification to synthesis and deployment. Pride also provides generic support for integrating extra-functional properties into architectural definitions.

Proceedings 27th EUROMICRO Conference. 2001: A Net Odyssey

During the last years the use of component-based software development (CBSE) gets more and more common for desktop applications to speed up time to market and reduce development costs. Especially in the area of embedded real-time systems the reuse of tested and robust parts of prior applications is of great desire, to fulfill the strong requirements on maturity, availability and cost. But further requirements like low power design and real-time execution of components makes it impossible to use component frameworks well known in the desktop area. This paper discusses the problems of componentbased software development for embedded real-time systems and derives requirements for a component framework for this domain. First insights for such a framework are presented.

2006

Design-time performance analysis of component-based realtime systems Citation for published version (APA): Bondarev, E. (2009). Design-time performance analysis of component-based real-time systems. Technische Universiteit Eindhoven.

Journal of Systems and Software, 2005

Software for embedded systems must cope with a variety of stringent constraints, such as real-time requirements, small memory footprints, and low power consumption. It is usually implemented using low-level programming languages, and as a result has not benefitted from component-based software development techniques. This paper describes a data-centric component model for embedded devices that (i) minimizes the number of concurrent tasks needed to implement the system, (ii) allows one to verify whether components meet their deadlines by applying Rate Monotonic Analysis (RMA), and (iii) can generate and verify schedules using Constraint Logic Programming (CLP). This model forms the foundation for a suite of tools for specifying, composing, verifying and deploying embedded software components developed in the context of the PECOS project.

This paper presents a framework to incorporate real-time theory with component based software engineering, in order to achieve predictable systems. The proposed technology is aimed at releasing the developers from analysis aspects, and having a synthesis tool resource efficiently mapping a feasible component based software architecture to a run-time environment. Two component technologies form the base of our proposal, the predictable infrastructure PECT and the real-time component technology AutoComp. By combining properties from both, we achieve a framework suited for resource constrained real-time systems.

Electronic Notes in Theoretical Computer Science, 2005

In this paper, we describe a methodology for the design and the development of component-based real-time systems. In our model, a component consists of a set of concurrent real-time threads that communicate by means of synchronous and asynchronous operations. In addition, each component can specify its own local scheduling algorithm. We also discuss the support that must be provided at the operating system level, and present an implementation in the SHaRK operating system.

2002

Embedded real-time applications are often built from scratch on a trial-and-error basis, which leads to sub-optimal designs with latent errors that are not detectable in early stages of use or deployment and often incurs prolonged time-to-market. A new application framework called Verifiable Embedded Real-Time Application Framework (VERTAF) is proposed for embedded real-time application development, with the aim of reducing design errors and increasing design productivity. VERTAF is an integration of three technologies, namely object-oriented technology, software component technology, and formal verification technology. VERTAF consists of five software components: Implanter, Modeler, Scheduler, Verifier, and Generator. Experiences of using VERTAF show a significant increase in design productivity through design reuse, and a significant decrease in design time and effort through design verification. An example shows a relatively low design effort on the part of the designer using VERTAF.

Using component-based software development in real-time system development offers significant benefits especially in enabling configurability, and rapid development and deployment of real-time software. Successful integration of component-based software development into real-time system development is greatly dependent on identifying issues that a design method for component-based real-time systems needs to address. The issues focused on by existing design approaches are decomposition of a real-time system into tasks and temporal analysis, while issues such as components, their relationship to tasks, and separation of concerns are not addressed. In this paper, we identify the criteria a design method for component-based real-time systems should fulfill to enable efficient, reuse-oriented, development of reliable and configurable real-time systems. The criteria include a real-time component model that supports mapping of components to tasks, separation of concerns in real-time systems through the notion of different types of aspects, and composition support, namely support for configuration and analysis of the composed real-time software. By introducing a new set of criteria for the design of component-based real-time systems, we help bridging the gap between the real-time and software engineering community and offer a good basis for evaluating existing, and developing new, design methods for building component-based real-time systems.

Journal of Signal Processing Systems, 2007

Currently available application frameworks that target at the automatic design of real-time embedded software are poor in integrating functional and non-functional requirements for mobile and ubiquitous systems. In this work, we present the internal architecture and design flow of a newly proposed framework called Verifiable Embedded Real-Time Application Framework (VERTAF), which integrates three techniques namely software component-based reuse, formal synthesis, and formal verification. The proposed architecture for VERTAF is component-based which allows plug-and-play for the scheduler and the verifier. The architecture is also easily extensible because reusable hardware and software design components can be added. Application examples developed using VERTAF demonstrate significantly reduced relative design effort, which shows how high-level reuse of software components combined with automatic synthesis and verification increases design productivity.

Lecture Notes in Computer Science, 2004

In this work, we propose a complete methodology called RESS (Real-Time Embedded Software Synthesis) for the automatic design of real-time embedded software. Several issues are solved, including software synthesis, software verification, code generation, graphic user interface, and system emulation. To avoid design errors, a formal approach is adopted because glitches in real-time embedded software are intolerable and very expensive or even impossible to fix. Time Complex-choice Petri Nets are used to model realtime embedded software, which are then synthesized using a time extended quasi static scheduling algorithm. The final generated C code is prototyped on an emulation platform, which consists of an 89C51 microcontroller for executing the software, an FPGA chip for programming the hardware for different applications, and some input/output devices. Two application examples are used to illustrate the feasibility of the RESS methodology.

2008 Design, Automation and Test in Europe, 2008

Embedded systems are often operating under hard real-time constraints. Such systems are naturally described as time-bound reactions to external events, a point of view made manifest in the high-level programming and systems modeling language Timber. In this paper we demonstrate how the Timber semantics for parallel reactive objects translates to embedded real-time programming in C. This is accomplished through the use of a minimalistic Timber Run-Time system, TinyTimber (TT). The TT kernel ensures state integrity, and performs scheduling of events based on given time-bounds in compliance with the Timber semantics. In this way, we avoid the volatile task of explicitly coding parallelism in terms of processes/threads/semaphores/monitors, and side-step the delicate task to encode time-bounds into priorities.