In the very recent past, there has been a trend for passenger transport towards electrification of the vehicles to reduce greenhouse gas emissions. However, due to the low energy density of battery technology, electrification of airplanes is not possible with current technologies. Here, Hyperloop systems can offer a climate-friendly alternative to short-haul flights but face some technical challenges to be resolved. In contrast to conventional rail systems, the Hyperloop concept uses magnetic propulsion and levitation to operate and has no physical contact with the environment. Consequently, mechanical backup solutions do not suffice to avoid catastrophic events in case of failure. Software solutions must, therefore, ensure fail-operational behavior, which requires autonomous adaptability to uncertain states. The MAPE-K approach offers a solution to achieve such adaptability. In this paper, we present a hierarchical architecture that combines the MAPE-K concept with the Simplex concept to achieve self-adaptive behavior. We impose our autonomous architecture on the controller design for the levitation system of a Hyperloop pod and show that this controller, designed using our methodology, outperforms a conventional PID controller by up to 76%.

Production systems continuously need to become more cost-efficient and flexible. Hardware-based programmable logic controllers, while widely used in the industry, do not offer the level of flexibility and scalability required for future applications. Each hardware-based PLC entails costs for maintenance and they cannot keep up with resource-intensive loads, such as artificial intelligence. The virtualization of PLCs promises to solve these issues. A Virtual PLC at the local edge level between cloud and industrial assets provides the flexibility and resource capacity needed for modern control applications. In this paper, the concept of virtual PLCs in a COTS server is outlined as a SoftPLC that is running within a virtual machine managed by a hypervisor. In addition, the virtual PLC is implemented and evaluated to determine whether virtual PLCs can satisfy the requirements for specific domains of industrial automation. We compare multiple virtual PLC configurations to a SoftPLC without a hypervisor. Our results indicate that the virtual PLC implementation is on par in terms of switching and response time for applications requiring response times below 10 ms and deterministic behavior is achievable. While further work is necessary, virtual PLCs may offer tremendous advantages for future industrial systems.

Resilience is a critical quality of future Industrial Control Systems (ICS). The ability to detect and react to unanticipated attacks, bugs, and failures is crucial. Self-adaptation can provide this ability, yet it is difficult to achieve in safety-critical real-time systems, since strict safety and timing requirements must be guaranteed. Recent results indicate that automated adaptation of ICS using the IEC 61499 is possible, however it has not been analyzed how much dynamic adaptation can contribute to overall system resilience. In this paper, we analyze how dynamic adaptation can be embedded into industrial control architectures, and quantify its advantage over a traditional restart. We propose a self-adaptive architecture using the MAPE-K model and merge it with the existing models for ICS. Using measurements on a real system, we estimate the expected adaptation time of selected adaptation scenarios and calculate the loss of productivity depending on the reaction time and adaptation complexity. The results show that using current dynamic adaptation mechanisms, minor to moderate adaptations can be completed within 10 ms, while larger adaptations can take up to a second from initialisation to cleanup. The resilience gain is larger the faster the reaction is initiated, which indicates that once dynamic adaptation is available, a faster detection and decision-making becomes more important. Dynamic adaptation can provide ICS the means to evolve and react rapidly, preparing them for an agile, flexible, and resilient future.

Established development processes for industrial control systems are static and struggle to adopt changing requirements. The interdisciplinary nature of such systems necessitates carefully designed interfaces between modules and components, as well as unambiguously defined requirements. The domain-specific modeling language IEC 61499 offers potentials to accelerate design processes and to introduce a model-driven approach, in which interface and behavior models are continuously refined and reused. We investigate these potentials and outline how to apply an extended development process in which implicit expert knowledge is preserved in behavior- and interface models that are currently not retained during the development. Based on a running example, we illustrate the refinement of scenarios along the development process and show how the retained information captures the expected behavior of the environment. We identify research questions and gaps in the elicitation, maintenance and utilization of these models, in particular in the domains of model-based testing, monitoring, and reconfiguration. An accelerated development process that integrates behavior models can help making future industrial control systems more dependable, flexible, and resilient during the whole life cycle.

