Engineering distributed control systems is a complex task, where the complexity and, thus, costs of the software development are growing rapidly. To keep the software complexity at an acceptable level and save time for development and subsequent maintenance, new solutions are sorely needed. In this paper, we investigate the advantages of using skills - universal control device interfaces - for generating complex logic in distributed control environments. By enriching a skill interface with the information about the dynamic behavior of a component under control, we compose the functionalities of individual control devices. The logic, required for such composition, is automatically derived from the interface description and the production plan, identifying the required skill sequence. The evaluation, executed using two industrial demonstrators, shows that the approach successfully handles different behavioral models and is capable of generating fault-tolerant orchestrators, including error handling scenarios. Overall, for developing a complex logic in a distributed skill-based automation system, the proposed approach shows significant savings in development time allowing to automate the skill composition task.

An asset administration shell (AAS), as a key concept of Industry 4.0 (I4.0), provides a machine-accessible interface to any kind of asset. To enable interoperability and smooth integration of the devices into the I4.0 middleware, an application implementing the device's functionality should be able to interact with different AASs. In this work, we investigate the integration of the Programmable Logic Controller (PLC) runtime systems into the I4.0 middleware. For doing this, we specify the function blocks (FBs) for connecting the PLCs with AASs and other I4.0 components, such as registry and discovery server. We analyze the requirements of such FBs while focusing on REST/HTTP- and OPC UA-based AASs, and provide interface specification for IEC 61499- and IEC 61131-3-based FBs. Furthermore, we implemented an FB library that enables communication with an AAS from the respective control applications. Those FBs allow accessing properties and invoking operations of remote AASs, as well as hosting AASs submodels. Common functionalities, such as registering the runtime system at the registry component, or finding AASs, are also supported. The results obtained in this paper will ease interaction with the complex AAS structure from the low-level devices.

Functionally described capabilities play an important role in the virtualization of manufacturing and the resource-specific realization with the skill-based approach. The importance of this modeling can be seen in a formalization of production capabilities for a holistic usage in a workflow from product orders towards manufacturing on the shop floor. This paper presents a concept for modeling and usage of functionally described capabilities along this workflow with combined modeling approaches. Therefore, the formalism and the setup of product requirements, functionally described capabilities, Petri Net Plans for creation of resource-specific process sequences, and at least their execution with skills are considered. The application and validation of this concept on a virtualized demonstrator example is shown. The achieved results for a given application from a product order towards its simulated manufacturing are presented.

While engineering distributed control systems, the implementation of the underlying communication interaction is a tedious and error-prone task. Some existing approaches to overcome this issue propose using generic interfaces to abstract the implementation and communication details. We reuse the information from these interfaces to automatically synthesize the required communication infrastructure. To demonstrate this idea, we implement the generation of the Programmable Logic Controller (PLC) code in IEC 61499, enabling the network communication for the distributed control applications. As a result, the prototype generation tool is capable of creating the PLC code according to the specification, provided by a service interface of a component. We examine the applicability of the approach on a small use case, generating a communication logic for a distributed control application.

The fourth industrial revolution (Industry 4.0) anticipates unplanned changes of production processes. Production changes may trigger synthesis, and preferably optimization, of architecture-level decisions, such as service deployment and composition. Performing such architecture-level decisions manually is difficult due to the ever-rising complexity of Industry 4.0 systems. In order to (semi-)automate the architecture synthesis and optimization, we propose an approach of service deployment and composition by using existing domain models. Our contribution is threefold: (1) We suggest a workflow with domain models for architecture synthesis in the industrial automation. (2) We display the formalization on a part of the workflow and provide an initial prototype of service deployment synthesis using a satisfiability modulo theories (SMT) solver. (3) We envision a way of service composition and code generation, and prototypically implemented it as conclusion of the suggested workflow. We demonstrate the practical use of the proposed approach in the Industry 4.0 scenario, i.e., flexible production of new products.

Architectural design decisions, such as service deployment and composition, plant layout synthesis, or production planning, are an indispensable and overarching part of an industrial manufacturing system design. In the fourth industrial revolution (Industry 4.0), frequent production changes trigger their synthesis, and preferably optimization. Yet, knowledge on architecture synthesis and optimization has been scattered around other domains, such as generic software engineering. We take a step towards synthesizing current knowledge on architectural design decisions in Industry 4.0. We developed a taxonomy describing architectural models, design decisions, and optimization possibilities. The developed taxonomy serves as a guideline for comparing different possibilities (e.g., application of different optimization algorithms) and selecting appropriate ones for a given context. Furthermore, we reviewed and mapped 30 relevant research works to the taxonomy, identifying research trends and gaps. We discuss interesting, and yet uncovered topics that emerged from our review.

