Skip to main content
Fachgebiete
Automobil + Motoren Bauwesen + Immobilien Business IT + Informatik Elektrotechnik + Elektronik Energie + Nachhaltigkeit Finance + Banking Management + Führung Marketing + Vertrieb Maschinenbau + Werkstoffe Versicherung + Risiko
DE
EN
Themenseiten
Organisationspsychologie Projektmanagement Marketing Smart Manufacturing
Bücher
Zeitschriften
Weitere Formate
Podcasts Webinare Technik Webinare Wirtschaft Kongresse Veranstaltungskalender Awards
Jetzt Einzelzugang starten
Zugang für Unternehmen
Referenzkunden
MTZ-Fachkongress

Antriebe und Energiesysteme von morgen


Austausch von Automobil- und Energiewirtschaft

Am 14./15. Mai geht es in Chemnitz um die Mobilitätswende durch Elektro- und Wasserstofffahrzeuge.
Erweiterte Suche
Anmelden
nach oben

2005 | Buch

Component-Based Software Development for Embedded Systems – An Introduction Kapitel lesen Erstes Kapitel lesen

Component-Based Software Development for Embedded Systems

An Overview of Current Research Trends

herausgegeben von: Colin Atkinson, Christian Bunse, Hans-Gerhard Gross, Christian Peper

Verlag: Springer Berlin Heidelberg

Buchreihe : Lecture Notes in Computer Science

Enthalten in: Springer Professional "Wirtschaft+Technik" , Springer Professional "Technik" , Springer Professional "Wirtschaft"

Einloggen, um Zugang zu erhalten
insite
SUCHEN

Über dieses Buch

Embedded systems are ubiquitous. They appear in cell phones, microwave ovens, refrigerators, consumer electronics, cars, and jets. Some of these embedded s- tems are safety- or security-critical such as in medical equipment, nuclear plants, and X-by-wire control systems in naval, ground and aerospace transportation - hicles. With the continuing shift from hardware to software, embedded systems are increasingly dominated by embedded software. Embedded software is complex. Its engineering inherently involves a mul- disciplinary interplay with the physics of the embedding system or environment. Embedded software also comes in ever larger quantity and diversity. The next generation of premium automobiles will carry around one gigabyte of binary code. The proposed US DDX submarine is e?ectively a ?oating embedded so- ware system, comprising 30 billion lines of code written in over 100 programming languages. Embedded software is expensive. Cost estimates are quoted at around US$15– 30 per line (from commencement to shipping). In the defense realm, costs can range up to $100, while for highly critical applications, such as the Space Shuttle, the cost per line approximates $1,000. In view of the exponential increase in complexity, the projected costs of future embedded software are staggering.

Inhaltsverzeichnis

Frontmatter

Component-Based Software Development for Embedded Systems – An Introduction

Component-Based Software Development for Embedded Systems – An Introduction
Abstract
The potential benefits of component-based development are as attractive in the domain of embedded systems as they are in other areas of the software industry. These include reductions in development times and costs, improved quality and specialization of expertise. However, these benefits are much more difficult to realize in embedded systems development than in other areas of software engineering because the problems of composing extra-functional requirements such as quality, reliability and performance are much more acute. When building new applications from existing components it is not only necessary to ensure that they behave as expected, but also that these extra-functional properties are composed correctly. Until recently it was difficult to do this in an economically viable way, but recent trends have combined to make component-based software engineering as imperative for embedded systems development as it is in other domains.
Colin Atkinson, Christian Bunse, Christian Peper, Hans-Gerhard Gross

Specification and Verification

Specification and Verification of Applications Based on Function Blocks
Abstract
The concept of Function Block origins in automation engineering. It is the standard IEC 61499 that makes a Function Block paradigm for developing automation applications. Due to the component-like features, hardware-oriented view and explicit abstraction-complexity handling provided by Function Block paradigm, a methodology for applying CBD to embedded systems is suggested in this chapter. The classic CBD methods are considered in the combination with Function Block method, which are organized in a development process (i.e., V-model). In the development process, specification and verification issues are especially emphasized in this chapter. UML is chosen to take the pivot role of specifying all artifacts in the process.
Wei Zhang, Wolfgang A. Halang, Christian Dietrich
A Model-Based Approach to Formal Specification and Verification of Embedded Systems Using Colored Petri Nets
Abstract
In this chapter we introduce a component-based development process to deal with the complexity of the development of embedded software systems. This process is defined based on a reuse method for colored Petri nets. The use of formal methods and an associated systematic process promotes a greater confidence in the models reducing the time and errors to develop complex embedded software systems. A transducer network is used as a case study to illustrate the approach presented in this chapter.
Leandro Dias da Silva, Angelo Perkusich
Modular Verification of Reconfigurable Components
Abstract
This chapter presents a framework for modular verification of reconfigurable real-time components. The framework enables proving that the reconfiguration of components via aspect weaving provides expected functional and temporal behavior in the reconfigured component. Within the framework we formally represent components and aspects as augmentations of timed automata. The verification is based on two algorithms: an algorithm that extracts necessary information into component verification interfaces, and an algorithm that checks, on an aspect, whether the property is preserved upon reconfiguration. Hence, the method ensures that components are verified only once for a particular property, while the property satisfaction under reconfiguration is checked only on aspects. Verification interfaces for a given property can be reused for multiple aspects and reconfigurations.
Aleksandra Tešanović, Simin Nadjm-Tehrani, Jörgen Hansson

