Emerging cloud services provide users the device- and location agnostic access to their applications and personal data. With growing customer demand for personalized in-vehicle infotainment (IVI) the seamless access to personal data will play a crucial role in the success of upcoming IVI-systems. A seamless access, however, is tied to specific consumer electronic (CE)-device ecosystems and requires the storage of personal data in the backend infrastructure of the chosen ecosystem. An open and user-controlled middleware is missing. This paper present the webinos middleware for enabling the execution of applications across heterogeneous devices such as IVI-systems, smartphones, tablets, PCs and home media centers. By avoiding the storage of personal data in the backend infrastructure, users stay in control over their personal data. We evaluate the feasibility of our approach in respect for in-car scenarios with a prototype implementation of a browser-based Point-of-Interests manager on top of the webinos middleware. The application runs on three different device types - pc, smartphone/tablet and IVI-system.

Today, embedded systems are ubiquitous in highly safety-critical environments as represented by cars and airplanes. To avoid high warranty costs and human injury, their correct and thus safe operation must be ensured. Besides programming errors, hardware defects are a major source for the failure of such systems. Therefore, development approaches for safety-critical systems employ, in addition to strict rules for the software development, the redundant use of soft- and hardware in the run-time system in order to achieve the desired fault-tolerance. While redundancy may improve system safety, the correct integration of redundant soft- and hardware in the system's development further raises design complexity. In this paper we present an approach how redundancy may be generated automatically, disburdening the system developer from this task. This leads to less implementation effort and at the same time eliminates a potential source for coding errors. The concept is based on our deployment approach for automatic code generation and configuration of distributed embedded systems.

Model-driven development has become the state- of-the-art approach for designing embedded real-time systems. Due to their high level of abstraction, models are easier to understand and verify, thus leading to less faulty systems. But even when combined with automatic code generation, there is still the risk of unintended behavior. This may, for example, arise from real sensor inputs which differ from the characteristics assumed in the model. Consequently, debugging techniques still play an important role, even in model-driven development processes. However, debugging a system on the embedded target platform is tedious because of the limited user interface. In this paper, we present an approach for capturing runtime data on the target platform and mapping them back to the model. Debugging can then be performed at model-level by visualizing actual input data, like feedback from the target platform’s environment. Using a case study, we demonstrate a realization of our approach.

Model-driven development (MDD) today is the most promising approach to handle the complexity of software development for distributed embedded systems. Still, no single tool-chain exists that meets all needs of companies employing MDD. Moving back and forth between the tools in today's iterative development processes thus requires manual integration steps, which are error-prone and hamper reuse and refinement of models. A possible workaround is developing adapters for each pair of tools. Despite its large overhead, industry started pursuing this approach because of a lack of better alternatives. A proper solution is a tool-chain building on an integrated modeling language. We have realized this in cooperation with BMW Research and Technology. To increase the degree of automation during development, the modeling language builds upon a core featuring a rigorous semantics. This enables automatic analysis, facilitating an automatic transition from model-based designs to a distributed system running on the target platform.

A modeling language with formal semantics is able to capture a system's functionality unambiguously, without concerning implementation details. Such a formal language is well-suited for a design process that employs formal techniques and supports hardware/software synthesis. On the other hand, SystemC is a widely used system level design language with hardware-oriented modeling features. It provides a desirable simulation framework for system architecture design and exploration. This paper presents a design framework, called SysCOLA, that makes use of the unique advantages of both a new formal modeling language, COLA, and SystemC, and allows for parallel development of application software and system platform. In SysCOLA, function design and architecture exploration are done in the COLA based modeling environment and the SystemC based virtual prototyping environment, respectively. Our concepts of abstract platform and virtual platform abstraction layer facilitate the orthogonalization of functionality and architecture by means of mapping and integration in the respective environments. As SysCOLA is targeted at the automotive domain, the whole design approach is showcased using a case study of designing an automotive system.

Hard real-time embedded distributed systems pose huge demands in their implementation which must contain as few faults as possible. Over the past years, model-driven development and automatic code generation have proven to effectively reduce design faults in those systems. Still, models are mainly used for parts of the systems' functionality and most solutions do not address the generation of a whole system. In this paper we will showcase an approach for code generation for entire systems. A crucial step is the semantically correct realization of operating modes defined in the model. If they are not changed synchronously, a distributed system will show unpredictable behavior. We will demonstrate how a reliable transition between operating modes, even for a distributed system, can be achieved. Our approach is exemplified using a case study we carried out recently.