The ongoing manufacturing systems transformation from mass production towards mass customization requires more flexible engineering solutions than the existing ones. The recently proposed control architectures target, among other plug-and-produce features, a reduction of configuration times. This is relevant for building a new production line as well as for faster reconfiguration when adding new hardware and product variants to an existing manufacturing line. This paper identifies operational requirements for such reconfiguration scenarios and proposes a way to implement them using the concept of a device adapter. The device adapter contains a device description and constantly updates it following the reconfiguration changes happening in a manufacturing system. This allows not only to detect the changes in the hardware, which appear in the production system, using the device discovery mechanisms but also automatically adapt the software. Preliminary tests have been performed on a demonstrator that shows both virtual and physical executions combined in a single system. The proposed solution supports automatic hardware and software reconfiguration on-the-fly without a need to stop and restart the whole production system.

For the manufacturing of customized products, systems require easier and better adaptivity of the production plant especially in terms of the control software. In recent research projects, a skill-based architecture has been introduced and presented within an industrial demonstrator proposing the required adaptivity. Within this work, the skill-based architecture is compared to a more traditional component-based hierarchical approach to identify strength and weakness of this approach, which then enables further improvements of the skill-based architecture. The flexibility of control software can not directly be measured. Therefore execution time, modularity, readability, and reusability considering the impact of component exchanges are used as evaluation criteria. Modularity and reusability are measured by the number of needed Function Blocks (FBs) and that can also be used for other systems respectively. To evaluate readability three derived metrics from the basic Halstead Metric are used. The comparison shows that the skill-based architecture is more complex but much more flexible than the more traditional component-based hierarchical approach.

An asset administration shell (AAS), as a key concept of the Industry 4.0, provides a machine-accessible interface to any kind of asset. An application implementing the devices functionality should be able to interact with different AASs.In this work, we specify the function blocks (FBs) for accessing properties and invoking operations of AASs. We analyzed the nature and requirements of such FBs while focusing on REST/HTTP- and OPC UA-based AASs and provided IEC 61499-based implementation.The results obtained in this paper will ease interaction with the complex AAS structure from the low-level devices.

The configuration of current automated production systems is complex and therefore time consuming while the market demands an easy setup and adaptability due to smaller batch sizes and volatile markets. While there are different concepts in research on how to simplify the engineering process by using generic skills or capabilities of devices, run-time control is still achieved with proprietary communication protocols and commands. The concept in this paper uses skills not only in the phase of engineering but also consequently for direct and generic control of field-devices. An executable skill-metamodel therefore describes the methodological functionality which is implemented by using OPC UA due to its vendor independence as well as built-in services and information model. The implementation uses client/server-based OPC UA and the pub/sub pattern to prepare for a deterministic real-time control in conjunction with TSN, which is required by industrial automation.

Assembly systems today are facing significant pressure to deliver high performance process executions, while being responsive to the fluctuating market demands. However, the implementation the trending Cyber Physical Systems concepts via ‘Plug-and-Produce’ devices produces some communication overheads. In this direction, the openMOS project aims to decouple the elements that are responsible for adaptation and general operations of the system. This allows the system to have two parallel processes. Towards this end, the priority is to deliver high performance process executions, while the other process focuses on delivering the required agility. The focus of this work is narrowed down to the development of task execution tables that guarantees high performance process executions. In this direction, the definition of task execution table is based on an existing AutomationML (AML) model that highlights the explicit relationships between the Product, Process and Resource (PPR) domains. A new decisional attribute has been added to the existing ‘Skill’ concept, which provides the flexibility to incorporate eventbased process alternatives. An insight description on how the system handles process executions during run-time failures is also provided. Finally, this paper illustrates the run-time implementation of the execution table with a help of an industrial case study that has been used for a demonstration activity within the openMOS project.

The modern manufacturing and production systems are changing into a flexible factory layout that raises a demand for distributed control systems, where various components from different vendors communicating over their capabilities (skills) to execute a production task. This paper offers a way of how the skills, offered by an automation system component, can be represented using a generic interface to allow the higher control levels to easily orchestrate the skills available in the system and control their execution in the runtime. We show how a skill can be modeled using a Finite State Machine and present a concrete example how the concept can be realized by means of the OPC UA communication protocol.

Modern manufacturing systems require a transformation from mass production towards mass customization. This results in a trend towards more agile production lines. It also demands a reduction of configuration times when building the production line as well as faster reconfiguration when adding new hardware and product variants to the manufacturing line. This paper introduces the concept of a device adapter that allows the device to be seamlessly plugged into the agile production systems. The device adapter wraps the device functionality and offers it as a service, hiding away the low-level process capability (skill) implementation and allowing to formally represent the production steps. Preliminary tests have been performed on an industrial demonstrator that simulates a real manufacturing process.

Current manufacturing and production are changing more and more into a flexible and adaptable factory layout that requires rapid changeover and short reconfiguration times of machines. Additionally the setup time for new devices should be as short as possible. In this paper we propose a hierarchical architecture for a multi-level Plug & Produce system and evaluate the proposed structure using open source OPC UA implementations for easy integration of new devices into an existing system. Aside from the requirements for such a system, basic concepts of the OPC UA Discovery Service Set are described and different open source OPC UA implementations for C/C++ and Java are compared.