Dynamic reconfiguration is a core contributor to the flexibility and agility of future industrial control systems. Verification and validation can provide some confidence in the success of a reconfiguration, yet unexpected external events or bugs can always lead to the abortion of the reconfiguration process. This can threaten the real-time behavior and must be anticipated. In this paper, we extend existing real-time models of dynamic reconfiguration to incorporate safe rollback scenarios that allow a disruption-free reversal of the reconfiguration process, thus providing fault-tolerance. We introduce the concept of a point of no return, after which a rollback is no longer feasible. We demonstrate in two example systems how the ordering of operations can affect the length of the rollback sequence and optimize the ordering of operations in two stages to find a sequence that offers a maximal fault-tolerance, while minimizing the real-time disruption. The results indicate that while considering potential failure modes requires additional overhead, it can provide fault-tolerance that promotes the further application of dynamic reconfiguration in practical applications. This may lead to higher agility and resilience in industrial control systems of the future.

Real-time decision-making is a key element in the transition from Reconfigurable Manufacturing Systems to Autonomous Manufacturing Systems. In Cyber-Physical Production Systems (CPPS) and Cloud Manufacturing, most decision-making algorithms are either centralized, creating vulnerabilities to failures, or decentralized, struggling to reach the performance of the centralized counterparts. In this paper, we combine the performance of centralized optimization algorithms with the resilience of a decentralized consensus. We propose a novel autonomous system architecture for CPPS featuring an automatic production plan generation, a functional validation, and a two-stage consensus algorithm, combining a majority vote on safety and optimality, and a unanimous vote on feasibility and authenticity. The architecture is implemented in a simulation framework. In a case study, we exhibit the timing behavior of the configuration procedure and subsequent reconfiguration following a device failure, showing the feasibility of a consensus-based decision-making process.

Dynamic reconfiguration and adaptability are crucial features in the evolution from automation to autonomy of industrial control systems. Component-based systems, such as specified in the IEC 61499, already provide a compelling framework for the distribution and transformation of software components, yet most reconfiguration approaches rely on a manual implementation of the required reconfiguration setup. We propose an automatic mechanism to generate the needed reconfiguration operations and order them into reconfiguration sequences, while preserving the dependencies of each operation. We further identify four scenarios for dynamic reconfiguration with different requirements regarding the treatment of state and showcase the results of our methodology on each scenario.

The IEC 61499 is a modeling language for distributed control systems. Despite numerous research results existing on this topic, industry acceptance is lacking. This paper aims to investigate the benefits of reusing an existing soft real-time runtime system for the implementation of the IEC 61499. For this purpose, FBBeam, a compiler that automatically converts IEC 61499 models to Erlang source code, was implemented. Possible execution semantics are presented and compared to the Erlang execution model. An initial case study examines the scalability of a multi-tasking runtime environment. The results indicate that Erlang is able to utilize multiple CPU cores efficiently and can distribute the load dynamically. FBBeam represents an opportunity to reutilize an existing runtime environment for research on dynamic updating, distribution, monitoring, maintenance, and fault-tolerance for Industry 4.0 or Cyber Physical Production Systems.

Despite several architectural advantages for the challenges of future manufacturing systems, the IEC 61499 standard is currently not widely accepted by industry. One advantage of the IEC 61499 is the concept of downtimeless system evolution. An extension of this, dynamic software updating, which allows switching out running processes and deal with unplanned changes, is readily available in the programming language Erlang. This paper investigates the real-time performance of an asynchronous, parallel IEC 61499 basic function block implementation in Erlang, a functional programming language with a soft real-time, concurrent runtime environment. As a result, although hard real-time performance is not guaranteed and the runtime environment is executed on top of a regular operating system, the performance is consistent and promising for future implementations and extensions.