Component Compatibility

Behavioral Types for Embedded Software – A Survey
Abstract
At present, there is a variety of formalisms for modeling and analyzing the communication behavior of components. Due to a tremendous increase in size and complexity of embedded systems accompanied by shorter time to market cycles and cost reduction, so called behavioral type systems become more and more important. This chapter presents an overview and a taxonomy of behavioral types. The intentions of this taxonomy are to provide a guidance for software engineers and to form the basis for future research.
Walter Maydl, Lars Grunske
Assessing Real-Time Component Contracts Through Built-in Evolutionary Testing
Abstract
Real-time contracts between components, as an important aspect of quality-of-service considerations, add a new dimension to the development and validation of component-based embedded systems. A real-time contract determines the fulfillment of a component’s response time requirements when it operates in a client-server relation with other components. This represents a typical contract testing scenario in which the client component needs to assess the timely response of an associated server component according to its usage profile of that server. The basic model of built-in contract testing technology is capable of assessing the correctness of behavioral contracts between components in this way. This chapter introduces an extension to the basic built-in contract testing model that puts components into the position to assess their deployment environment with respect to response time specifications. This extended model of built-in contract testing requires some additional built-in test architecture for components plus an automatic test case generator that is based on search heuristics.
Hans-Gerhard Gross, Nikolas Mayer, Javier Paredes Riano

Component Architectures, Implementation and Tool Support

Platform-Independent Specification of Component Architectures for Embedded Real-Time Systems Based on an Extended UML
Abstract
A way to specify component-based software architectures for embedded real-time systems is introduced. Component models are specified taking the Model Driven Architecture (MDA) approach, and employing UML notations. First, the principle of the developing process based on the MDA approach and the new concepts of UML-specified component architectures are addressed. Then, a conceptual framework architecture for the design of embedded real-time systems is presented, in which platform-independent component models are built. Taking specific platform features into regard, specific component models result from transformations mapping the platform-independent component model to either the Process and Experiment Automation Real-Time Language (PEARL) or to Function Blocks according to IEC 61131-3 or IEC 61499.
Shourong Lu, Wolfgang A. Halang
Model Driven Software Development in the Context of Embedded Component Infrastructures
Abstract
In this chapter we motivate the need for an infrastructure platform for embedded software, supporting the development of reusable systems. Our solution is based on a component infrastructure that is implemented using model-driven software development (MDSD) techniques. This approach allows us to achieve the goal of re-usability while still providing an efficient system, tailored for the specific embedded hardware and operating system.
This chapter explains the principles of our approach and introduces model-driven software development. It illustrates the concepts by presenting an example of how to model and specify the embedded application (a simple weather station), and how to generate supporting component middleware infrastructure from these models.
Markus Voelter, Christian Salzmann, Michael Kircher
A Component Framework for Consumer Electronics Middleware
Abstract
Developers of Consumer Electronics (CE) devices face the problem of the ever increasing amount of software that needs to be developed. At the same time the time to market of their products needs to decrease. In other domains Component Based software development aids in solving the resulting problems. However, existing component frameworks fail to meet some of the requirements specific for the CE domain. In order to improve this situation a component-based framework has been developed. In this chapter we describe this framework and motivate the architectural choices. These choices are influenced by the requirements on the framework. Some of these requirements are specific for the CE domain, others are more general.
Johan Muskens, Michel R. V. Chaudron, Johan J. Lukkien
Connecting Embedded Devices Using a Component Platform for Adaptable Protocol Stacks
Abstract
Research domains such as sensor networks, ad-hoc networks, and pervasive computing, clearly illustrate that computer networks have become more complex and dynamic. This complexity is mainly introduced by unpredictable and varying network link characteristics, heterogeneous capabilities of attached nodes, and the increasing user expectations regarding reliability and quality of service. In order to deal with this complexity and dynamism of computer networks, the system’s protocol stack must be able to adapt itself at runtime. Yet, to handle this complex challenge effectively and efficiently, we claim that it is essential for protocol stacks to be developed with run-time adaptability in mind. This chapter presents a software architecture tailored to build highly adaptable protocol stacks, along with a component platform that enforces this architecture. Although the presented software architecture focuses on protocol stacks in general, we zoom in on the application of its founding principles in the domain of embedded network devices.
Sam Michiels, Nico Janssens, Lieven Desmet, Tom Mahieu, Wouter Joosen, Pierre Verbaeten
CoConES: An Approach for Components and Contracts in Embedded Systems
Abstract
This chapter presents CoConES (Components and Contracts for Embedded Software), a methodology for the development of embedded software, supported by a tool chain. The methodology is based on the composition of reusable components with the addition of a contract principle for modeling non-functional constraints. Non-functional constraints are an important aspect of embedded systems, and need to be modeled explicitly. The tool chain contains CCOM, a tool used for the design phase of software development, coupled with Draco, a middleware layer that supports the component-based architecture at run-time.
Yolande Berbers, Peter Rigole, Yves Vandewoude, Stefan Van Baelen
Adopting a Component-Based Software Architecture for an Industrial Control System – A Case Study
Abstract
This chapter presents a case study from a global company developing a new generation of programmable controllers to replace several existing products. The system needs to incorporate support for a large number of I/O systems, network types, and communication protocols. To leverage its global development resources and the competency of different development centers, the company decided to adopt a component-based software architecture that allows I/O and communication functions to be realized by independently developed components. The architecture incorporates a subset of a standard component model. The process of redesigning the software architecture is presented, along with the experiences made during and after the project. An analysis of these experiences shows that the component-based architecture effectively supports distributed development and that the effort required for implementing certain functionality has been substantially reduced while, at the same time, the system’s performance and other run-time quality attributes have been kept on a satisfactory level.
Frank Lüders, Ivica Crnkovic, Per Runeson