A modeling language with formal semantics is able to capture a system's functionality unambiguously, without concerning implementation details. Such a formal language is well-suited for a design process that employs formal techniques and supports hardware/software synthesis. On the other hand, SystemC is a widely used system level design language with hardware-oriented modeling features. It provides a desirable simulation framework for system architecture design and exploration. This paper presents a design framework, called SysCOLA, that makes use of the unique advantages of both a new formal modeling language, COLA, and SystemC, and allows for parallel development of application software and system platform. In SysCOLA, function design and architecture exploration are done in the COLA based modeling environment and the SystemC based virtual prototyping environment, respectively. Our concepts of abstract platform and virtual platform abstraction layer facilitate the orthogonalization of functionality and architecture by means of mapping and integration in the respective environments. As SysCOLA is targeted at the automotive domain, the whole design approach is showcased using a case study of designing an automotive system.

Model-driven development has become the standard approach for the development of avionic and automotive embedded systems. When a semantically founded modeling language is employed, the implemented systems can be checked and further processed in an automated manner. To this end, the Component Language (COLA) was invented. It allows for the definition of all information needed during system development. For a better understanding, and also debugging, of the systems modeled therewith, simulation at the level of the model is a welcome complement. In this paper we present a model-level simulator for COLA. It follows the language's semantics closely, thus guaranteeing the same behavior as specified in the model and implemented by other tools based on COLA. Furthermore, its modular nature allows for the use of different sources for input data. We will demonstrate the architecture and abilities of our simulator, using parts of a recent case study throughout the paper.

Model driven development (MDD) is well established as a means of tackling the complexity involved in designing such distributed embedded systems. The complexity of the modeled system not only necessitates proper abstractions, but also calls for automation to take a model to an executable object, and later to a functional integrated system. An automated translation reduces errors, guarantees reproducible results, and thus improves overall quality. We focus on automation of the translation steps. Using COLA, we need not handle a multitude of heterogeneous models, but rather benefit from the consistent modeling formalism and start with a single, behavioral, model. It provides a clustering of application components which define the tasks that must be allocated to hardware nodes contained in the platform model. The obtained executables are tailored towards the specific platform and require no further manual intervention before effective installation (flashing) onto the target hardware system.

Due to the time-to-market pressure, it is highly desirable to design hardware and software of embedded systems in parallel. However, hardware and software are developed mostly using very different methods, so that performance evaluation and validation of the whole system is not an easy task. In this paper, we propose a simulation approach to bridge the gap between model-driven software development and simulation based hardware design, by merging hardware and software models into a SystemC based simulation environment. An automated procedure has been established to generate software simulation models from formal models, while the hardware design is originally modeled in SystemC. As the simulation models are annotated with timing information, performance issues are tackled in the same pass as system functionality, rather than in a dedicated approach. For designing real-time systems, although performance evaluation based on simulation cannot provide guarantees of safety, it can provide realistic performance values to validate whether the performance requirements are really satisfied or not and show how pessimistic the static analysis is. Further, the simulative approach is also able to provide the developers an insight into the system architecture to help find bottlenecks of the system. We use the simulative approach as a complement of static analysis and combine them in an integral development cycle.

Model-driven development (MDD) is an emerging paradigm and has become state-of-the-art for embedded systems software design. In the overall design process, several steps have to be taken in order to get from a high-level system design to the deployed binaries on the target platform: starting from model design, software partitioning and code generation reaching down to task and bus scheduling. In this paper we focus on the later steps in the overall developing process and present a way to deploy clusters, which are tasks from an operational point of view, speci?ed using the Component Language (COLA). In this context, we introduce the notion of a Cluster Dependency Graph (CDG) which forms the basis for scheduling, address generation and estimation of memory requirements for the used middleware. Moreover the CDG provides clues about possibly parallelizable tasks. A case-study, namely an adaptive cruise control system (ACC), taken from the automotive domain serves as example throughout this paper to demonstrate our new approach.

Model-driven development has become common practice in design of safety-critical real-time systems. High-level modeling constructs help to reduce the overall system complexity apparent to developers. This abstraction caters for fewer implementation errors in the resulting systems. In order to retain correctness of the model down to the software executed on a concrete platform, human faults during implementation must be avoided. This calls for an automatic, unattended deployment process including allocation, scheduling, and platform configuration. In this paper we introduce the concept of a systems compiler using non-functional requirements (NFR) as a guidance for deployment of real-time systems. The postulated requirements are then used to optimize the allocation decision, i.e., the process of mapping model entities to available computing nodes, as well as the subsequent generation of schedules.

To deal with the increasing complexity of embedded real-time systems the model-driven development approach has proven to be beneficial. The reduction of complexity achieved by the used models, which are often implemented using a graphical modeling language, results in less faulty systems. For model-driven development to be effective, the possibility of human faults has to be kept as small as possible. This goal can be reached by utilizing automatic code generation and is hence already employed in production today. Tools like Matlab/Simulink or ASCET-SD are examples of such efforts. Yet those tools lack the possibility of designing not only parts, but specifying complete systems and generating code as well as configuration data for the overall application. The Component Language COLA is intended to fill this gap. While generating application code for COLA models is similar to the mentioned tools, the code shall be deployed onto a distributed system with as less manual interaction as possible. To enable for unattended deployment and efficient modification of the generated system, a transparent communication layer is desirable. In this paper we present a middleware approach intended for use in automatic system deployment for COLA. Besides transparent communication the presented middleware features additional services to the application like a clock synchronization mechanism, storage of task states and more. The details about the middleware's realization and its use for a model-driven process are described in the paper at hand.

