In the Logical Execution Time (LET) programming model, fixed execution times of software tasks are specified and a dedicated middleware is employed to ensure their realization, achieving increased system robustness and predictability. This paradigm has been proposed as a top-down development process, which is hardly applicable to a large body of legacy control software encountered in the embedded industry. Applying LET to legacy software entails challenges such as: satisfying legacy constraints, minimizing additional computational costs, maintaining control quality, and dealing with event-triggered computations. Such challenges are addressed here by a systematic approach, where program analysis and modification techniques are employed to introduce efficient buffering into the legacy system such that the given LET specifications are met. The approach has been implemented in a tool suite that performs fully automated transformation of the legacy software and may be carried out incrementally. This paper presents an application to large-scale automotive embedded software, as well as an evaluation of the achieved LET-based behavior for industrial engine control software.

Automotive architectures today consist of up to 100 electronic control units (ECUs) that communicate via one or more FlexRay and CAN buses. Multiple control applications - like cruise control, brake control, etc. are specified as Simulink/Stateflow models, from which code is generated and mapped onto the different ECUs. In addition, scheduling policies and parameters, both for the ECUs and the buses, need to be specified. Code generation/optimization from the Simulink/Stateflow models, task partitioning and mapping decisions, as well as the parameters chosen for the schedulers all of these impact the execution times and timing behaviour of the control tasks and control messages. These in turn affect control performance, such as stability and steady-/transient-state behaviour. This paper discusses different aspects of this multi-layered design flow and the associated research challenges. The emphasis is on model-based code generation, analysis, testing and verification of control software for automotive architectures, as well as on architecture or platform configuration to ensure that the required control performance requirements are satisfied.

In this paper, we introduce a novel and cost effective approach to calibrate the geometric properties of a far-infrared (IR) sensor. We further demonstrate that fully automatic sensor-to-sensor calibration is feasible in a setup involving a laser range scanner, IR cameras as well as conventional cameras. The calibration result then serves as a basis for upsampling range measurements to the resolution of the IR or visible-light camera images. Since our approach allows to rely on IR information instead of visible-light information for upsampling, bad light conditions or even no visible light at all are no limitation. From a practical point of view, we only require one calibration board of relatively small size which facilitates application in outdoor environments and further allows seamless integration of the IR camera in an existing multi-sensor platform. Our experimental results demonstrate that IR images are particularly useful to obtain reasonable depth information for living objects, when visible-light cameras are either blind or require impractical exposure times. In fact, our approach provides a convenient solution to IR camera calibration and integration, an issue which is particularly important in scenarios where sensors are not permanently mounted on vehicles and consequently require on-site adjustment and calibration.

Domain specific languages play an important role in model-driven engineering of software-intensive industrial systems. A rich body of knowledge exists on the development of languages, modeling environments, and transformation systems. The understanding of architectural choices for combining these parts into a feasible solution, however, is not particularly deep. We report on an endeavor in the realm of a technology transfer process from academia to industry, where we encountered unexpected influences of the architecture on the modeling language. By examining the evolution of our language and its programming interface, we show that these influences mainly stemmed from practical considerations; for identifying these early on, tight interaction between our research lab and the industrial partner was key. In addition, we share insights into the practice of cooperating with industry by presenting essential lessons we learned.

Existing embedded software development methodologies can hardly cope with platform changes such as CPU upgrades, different RTOS or distributed systems. The timing definition language (TDL) enables the development of deterministic real-time components regardless of the deployment platform. The proposed virtual execution environment enables parallel execution and deterministic run-time composition of real-time TDL components with data dependencies. We focus on embedded code generation and the virtual machine that controls the execution of TDL components and their interaction patterns.

The Timing Definition Language (TDL) provides a component model and a tool chain as a solution for building time-safe components that can be developed independently and integrated in a distributed platform without changing the observable behavior and the code of existing components. TDL is based on the Logical Execution Time abstraction and supports the decomposition of hard real-time applications into modules that are executed logically in parallel. This paper presents the algorithms for automatic schedule generation of TDL communications over the hyperperiod. As modules may switch modes independently, we combine the messages from all modes in the schedule. Hence, we introduce several optimizations to save bandwidth and improve the schedule's feasibility.

This paper introduces the notion of transparent distribution of real time software components. Transparent distribution means that (1) the functional and temporal behavior of a system is the same no matter where a component is executed, (2) the developer does not have to care about the differences of local versus distributed execution of components, and (3) the components can be developed independently. We present the design and implementation of a component model for real time systems that is well suited for transparent distribution. The component model is based on logical execution time, which abstracts from physical execution time and thereby from both the execution platform and the communication topology.

In state-of-the-art methodologies the critical timing properties of embedded software systems are accidental consequences of an implementation, rather than specified parts of the design. The Giotto project, lead by Thomas Henzinger at the University of California, Berkeley, delivered the formally sound concept of logical execution time (LET) as abstraction for explicitly specifying the timing behavior of embedded software. The presentation outlines the various hurdles along the way from the initial idea in 2000 until the shipment of products that incorporate model-based design relying on LET in 2005. For example, it was tempting to overcome certain limitations of the programming model at the price of loosing crucial embedded software properties such as determinism.

Due to the diversity of display capabilities and input devices, mobile computing gadgets have caused a dramatic increase in the development effort of interactive services. User interface (UI) tailoring and multi platform access represent two promising concepts for coping with this challenge. The paper presents the MUSA (multiple user interfaces, single application) prototype system that addresses both issues by introducing an event-graph as basis of a UI tailoring process.

Component-based software development is associated with a shift from statement-oriented coding to system building by plugging together components. The idea is not new and some progress has been made over the past decades. Nevertheless, today's software development practice is still far away from the vision. In recent years, the term componentware became the vogue in the software engineering community. The paper defines the relevant terms by relating the definitions to the already well-defined terms of object technology. In particular, the focus lies on a discussion of the deficiencies of the object-oriented paradigm and how componentware might solve these shortcomings.

This tutorial gives an overview of state-of-the-art design pattern approaches, focusing on those that support the development of frameworks. The tutorial also introduces so called hot-spot cards. These cards proved to be a useful communications vehicle between domain experts and software engineers in order to exploit the potential of design patterns. Hot-spot cards help in the early development phases to capture those system aspects that have to be kept flexible. Case studies based on Java illustrate how to apply design patterns together with hot-spot cards in various commercial application domains.

No abstract available.

This paper deals with human-computer interaction in several ways. On the one hand it presents the roots of interactive, graphic user interfaces and how such interfaces are implemented on the abstraction level of programming languages: The construction of graphic, direct-manipulation interfaces with conventional programming techniques is compared with an object-oriented approach based on powerful class libraries (called user interface application frameworks). Although application frameworks substantially ease the building of highly interactive applications the abstraction level is considered to be too low to support prototyping such interfaces in a comfortable way. Hence we portray DICE1 (Dynamic Interface Creation Environment), a tool for prototyping graphic user interfaces implemented itself in an object-oriented manner. In particular this paper discusses the question of how dynamic behavior can be added to a user interface prototype. It also presents a useful and powerful way to combine conventionally developed and object-oriented software systems.