Non-functional Properties

Specification and Evaluation of Safety Properties in a Component-Based Software Engineering Process
Abstract
Over the past years, component-based software engineering has become an established paradigm in the area of complex software intensive systems. However, many techniques for analyzing these systems for critical properties currently do not make use of the component orientation. In particular, safety analysis of component-based systems is an open field of research. In this chapter we investigate the problems arising and define a set of requirements that apply when adapting the analysis of safety properties to a component-based software engineering process. Based on these requirements some important component-oriented safety evaluation approaches are examined and compared.
Lars Grunske, Bernhard Kaiser, Ralf H. Reussner
Performance Evaluation Approaches for Software Architects
Abstract
Performance analysis techniques have already been developed for decades. As software architecture research has matured, performance analysis techniques have also been adapted to the evaluation of software architectures. However, the performance evaluation of software architectures is not yet systematically used in the industry. One of the reasons may be that it is difficult to select what method to use. The contribution of this work is to define a comparison framework for performance evaluation approaches. In addition, the framework is applied in comparing existing performance evaluation approaches. The framework can be used to select methods for evaluating architectures, to increase understanding of the methods, and to point out needs for future work.
Anu Purhonen
Component-Based Engineering of Distributed Embedded Control Software
Abstract
Embedded control applications have become increasingly network-centric over the last few years. Inexpensive embedded hardware and the availability of pervasive networking infrastructure and standards have created a rapidly growing market place for distributed embedded control applications. Software construction for these applications should be inexpensive as well in order to satisfy mass-market demands. In this chapter, we present results from an industrial-driven collaborative project with the purpose of researching component-based software engineering technologies for mass-market network-centric embedded control applications. This project has lead to the development and refinement of several tools in support of component-based software development. We describe these tools along with their underlying concepts and our experiences in using them.
J. H. Jahnke, A. McNair, J. Cockburn, P. de Souza, R. A. Furber, M. Lavender
Component-Based Development of Dependable Systems with UML
Abstract
Dependable systems have to be developed carefully to prevent loss of life and resources due to system failures. Some of their mechanisms (for example, providing fault-tolerance) can be complicated to design and use correctly in the system context and are thus error-prone. This chapter gives an overview of reliability-related analyzes for the design of component-based software systems. This enables the identification of failure-prone components using complexity metrics and the operational profile, and the checking of reliability requirements using stereotypes. We report on the implementation of checks in a tool inside a framework for tool-supported development of reliable systems with UML and two case studies to validate the metrics and checks.
Jan Jürjens, Stefan Wagner
Backmatter
Metadaten
Titel
Component-Based Software Development for Embedded Systems
herausgegeben von
Colin Atkinson
Christian Bunse
Hans-Gerhard Gross
Christian Peper
Copyright-Jahr
2005
Verlag
Springer Berlin Heidelberg
Electronic ISBN
978-3-540-31614-5
Print ISBN
978-3-540-30644-3
DOI
https://doi.org/10.1007/11591962

Premium Partner

    Bildnachweise