Industrial real-time software is commonly evaluated on real embedded systems, while simulators are less used, since the abstraction level and purpose vary with for example, different programming languages and run-time contexts. This paper extends, applies, and evaluates previous work on a flexible task design that improve code reuse between discrete event simulators and embedded real-time systems. The paper focuses on two parts: (i) The performance cost of the proposed design in practice, by comparing the flexible task design with a traditional threaded approach. (ii) The potential of an alternative way to support legacy code in combination with discrete event simulation. The experiments indicate an almost negligible performance cost with respect to the real-time behavior, i.e., latency and jitter, while enabling improved code reuse between discrete event simulation and industrial embedded real-time systems.

Embedded systems are today often self-sufficient with limited and predefined communication. However, this traditional view of embedded systems is changing through advancements in technologies such as, communication, cloud technologies, and advanced analytics including machine learning. These advancements have increased the benefits of building Systems of Systems (SoS) that can provide a functionality with unique capabilities that none of the included subsystems can accomplish separately. By this gain of functionality the embedded system is evolving towards a “dual use” purpose11In this paper we define dual usage as a control system having two purposes. In other contexts such as politics, diplomacy and export control, the term “dual-use” refers to technology that can be used for both peaceful and military aims, e.g., nuclear power technology., The use is dual in the sense that the system still needs to handle its original task, e.g., control and protect of an asset, and it must provide information for creating the SoS. Larger installations, e.g., industry plants, power systems and generation, have in most cases a long expected life-cycle, some up to 30–40 years without significant updates, compared to analytical functions that evolve and change much faster, i.e., requiring new types of data sets from the subsystems, not know at its first deployment. This difference in development cycles calls for new solutions supporting updates related to new requirements inherent in analytical functions. In this paper, within the context of “dual usage” of systems and subsystems, we analyze the impact on an embedded system, new or legacy, when it is required to provide analytic data with high quality. We compare a reference system, implementing all functions in one CPU core, to three other alternative solutions: a) a multi-core system where we are using a separate core for analytics, b) using a separate analytics CPU and c) analytics functionality located in a separate subsystem. Our conclusion is that the choice of analytics information collection method should to be based on intended usage, along with resulting complexity and cost of updates compared to hardware cost.

Most evaluations of industrial real-time software are conducted on real embedded systems. The use of simulators that provides easily reproducible evaluations is often limited, due to different levels of abstraction, e.g., programming languages and run-time contexts. This paper extends previous work on a flexible task design, enabling tasks to be agnostic to run-time context, with evaluations conducted on bare-metal and real-time operating systems. Based on the same design and experiments we extend the proof-of-concept implementation in a discrete event simulation context, executing on a Windows based simulation host. Our experiments show that the flexible task design can be driven in a simulation run-time context, and still support typical industrial constructs. The result indicates that improved code reuse between discrete event simulators and industrial embedded systems is feasible.

The run-time context in industrial embedded systems varies from bare-metal microcontrollers, to multicore-processors running real-time operating systems. Due to the longevity of industrial systems, reusability and evolvability are often considered crucial quality attributes. This paper presents a new flexible task design that enables tasks to be agnostic to run-time context. Evaluations of the design were made by conducting experiments using a proof of concept implementation of the proposed design. The experiments were based on typical industrial constructs, such as periodic tasks, and event signaling from interrupts. Findings from the experiments show that tasks can be more agnostic to run-time context and still deliver functionality normally used within industry. The results indicate that it is feasible to improve reusability and evolvability between different run-time contexts, and in addition, support hybrid configurations that can reduce resource usage, since e.g. a thread can be easily shared among several tasks.

Industrial control systems often exhibit a need for short latencies and/or consistent data gathering. In a system with limited resources it is a challenge to achieve the combination of short latencies and consistent data. In this paper we propose three different architectural solutions to this challenge, each having different trade-offs: one that gives a consistent set of data and also a short latency but with a higher resource usage, a second alternative that reduces resource needs but at the cost of an increased latency, and a third and final solution that reduces resource needs to a minimum but in doing so also increasing the latency. The results presented in this paper suggest that it is possible to get low latency and robustness at the cost of performance.