Model driven development has become state of the art in embedded systems software design. To take the resulting models to the designated hardware platform, automated code generation is sought for. The code obtained thereby must match the semantics of the model as closely as possible. In this paper we show how to map models specified using the Component Language (COLA) to C code in an automated manner. In addition we present our concepts for interfacing the effective hardware platform, which in case of embedded systems means the interaction with sensors and actuators. Using a prototypical implementation of the code generator, we validated our approach on a case study using LEGO Mindstorms, which embody all characteristics of embedded systems. This case study includes benchmarks comparing the automatically generated code to a hand-written version offering the same functionality.

Model driven development has become state of the art in embedded systems software design. To take the resulting models to the designated hard- ware platform, automated code generation is sought for. The code obtained thereby must match the se- mantics of the model as closely as possible. In this paper we present an approach to translate Component Language (COLA) models to C code in an automated manner. This process involves handling of target specific sensors and actuators, and distribution of software across multiple nodes. We therefore also describe our middleware layer, which is configured in an unattended manner. Using a prototypical implementation of the tool- chain, we validated our approach on a case study using LEGO R MindstormsTM, which shows all characteris- tics of embedded systems. This case study includes benchmarks comparing the automatically generated code to a hand-written version providing the same functionality. (COLA) (3) was built to tackle the complexity of such large scale systems in a framework consistent across all layers of abstraction. COLA has a slender syntax, which caters for easy understanding, and it is defined by a rig- orous formal semantics. At higher levels of abstraction then formal verification, e.g., using model checking, can be applied to guarantee conformance with requirements. These characteristics make COLA well-suited for devel- opment of mission-critical real-time systems. The complexity of the modeled system not only necessi- tates proper abstractions, but also calls for automation to take a model to an executable object, and later to a func- tional integrated system. An automated translation re- duces errors and further guarantees reproducible results, and thus improves overall quality. The process of trans- lation is best compared to that of a software compiler. Given a functional model, usually as a piece of source code, a runnable entity is produced. A simple model of the system will comprise three layers: the software, an operating system, and the (single piece of) hardware. Compiler and linker will be given all constraints imposed by the operating system and the target hardware plat- form to obtain an appropriate piece of software. Apart from the straightforward translation, a fundamental job of today's compilers is optimization in terms of size and execution speed. Therefore, a set of rules is built into the compiler to obtain runnable entities optimized for a given platform and operation system. In embedded systems, we will call this process systems compilation, since the compilation must be accomplished for the overall system model, where the involved software and hardware components may be of various types. The target platform to operate on likely invalidates several assumptions made at model level, or exposes properties that are not captured by functional/behavioral model- ing. Furthermore, the distributed nature of the target hardware must be accounted for. Here, both translation and optimization are by no means straightforward. As per translation, often a heteroge- neous heap of models and requirements must be consid- ered to obtain a valid runnable entity (cf. (4)). Further, in general a certain level of black magic performed by engineers is required to fit the software and hardware components onto the target platform.

In this paper we present an approach of generating SystemC executable models from software designs captured in a new component-based modeling language, COLA, which follows the paradigm of synchronous dataflow. COLA has rigorous semantics and specification mechanisms. Due to its well-founded semantics, it is possible to establish an integrated development process, the artifacts of which can be formally reasoned about and are dealt with in automated tools such as model checkers and code generators. However, the resulting models remain abstract and cannot be executed immediately. Therefor SystemC offers executable models of a component-based flavor. Establishing an automated translation procedure from COLA to SystemC thus allows for design validation and performance analysis during early design phases. We have validated our approach on a case study taken from the automotive domain.

In this paper we introduce the component language COLA for the design and development of embedded systems. We present the formal syntax and semantics of COLA which is based upon synchronous data?ow. Utilizing the abstraction provided by this paradigm, the designer is freed from implementation details and is able to focus on the core-functionality to be modeled and implemented. Due to the well-founded semantics of the language, it is possible to establish an integrated development process, the artifacts of which can be formally reasoned about and are dealt with in automated tools such as model checkers or model-based test case generators. Since COLA has been developed in the context of an industrial cooperation, the main rationale in the design of COLA is its industrial applicability: Thus, the language must provide a well-de?ned semantical foundation which is accessible to today’s tools and techniques and which is also able to capture today’s industrial applications. To this end, we extend the data?ow approach with automata to model operating modes concisely as well as with a hierarchical decomposition to facilitate reuse e?ciently. We designed a textual and an equivalent graphical representation of COLA models to meet the need of our industrial collaborators. Finally, we demonstrate the viability of our approach with a case study from the automotive domain where we design an adaptive cruise control (ACC) unit.