https://www.mdu.se/

As modern embedded systems grow in complexity component-based development is an increasingly attractive approach to make the development of such systems simpler and less error prone. In this approach software systems are built by composing them out of prefabricated software components. One of the challenges for applying component-based development to embedded systems is the tight coupling between the software and the hardware platform. To take full advantage of the component-based approach in the embedded domain, the development process has to provide support for describing and handling this coupling.

The goal of this thesis is to provide advancements in development of embedded component-based systems by using a combination of software and hardware models. To achieve the overall research goal, three different aspects are investigated: (i) how to provide support for integration of sensors and actuators in component-based development, (ii) how to utilize a combination of software and hardware models in development of distributed systems, and (iii) how to analyze extra-functional system properties using models of both software and hardware. The thesis goal is addressed by following contributions: (i) a component-based model which allows describing sensors and actuators, and how they are connected to the processing nodes and software components, (ii) a method for automatic synthesis of code for communication with sensors and actuators, (iii) a framework for automatic generation of distributed communication in component-based models and (iv) a compositional model-level analysis of timing and processing node utilization for component-based applications. These contributions are evaluated in separation, by applying prototype tools to either example systems, case-studies, or test scenarios.

In component-based and model-driven development it is common to model embedded applications in a platform-independent manner. As an example, some approaches allow development of distributed applications while abstracting away from details of communication between platform nodes. Using such an approach requires to implement this communication before an executable system is deployed. Currently it is common to automatically implement this communication on the level of code, while providing it on the model level is mostly a task that needs to be done manually. In this paper we present a framework for automatic generation of inter-node communication by adding communication components to software models. The framework provides flexibility in the level of automation of generation decisions, and is defined in a way which allows adding support for new communication media or protocols. We have implemented the generation framework for the IEC 61499 standard and provide a prototype generation tool, which we use for examining the applicability of the approach.

Usage of model-driven and component-based development approaches in embedded systems allows timing analysis to be performed using system models. One of the problems rarely addressed by model-level analysis is support for analysis of cyclic execution paths. In this paper we present a method which allows compositional worst-case execution time analysis to be performed on software models containing such cycles. Our method allows defining cycle bounds for components and connections, and provides an algorithm to analyze cyclic paths containing such bounds. Additionally, we provide a possibility to propagate cycle bound definitions through the component hierarchy. The method is applied to the IEC~61499 component model and its applicability has been tested using a prototype tool.

Model-driven and component-based approaches, such as the IEC~61499 standard, allow us to apply analysis to systems in early stages of development. When applied to embedded systems, early analysis can help guide the development process of both the software and the hardware platform, and thus reduce the time and cost of the development. In this paper we present a method for early analysis of device utilization for IEC~61499 systems. The method is based on determining device-specific worst-case execution time of each activity in the application. For this, we use timing information for individual algorithms together with IEC~61499 software and platform models. We provide a prototype implementation integrated in an open-source development environment.

In 2012, the International Symposium on Component-based Software Engineering (CBSE) is being organized for the 15th time. This is a great opportunity to take a step back and reflect on the impact of the symposium over these 15 years. Several interesting questions immediately come to mind: What were the main topics of interest in the community? What is the maturity of the field? What is the research CBSE Symposia impact? Who are the mots involved researches and researchers centers? In order to answer these questions we have performed a systematic review of 318 papers published under CBSE. In this paper we provide answers about the impact of the event, list and categorize the most frequent topics, and give some statistical data about the event during this period.

In recent years, there has been a clear trend in research and practice to bring benefits of component based development into the embedded systems domain. However, one often neglected aspect in component models is support for integration of hardware devices like sensors and actuators. In most component models, communication with such devices is either left out completely or considered as an integral part of the software component code. In the latter case, the software components are highly device-specific, and can hardly be reused on different platform configurations. This paper introduces an approach for automatic synthesis of device-specific code in component models for embedded systems. We divide a system in reusable elements: device-specific code, platform-specific code and device-dependant software component code. Based on a software and hardware model of the system, we then automatically generate glue-code that creates connections between these reusable elements. The result of our synthesis is a system-specific deployable code. The approach is illustrated by a demonstrator and an implementation example using the ProCom component model.

This report presents a complete list of papers published on the CBSE Syposium events (including Interational Workhop on Component Based Software Engineering 1998 - 2003, and International Symposium on Component Based Software Engineering 2004 - 2011). Each reference is accompanied with a unique identifier in the form of S-YY-Index.

This report presents the initial results from the Assist project at Mälardalen University, funded by the ABB Software Research Grant Program. The project aims to bridge the gap between recent academic research achievements in the area of control- and model based development of embedded systems, and concrete industrial needs and state of practice in this domain. Concretely, the focus of the project is to investigate how novel timing analysis and code synthesis techniques developed in the context of ProCom, an academic component model for embedded systems, can be extended and adapted in order to be applicable to IEC 61499.

Most component models currently in use do not try to provide extensive support for dealing with hardware devices like sensors and actuator. Lack of such support means that software components and subsystems often include deviceand platform- specific code, limiting our ability to reuse them and forcing us to deal with specifics of underlying hardware in high-level software models. In this paper we propose a solution that would enable automatic generation of device specific code. We remove device- and platform-specific code outside of software components and specifying it as reusable units. Based on a system model we then generate glue-code that binds this reusable units of code to each other and to the software components, resulting in a system-specific solution.

Component-based development promises many improvements in developing software for embedded systems, e.g., greater reuse of once written software, less error-prone development process, greater analyzability of systems and shorter time needed for overall development. One of the aspects commonly left out of component models is communication of software components with hardware devices such as sensors and actuators. As one of the main characteristics of embedded systems is the interaction with their environment through hardware devices, the effects of this interaction should be fully included in component models for embedded systems. In this paper we present a framework that enables inclusion of hardware devices in different phases of the component-based development process, including system design, deployment, analysis and code synthesis. Our framework provides a way for software components to explicitly state their dependencies on hardware devices, promotes reuse of software components with such dependencies and provides a basis for including hardware devices in analysis of component based embedded systems. We evaluate the feasibility of our approach by applying it to the ProCom component model.