A significant part of industrial systems have requirements on long life times. Such requirements on the complete system impose requirements on its corresponding embedded systems to be operational for an equally long time. As a consequence it is of paramount importance to be able to replace obsolete components of the embedded systems during the life time of the system, and to be able to update part of the design due to new requirements. In this paper we present a method to manage component replacement in such systems, and we present an industrial case study highlighting the work needed to replace an FPGA chip with another, including all corresponding legacy FPGA design challenges that comes with such a replacement. We have found one larger problem inherent in the ability to use the included components in a way that is not possible with the new circuits replacing the old ones. This problem significantly increased the work needed when performing the conversion and migration from the old design to the new, since parts of the design had to be redesigned from a functional perspective.

The use of cloud computing in different application areas is growing fast. More and more functions are being moved into the cloud in order to take advantage of cloud computing strengths such as scalability, resources on demand, and usage based cost models. However, most types of embedded systems are still in an early phase of cloud adoption, with a few exceptions found in e.g., data storage and user interfaces. In this paper we present a number of challenges and opportunities when introducing cloud computing into embedded systems. In particular, we look at embedded systems with requirements on timing predictability, i.e., real-time systems. In the paper we conclude that it is possible to move a complete soft real-time system into the cloud. Moreover we see an upcoming development in cloud computing to potentially allow for hard real-time systems to be moved to the cloud.

Handling of obsolete software and/or hardware components together with management of function updates in a complex embedded system with an expected life time of more than 30 years can be a very difficult to almost impossible task. This types of challenges can be found in a large number of companies in, for example, the power transmission industry, power plants, aviation etc. In this paper we present the basic steps in a proposed method for handling evolvability in such embedded systems with long expected life cycles. The key elements of the proposed method are the definition of function dependencies, release planning, and test requirements.

Agile has been used to refer to a software development paradigm that emphasizes rapid and flexible development. In the meanwhile, we have through our practical experiences in scaling up agile methods, noticed that architecture plays an important role. Due to the inter-relationship between agile methods and architecture, as well as divergent perceptions on their correlation stated in numerous sources, we are motivated to find out how these perceptions are supported by findings in the research community in general and in empirical studies in particular. To fully benefit from agile practices and architectural disciplines, we need empirical data on the perceived and experienced impacts of introducing agile methods to existing software development process, as well as correlations between agile and architecture. In this paper, we survey the research literature for statements made regarding the relationship between agile development and software architecture. The main findings are that there is a lack of scientific support for many of the claims that are concerned with agile and architecture, and more empirical studies are needed to fully reveal the benefits and drawbacks implied by an agile software development method.

Process improvement efforts based on best practices and standards such as the CMMI use appraisal results as input and focus on implementing processes as described in reference models. Since these models are of a general character the conclusions from the assessments could easily overlook problems experienced in the daily work. In addition, process improvement programs often fail to engage practitioners. To improve this, data that can be related to the daily work can help. This paper reports on the results from a study performed to understand how process data can complement project appraisals in finding improvement possibilities. A method for mapping process data to different practices and combining this with project appraisals to form a basis for focused performance improvement is proposed and a study including four projects from three organizations is presented.

The process of component- and component-based system development differs in many significant ways from the "classical" development process of software systems. The main difference is in the separation of the development process of components from the development process of systems. This fact has a significant impact on the development process. Since the component-based approach is a relatively young approach in software engineering, the main emphasis in the area has been in development of technologies, while process modeling is still an unexplored area. This paper analyses the basic characteristics of the component-based approach and its impact on the development process and lifecycle models. The generic lifecycle of component-based systems and the lifecycle of components are discussed, and the different types of development processes are discussed in detail: architecture-driven component development, productline development and COTS-based development. Finally a short case study illustrates the principles and specifics of component-based processes.

Consider the scenario where two or more software systems have been developed in-house, for different purposes. Over time, the systems have been evolved to contain more functionality, until a point where there is some overlap in functionality and purpose. The same situation occurs, only more drastically, as a result of company acquisitions and mergers. A new system combining the functionality of the existing systems would improve the situation both from an economical and maintenance point of view, and from the point of view of users, marketing and customers.