Luka Lednicki

Model level worst-case execution time analysis for IEC 61499

The IEC 61499 standard provides a possibility to develop industrial embedded systems in a component-based manner. Besides alleviating the efforts of system design, the component-based approach also allows analysis of various system characteristics using system models even before the actual deployment. One of the crucial characteristics in the domain of safety-critical and real-time systems is timing: a failure to execute a specific task on time can have severe consequences. This paper presents a method for compositional model-level analysis of worst-case execution time of IEC 61499 software models. The analysis is performed on one hierarchical level of composition at a time, and the results can be stored together with the software artefact to be used when analysis is performed on the higher hierarchical level, or when the unit is reused in another system. The analysis has been implemented as a plug-in for the 4DIAC tool.

PRIDE - An Environment for Component-Based Development of Distributed Real-Time Embedded Systems

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-verification deployment 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.

15 years of CBSE symposium: impact on the research community

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.

Device utilization analysis for IEC 61499 systems in early stages of development

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.

A Component-Based Technology for Hardware and Software Components

One of the challenges in development of embedded systems is to cope with hardware and software components simultaneously. Often is their integration cumbersome due to their incompatibilities, different specifications and different approaches in their development. In this paper we present a component-based technology for building distributed embedded systems consisting of both embedded hardware devices and software components. To obtain a uniform view on hardware and software we have developed a new component model – UComp. Our technology consists of the UComp component model that allows treating remote devices as components, and a run-time framework that supports this component model when the system is deployed. To evaluate the principles we have developed a prototype tool that implements the technology and uses the Universal Plug and Play (UPnP) standard for communication between system parts.

Towards Automatic Synthesis of Hardware-Specific Code in Component-Based Embedded Systems

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 device- and 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.

Handling Cyclic Execution Paths in Timing Analysis of Component-Based Software

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.

A framework for generation of inter-node communication in component-based distributed embedded systems

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.