Human-Robot Collaboration (HRC) offers potential for flexible manufacturing, especially in small and medium-sized enterprises, but existing systems often lack adaptability to dynamic environments and human needs. This paper presents a novel, skill-based framework for user-centric, Quality of Service (QoS) based orchestration of HRC workflows. Our three-layer architecture separates non-real-time orchestration and workflow management from real-time, safety-critical execution, coordinated via a user-friendly interface using our Gantt chart-based Robot Collaboration Language. The framework allows users to define QoS goals (e.g., speed, energy efficiency, ergonomics), influencing high-level orchestration and low-level motion planning. This paper details the implementation and demonstrates the framework’s structure. It contributes towards more flexible, efficient, and human-aware robotic systems by providing an integrated approach to adaptive HRC workflow execution.

The debugging capabilities in the automation domain lag behind those in other domains. One obstacle to debugging systems in the automation domain is the presence of heavy and costly machinery connected to the Programmable Logic Controllers (PLCs). Replay debugging presents an opportunity to overcome this issue by allowing the user to debug a system with full control and observability, without the real system being connected. During the first stage of replay debugging, information is captured while the system is running. This is then used during the second stage to reproduce the system in a safe environment.This work focuses on a viability analysis of replay debugging for Function Block networks within resources modelled according to the IEC 61499 standard. In order to reduce the execution impact of information capture, the work presents an approach where only a small subset of the run-time information is captured and can be used in an offline stage to generate the full execution behaviour of an IEC 61499 resource. Thorough tests and experiments show that the reproduction of the original states is possible.

Signal processing plays a vital role in various areas of engineering, particularly in industrial automation. Signal processing applications are based on a data flow paradigm, which uses directed graphs to describe the flow of data between operations. Although industrial control applications are based on standards such as IEC 61499, their syntax, and semantics differ from the data flow paradigm, creating a challenge in integrating signal processing applications into industrial automation systems. Modeling signal processing applications using IEC 61499 is not yet a common practice. This paper addresses this gap by proposing an approach to transform data flow models into IEC 61499 models. This approach enables the design and transformation of signal processing applications using data flow models, without requiring manual modeling or knowledge of the IEC 61499 standard. The model transformation is formally defined and subsequently implemented as a separate tool. A running example illustrates the transformation process, demonstrating that the model is both syntactically correct and executable.

IEC 61499 is a proven technique for the model-based engineering of factory automation systems. Due to recent developments in this field like Industry 4.0, however, modern systems rely more and more on distributed computer technology. In this article, we investigate if and to which degree IEC 61499 together with IEC 61131-3 Structured Text as the algorithm implementation language is suited to also model the behavior of these amended systems. To achieve that, we selected three relevant use cases, i.e., mixed initiative mitigation, free-pool, and heartbeat, and exemplarily implemented each of them. This allowed us to get insight about what can be conveniently specified using IEC 61499 and for what an extension of the modeling technique is recommended. In this paper, we introduce the models for the three use cases and report the lessons learned from their implementation. Based on that, we suggest enhancements to IEC 61499.

Semantic domain models are becoming an essential component of software-intensive Cyber-Physical Production Systems (CPPSs). They support the implementation of innovative concepts like Digital Twins (DTs), that enable autonomous operations of an entire production environment. However, developing domain models for CPPS is a challenging endeavour, especially due to a lack of standardised modelling approaches within the manufacturing domain. In this paper, we have tried to reduce this existing research gap by proposing a conceptual modelling approach that allows developing generic domain models of a production environment. The focus of this research work is to define generic modelling constructs that can be employed to capture domain concepts in a technology- or standard-neutral manner and used by various software engineering disciplines to develop diverse use case-specific CPPS applications.

Control software components in the Cyber-Physical Systems domain use Function Blocks (FBs) to implement system logic, which manages interactions among hardware components (e.g., sensors and actuators) and other control software modules. FBs provide discrete input and output interfaces that support unidirectional data and event connections, which facilitate the integration of multiple subsystems to meet overall system requirements. However, this design based on discrete interfaces results in a high number of connection instances and lacks encapsulation. The complexity is further compounded by implicit one-to-many (fan-out) connections among subsystems, which can hinder both system understandability and maintainability. To address these challenges, we propose leveraging the adapter interface concept from IEC 61499. This approach replaces multiple discrete connections with a single bidirectional adapter connection that explicitly defines interaction requirements between components. Consequently, this reduces visual complexity and enhances system maintainability and testability.

Understanding event propagation in IEC 61499 applications presents a significant challenge for control software developers. To address this issue, we adapted the well-known concept from software engineering called control flow graphs to create Event Flow Graphs. The purpose of developing Event Flow Graphs is to better understand and model event flow through IEC 61499 applications, and to see how the flow affects hardware and software components of the system. Our initial results show that Event Flow Graphs can accurately capture the properties of IEC 61499 models. This enables us to interpret common graph properties and invariants, and apply basic graph algorithms to query Event Flow Graphs efficiently. In addition, as an analysis tool, Event Flow Graphs represent a good alternative to visualize IEC 61499 applications, whose graphical and hierarchical nature can sometimes obscure event execution. The first findings indicate that Event Flow Graphs are valuable for analyzing and visualizing IEC 61499 software.

Domain-specific languages (DSLs) can simplify the programming of human-robot collaboration (HRC) systems for non-experts. However, executing skill-based DSLs for HRC programming requires integrating various production resources such as robots, humans, and sensors. Therefore, domain overlapping requirements must be considered when choosing an appropriate execution approach. This paper identifies and explains key requirements such as flexible interfaces, dynamic capability discovery, task dependency resolution, spatial awareness, continuous monitoring, and user interfaces. Through a comprehensive literature review and gap analysis, we identify trade-offs in execution methodologies. Based on this, we propose an orchestration-based strategy that offers centralized coordination, extendable interface integration, and monitoring capabilities to address current limitations in executing DSLs in HRC applications.

Cyber-Physical Production Systems (CPPSs) have emerged as a cutting-edge manufacturing paradigm that aims to utilise innovative technological concepts like the Digital Twin and Artificial Intelligence to upgrade and optimise the productivity level of manufacturing environments. These concepts typically thrive on data and could be challenging to implement due to the semantic heterogeneity induced by the diverse manufacturing resources. Information modelling is a well-established approach traditionally used in software engineering to address semantic heterogeneity. Although the relevance of information modelling has already been established in CPPS, a suitable framework for information model development is not yet available. Therefore, our goal is to address this issue by proposing a domain-specific semantic information modelling framework for CPPS that enables the seamless integration of diverse manufacturing resources into intelligent business applications.

When designing cyber-physical systems, especially in industrial automation, model-driven engineering plays an essential role in ensuring software maintainability and supporting evolution. Whereas textual programming environments provide mature tool support for refactoring and maintenance, equivalent capabilities in many industrial visual languages, such as IEC 61499 and Simulink, remain underdeveloped. This research addresses the challenges of maintaining and refactoring models in typed block-based modeling languages, such as IEC 61499 and Simulink, which are frequently used in industry. We propose a methodology that embeds repair mechanisms directly into refactoring processes, ensuring model consistency and minimizing manual intervention. By introducing a meta-model-based approach, we identify common maintenance operations and systematically define transformations that preserve the execution semantics while improving maintainability. Our approach is evaluated through a cross-language implementation, demonstrating its applicability across different modeling tools and industrial settings. We developed the concepts and assistance tools in close collaboration with our industry partner to enable software maintenance of large-scale automation software. The lessons learned are generalizable for various tool developers and contribute to error-resilient model evolution in visual modeling environments.

The debugging capabilities of software development tools in the automation domain lag behind other domains. Basic capabilities fromregulardebuggers, such as breakpoints and step-by-step execution, are hard to find or do not support all requirements imposed by the domain. This work presents the results of a Systematic Literature Review carried out to understand the characteristics of the automation domain that influence the debugging capabilities of Programmable Logic Controller (PLC) software and to find the current state and future directions of debugging tools. The process of the review was prepared and reviewed before its execution to avoid any type of bias. The review successfully finds the major characteristics affecting the debugging of PLC software which include the presence of interconnected components and heavy machinery from different domains, the participation of different stakeholders at different phases of the development of the automation systems, and the restricted software capabilities specific to the domain. The existing debugging capabilities are mainly limited to monitoring and forcing the current state of the PLC software. However, research is being done in different areas that help debug PLC software, such as testing and simulation, and static and dynamic code analysis. The latter helps develop more powerful debugging capabilities such as the reproduction of real-time scenarios and replay debugging. The usability of debugging tools is also a subject of study in the automation domain. The work ends with an overview of future research directions to close the gap to other domains.

Control software in the Cyber-Physical Production System domain continuously evolves to cater to customer needs. Addressing customer needs involves developing new functional requirements or modifying existing functionalities, leading to the creation of product variants. Clone-and-own is a common reuse strategy in which the closest variant in project history is cloned and then modified to derive a new variant. Platform-oriented reuse is an alternative strategy that builds a configurable platform to derive variants. Adopting both reuse strategies for existing systems requires common and variant-specific artifacts to be extracted and maintained. This paper proposes two extraction methodologies that extract common and variant-specific artifacts from existing systems for systematic reuse. We evaluate the two extraction methodologies by applying them to multiple industrial and academic control software case study systems developed using IEC 61499. We conduct quantitative analysis of the extracted artifacts, considering factors such as the total effort required to derive variants, the number and size of artifacts that need maintenance, and their evolution using the two extraction methodologies. Our proposal suggests different variants of control software that lead to the creation of artifacts that are not only more optimal but also easier to maintain using a specific extraction methodology.

The design process for manufacturing systems involves different architectural design decisions (ADDs), including deploying software to hardware components, determining shop-floor topology, and planning production tasks for stations. These ADDs exhibit complex interactions, where the synthesis of one ADD impacts other ADDs, highlighting the need to investigate their dynamic interplay. However, current research prioritizes individual ADDs over exploring multiple ADDs together. This work investigates a multi-dimensional design space exploration (DSE) of deployment, shop-floor topology, and production planning ADDs. We introduce mitigation constraints to ensure the compatibility among these ADDs. To evaluate our approach, we apply it to a flexible manufacturing line demonstrator. Furthermore, we assess and compare various DSE workflows, providing preliminary guidance to software architects on mitigatlng conflicts and enhancing the quality of ADDs.

Bad smells negatively influence different aspects of software, such as maintainability and quality. From development to maintenance, smells contribute to error-proneness and control software is no exception. Code smells are starting to gain some popularity in the domain of industrial automation and programming languages for Programmable Logic Controllers. However, they are still not as well researched as in general Software Engineering and lack appropriate support. Shotgun Surgery is a type of bad smell which can occur when changing source code. If every time a functionality is updated, many of the places where it is used need to be updated as well - we can sniff out Shotgun Surgery. This poses different challenges: being aware of all the places where this particular functionality is used and correctly updating those places. We aim to bridge the gap between bad smells and control software partially. We want to do this by developing approaches for automatic detection, visualization, and refactoring of Shotgun Surgery in IEC 61499 applications in Eclipse 4diac IDE.

This paper proposes a novel library management system tailored for Cyber- Physical Production Systems (CPPSs) using the IEC 61499 standard. Focusing on software maintenance challenges in CPPSs, we introduce efficient updating and refac-toring operations for modularized type libraries. Our approach addresses the unique requirements of graphical development environments, enhancing the longevity and efficiency of software maintenance. The workflow of creating, maintaining, and up-dating library modules is outlined, along with conflict detection, error visualization, and potential refactoring/update operations. Additionally, we illustrate the architectural concept implemented as a prototype in an IDE. The implemented library management system demonstrates its practical application through a case study. This research contributes to the ongoing development of robust software maintenance practices in industrial automation systems.

Optimizing evolving manufacturing systems often requires considering the interplay of various architectural design decisions (ADDs), especially at the lower levels of the automation pyramid. Here, decisions about programmable logic controllers, stations, and shop-floor topology directly impact product characteristics. This necessitates a multidimensional design space exploration (DSE) approach that synthesizes diverse ADDs together. However, integrating diverse ADDs within the complex context of industrial automation remains a challenge, and existing DSE solutions from other domains often lack direct applicability. This work introduces a novel multidimensional DSE approach for such systems, leveraging domain-specific input models to automatically generate valid and optimal deployment, shop-floor topology, and production planning ADDs. We evaluate the approach by assessing the quality of derived ADDs against various domain optimization goals. This evaluation compares our approach to both random and manual ADDs, utilizing a prototype implementation and realistic manufacturing architectures.

Industrial-scale control software is designed as variability-intensive, i.e., highly configurable and adaptable software, to support diverse hardware capabilities and to fulfill diverse customer requirements. Various control software architectures have been proposed for developing highly configurable and adaptable control software. However, each architecture has its strengths and weaknesses in configurability and adaptability. Measuring the suitability of a given architecture to deal with variability can further guide control software engineers in implementing highly configurable and adaptable control software. In this paper, we propose measurement approaches for IEC 61499-based control software that indicate how well a particular architecture can manage variability. Control software engineers are first encouraged to describe all the functionalities in their system. They can also describe which elements must be added or removed when implementing a particular functionality. They then store these descriptions using a variability mechanism called delta models. Next, we can measure the size of delta models, the cohesion and coupling of the control software modules, and the degree of mapping complexity between features and delta models. We argue that by using our proposed measurements, we can indicate whether the control software’s architecture is suitable for variability-intensive software.

The field of industrial automation has witnessed a significant increase in software development and maintenance efforts in recent years. This can be attributed to the demand for shorter product life cycles and customized products, leading to increasingly complex applications. As a result, control software engineers are facing new challenges. In this paper, we present our tool for visualizing industrial automation software. It provides engineers with a unique perspective on their large-scale applications. The tool offers several benefits, including convenient tracing of control and information flow across multiple levels of hierarchy, applying metrics to the visualization, and various interaction methods. The tool is tightly integrated into an existing IDE, providing a unique workflow for software analysis and maintenance. We discuss the experiences of engineers of our industry partner, who have been using the tool, and next steps.

Software size and complexity in all kinds of domains increase rapidly in recent times, making software maintenance and reusability increasingly difficult. Analysis of existing software and subsequent re-modularization can help with these challenges. Although software re-modularization can be time- and resource-intensive, it can support engineers in improving the quality of their systems in the future. Code can contain certain patterns, such as code smells, that define some kind of problematic implementation that is usually inefficient and hinders future development. We explore the use of a semantic clustering algorithm, which aims to minimize the code smell "Feature Envy". We apply this algorithm recursively to create a multi-level hierarchy. With this approach, we explore the re-modularization of existing IEC 61499 control systems. First tests we conducted on example implementations of a capping station and a real-life-sized industrial control system show a significant reduction of Feature Envy and thus the coupling between modules using this approach.

IEC 61499 is a standard for developing distributed industrial control software. It supports the configurability of the control software as the application model is platform-independent and separated from the system model that defines the hardware configuration specification. Thus, it can be used to develop control software for highly configurable Cyber-Physical Production Systems (CPPS). To address their customers’ requirements, companies that build CPPSs over time develop many variants of such production systems, typically through clone-and-own reuse, which increases engineering and maintenance efforts. Managing the control software variability in CPPSs in a systematic manner would facilitate software reuse and reduce the cost of developing and maintaining these systems. However, the IEC 61499 standard itself offers only limited capabilities for managing variability, e.g., by utilizing a library of modular components or by following certain design patterns. In this paper, we propose an approach to systematically manage IEC 61499-based control software using a (textual) delta modeling approach. Delta modeling is a prominent concept in the Software Product Line (SPL) domain for expressing and maintaining software variability. We show how our delta modeling approach can express control software variability and provide a semi-automatic control software generator. We evaluate the usability of our approach by applying it to multiple case studies as well as by performing a user study, in which control software engineers used our delta modeling approach. Our evaluation results indicate potential benefits of our delta modeling approach to implement and maintain control software through software generation.

Engineering Cyber-Physical Production Systems (CPPSs) heavily relies on Domain-Specific Languages (DSLs), which are tailored to a specific class of problems inherent to CPPSs. DSLs enable non-programming experts to solve problems in their domain, such as modeling production processes, implementing control software, or managing the variability of production systems. A DSL ecosystem encompasses the entire infrastructure (e.g., libraries and tools) built around its language and contributes to the successful and easy adoption thereof by domain experts. We present a maturity evaluation model for DSL ecosystems serving two aims: to developers, it reveals missing but essential aspects of the ecosystem, and users (e.g., industrial companies) can evaluate the maturity of a DSL ecosystem. We propose criteria to evaluate the maturity of DSL ecosystems and apply them to existing, publicly available DSLs which have been adopted in CPPSs. The results demonstrate that all components of the model are covered and they allow for deriving hypotheses about DSL ecosystems used in CPPSs.

Analyzing and maintaining the quality of control software is pivotal in the plant manufacturing industry. During software development, certain negative patterns frequently occur. These negative patterns are called code smells and are characterized by code that is hard to understand, maintain or expand. One such smell is duplicated code, also known as clones. Clones often result from clone-and-own reuse, which is common in practice. Detecting clones is crucial to avoid bug propagation and keep maintenance efforts low. This work deals with detecting clones in control software written in the domain-specific modeling language IEC 61499.

Modern industrial automation applications require a flexible and modular software architecture that can be easily adapted to meet dynamic market requirements. The IEC 61499-based programming model, due to its distributed and modular nature, could be a potential tool in this regard. In our previous works, we proposed the concept of a PLC-Service bus, a service-oriented architecture-based control application development paradigm for the Programmable Logic Controller (PLC). We have also demonstrated its applicability using the IEC 61499 modelling language. In this paper, we propose an OPC UA-based configuration approach for software components of the PLC-Service bus.

The IEC 61499-based distributed control model is gradually gaining popularity among the stakeholders involved in the field of cyber-physical production systems. Integration of IEC 61499 with the Open Platform Communication Unified Architecture (OPC UA) will ease the effort required for horizontal as well as vertical integration of distributed control applications. In our previous work, we mapped the function block model and the application model of the IEC 61499 standard to OPC UA. This work-in-progress paper is intended to be an extension of our previous work that demonstrates the mapping of the resource, device, and the system model to OPC UA.

Software has become an integral part of production automation systems and it is going to play a key role in the realization of Cyber-Physical Production Systems (CPPSs), a software-defined futuristic smart production environment. However, the emergence of CPPS has led to the development of a new genre of software tools that aims to bridge the gap between the machine world and the software domain. Examples of such tools are Open Platform Communication Unified Architecture (OPC UA) based software applications that are seen as potential enablers for CPPS. Building OPC UA server applications for CPPS could pose multiple challenges which could be addressed using established software development approaches. In this paper, we investigated the well-known Domain-Driven Design (DDD) based software development concept and its applicability regarding the development of an OPC UA server application for CPPS.

In the domain of CPPS, long-term maintenance of software is necessary. Refactoring, a technique used to improve maintainability is a viable solution. However, there is a scarcity of research on refactoring in the context of CPPS. In this work, we propose a systematic approach for analyzing and deriving refactoring operations for IEC 61499. In particular, we propose a generic meta-model for block-based languages, which is accompanied by a corresponding generic refactoring catalog. Based on the generic meta-model, an existing refactoring catalog for IEC 61499 is extended by comparing and evaluating meta-models and their associated refactoring operations derived from literature of different modeling languages. We demonstrate that our approach provides a systematic way of transferring refactoring operations across block-based modeling languages and allows to extend existing refactoring collections for IEC 61499.

Cyber-Physical Production Systems (CPPSs) consist of deeply intertwined physical and software components. In the last decade, the number of mechatronic components (sensors, actuators, etc.) in a system is increasing enormously to enable more flexible, intelligent production with more support for customization. Mechatronic variability, like different variants of sensors or actuators in the system, directly affects the control software. The standardization of physical interfaces of mechatronic components has provided well-defined plug-and-play interaction. Conversely, software components in the CPPS domain still face the issue of standardizing functionality. Software adaptability often leads engineers to develop control software for new mechatronic variants by just copying and modifying existing software. This leads to multiple and completely separate instances of the control software and a high development and maintenance effort. The core functionality of the control software should be standardized and reused as much as possible to reduce the development effort and improve overall reliability. This paper discusses an approach to standardize core functionality of IEC 61499-based control software. Our design approach encapsulates the process core functionality and defines standard interfaces for interacting with mechatronic variant software components. We evaluate our design approach by comparing it to the traditional clone-and-own approach for an academic case study system, a capping station. Additionally, we assess the impact of adding a new variant in the control software and analyze what changes are needed to keep the same core functionality. When introducing new mechatronic variants in combination with standardized core functionality, our design approach reduces the overall control software variance and maintenance effort.

Cyber-physical production systems (CPPSs) are modern production systems that aim to integrate the latest techniques and technologies from IT to enable flexible/adaptive manufacturing. The IEC 61499 standardizes a domain-specific modeling language used for developing control software for distributed CPPSs. However, currently, IEC 61499 software misses concrete design guidelines, and those that exist are often not concrete enough to implement high-quality software, which makes changeability and refactoring error-prone and tedious. Furthermore, modularization and decoupling of hardware access and software functions are missing concrete design patterns. This paper aims to implement and test the concepts of skill-based design patterns for IEC 61499 for a concrete use case in a simulation. We employ a case study to demonstrate the approach’s feasibility, achieve the benefits of modularity, adaptability, and maintainability, and facilitate better error handling.

The rising complexity of modern production systems raises the need for evaluating the code quality also in control software engineering. Complexity metrics can help identifying code that is difficult to maintain and may benefit from a refactoring. Although complexity metrics have already been adapted to the domain-specific languages (DSLs) used for cyber-physical production systems (CPPSs), literature on whether developers benefit from using these metrics is limited. Also, the complexity perception of code by the domain experts remains to be investigated. The perceived difficulty of comprehending a program can vary among developers and also between different implementation variants of the same functionality. We therefore asked industrial experts, who have experience in the respective DSLs, to rate the complexity of semantically equivalent implementations to find out which metric best represents their complexity perception and whether there are differences between implementation variants. The examples used in the study were inspired, in parts, by an open source library for IEC 61131-3. We found that the Cognitive Complexity metric is a useful representation of the software complexity in the domain, as it best matched the domain experts’ perception of complexity. These metrics should therefore be supported by the analysis tools.

The complexity of Industry 4.0 systems makes it challenging to manually synthesize and optimize architecture-level decisions, such as service deployment and composition. To address this challenge, we propose an approach that utilizes a satisfiability modulo theories (SMT) solver to (semi-)automate service deployment and composition synthesis. Thereby, we conceptualize, formalize and implement the complete workflow from input service workflows to valid and optimized service deployments and compositions. We demonstrate the practical application of our approach in an Industry 4.0 scenario, specifically the flexible production of new products. We evaluate the effectiveness of the proposed approach by investigating its benefits in terms of engineering effort, complexity of the resulting IEC 61499-based applications, and improvement of communication coupling quality attribute (QA).

Design of manufacturing system involves various architectural design decisions (ADDs), including software and hardware component allocation, production service composition, plant layout determination, and production planning. These ADDs gain significance in Industry 4.0 (I4.0) scenarios due to the frequent need for architecture synthesis to achieve adaptable and flexible production processes. Additionally, synthesizing ADDs in conjunction with each other increases the decisions’ impact on system quality attributes (QAs). The increasing importance of architecture synthesis and optimization (ASO) in I4.0 necessitates an overview of ADDs within this context. This paper expands on the previous work by creating a landscape of I4.0-related ADDs based on insights from the BaSys 4.0 research project series. The landscape describes relevant ADDs and their relationships, and suggests multi-dimensional ASO workflows. Mapping the ADD landscape to BaSys 4.0 research enhances idea generation and the exploration of existing solutions in ASO.

Modeling distributed control software facilitates reacting to changing hardware configurations due to the higher abstraction level. Well-designed modules of such systems may be arranged flexibly to perform production tasks, which need to be adapted during the life-cycle of the system. Although IEC 61499 supports modeling the relations between inputs and outputs of its software components as service sequence models, these models are not integrated with the rest of the development process. In this paper, we outline our vision of using the captured information on the interface behavior for development tasks of distributed control software modeled according to IEC 61499. The proposed research directions can contribute to the acceptance of modeling methods in the domain, as appropriate tool support can notably leverage the benefit of models.

IEC 61499 is an executable, event-based language for control software that allows visual and textual implementation of individual software components (Function Blocks, FBs). The standardized visual service sequence model specifies the expected input/output behaviour of a component, thus supporting model-based testing. We present our approach for testing an FB on various platforms, which helps manage the variations in execution semantics between different vendors. First, service sequences are generated manually or derived from an existing (partial) implementation. Then, these service sequences serve as unit tests for this implementation. Finally, we create a test application that is executable on any IEC 61499-compliant platform. Executing tests directly in the target platform helps validate the correct functionality of an FB before deploying the control software to a cyber-physical system.

Bad smells are code patterns which have a negative influence on software, often impacting its quality and maintainability. Because of these negative effects, it is important to detect and avoid them. In the domain of software engineering, the topic of bad smells has been widely researched. On the other hand, in the area of industrial automation and PLC programming languages, bad smells have not received the same amount of attention. Shotgun Surgery is a code smell which we can find when a functionality is used in a certain number of places in code. It starts smelling when every change to the functionality requires many smaller changes to the places where it’s used. If we take a closer look at Shotgun Surgery in the domain of IEC 61499, we see that the general trend persists and that there is no adequate research done on it. In this paper, we want to identify Shotgun Surgery scenarios and showcase multiple existing and new approaches for its detection in IEC 61499.

Errors of textual programming languages are usually detected by the compiler. These errors are then visualized by the IDE and made available to the developer. This paper is intended to show a novel approach to also propagate errors in visual programming languages to the developer. We analyzed the visual block-based language of IEC 61499 and implemented an error visualization mechanism in the Eclipse-based IDE 4diac. As IEC 61499 is a Domain-Specific Modeling Language (DSML) that includes a type system, we also implemented a mechanism for detecting inconsistencies. With this approach, it is possible to work on broken applications, giving developers the opportunity to fix them in a graphical editor. Furthermore, inconsistencies that lead to errors are now displayed rather than being hidden from the developer and hard to detect.

The introduction of emerging technologies like the Internet of Things (IoT), Artificial Intelligence (AI), and Cloud computing have radically evolved the software architecture of the industrial automation domain. Future automation and control software systems require a flexible and open architecture. The IEC 61499 standard-based programming paradigm, due to its flexible and modular structure, is considered a potential tool for developing future automation systems. Therefore, integrating IEC 61499 standard with the Open Platform Communication Unified Architecture (OPC UA) could be beneficial as it will increase the applicability of the standard. However, no formal mapping between the IEC 61499 models and the OPC UA information model is defined by the OPC Foundation for now. Therefore, in this paper, a conceptual mapping between the models of these two standards is provided. The goal of this work is to develop an OPC UA companion specification for the IEC 61499.

To address current challenges of production systems such as increased number of product variants, batch size one, and shorter product life cycle, they need to be modular, loosely coupled, and more adaptable than ever. A PLC-Service bus architecture has been proposed to improve the modularity and adaptability of a PLC-software. The architecture enables software components of PLC-software to interact via middleware in a loosely coupled manner. Previous work identified a catalog of message integration patterns for PLC-software, and IEC 61499 was proposed to implement the architecture. The current version of the IEC 61499 standard does not fully support all message integration patterns from the catalog.Therefore, this paper first identifies suitable middleware technologies for IEC 61499 and, later, based on the requirements of the PLC-Service bus architecture, evaluates them to propose the suitable middleware technologies.

Cyber-Physical Production Systems (CPPSs) are complex, highly-configurable systems interacting with their environment by sensors and actuators. Software in CPPS typically exists in a plethora of variants, developed to fulfill customer and technology requirements, which have to be maintained over a long time. Support for variability management can foster systematic reuse and configurability, but this requires a significant investment of resources to explicitly document or model variability. Additionally, we need to define the reusable engineering artifacts and their variability corresponding to the documents or models. Furthermore, the documents or models need to be maintained and kept consistent with the artifacts evolving frequently. In this short paper, we propose to (semi-)automatically capture delta models describing differences be-tween CPPS control software variants and support generating these variants based on a product line platform. Specifically, we envision a change recording mechanism and model comparison approaches for control software developed using IEC 61499, a domain-specific modeling language used for developing distributed control in CPPSs. We argue that both approaches can significantly reduce the development and maintenance effort for delta models.

The history of the software industry has shown and proved that coupling and cohesion are a never-ending story in this industry. Quantifying the quality of software systems by measuring the strength of coupling and cohesion and considering it a rule that good software has low coupling between its parts and high cohesion within each part, is currently widely accepted. Every paradigm shift, new technology, language, etc. that didn`t consider this fact had to sooner or later leave this industry. It is, therefore, crucial to study and consider this fact in every new topic in the software industry. Surprisingly neither the IEC 61499 nor IEC 61131 communities have yet conducted a deep study to evaluate what coupling and cohesion really mean for Industrial Control and Automation Applications. We hope this paper will manage to fulfill this considerable gap, if not fully at least partially.

Coupling could be an arbitrary property to Industrial Automation and Control Systems (ICAS) with a significant impact on complexity. Different software design approaches may result in coupling between software modules that either increase or decrease the overall system complexity. This paper proposes using the Cynefin Framework to guide the software design patterns used during the high-level design of software architecture, with the intent of reducing components coupling and overall system complexity.

Modern production systems are constantly getting more complex and moving towards smaller lot sizes and more customizable products. This poses new challenges on the control software, which is growing in size and complexity. To deal with this increasingly large and complex control software, design guidelines are needed. We are working on such design guidelines for IEC 61499, a modeling language for distributed control systems. In our previous work, we proposed a distributed and highly reusable application design based on skills. In this work, we will present concepts for extending this design beyond normal operation handling.

Cyber-Physical Production Systems (CPPSs) are highly variable systems of systems comprised of software and hardware interacting with each other and the environment. The increasing integration of technologies and devices has brought an unprecedented level of automation and customization. At the same time, it has also increased the efforts to maintain highly complex and heterogeneous systems. Although engineering practices support the reuse of common components to ease the development and maintenance of the systems in different projects, the identification of common components is still manually performed, which is a time-consuming, error-prone task. In this paper, a novel approach identifying repeating patterns in CPPSs based on artificial intelligence techniques is presented. This approach allows finding exact and similar components to support the CPPS design. Furthermore, it enables the maintenance of common components by reusing predefined types thereby reducing development effort. We implemented and evaluated our approach in an industry case study on developing CPPS control software with IEC 61499.

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.

Bad Smells are sub-optimal software structures or patterns. They can obstruct the understandability of a software system and cause maintenance issues. As a result, it is critical to avoid Bad Smells. While the subject is well-researched in software engineering, it remains an unresolved issue in industrial automation, e.g., when developing control software in the context of a Cyber-Physical Production System (CPPS). In this short paper, we present possible detection methods for Feature Envy, a smell that indicates bad modularization of a software system. We explain how these methods can be applied to analyze control software developed in IEC 61499. We present first results as well as next steps.

This work analyzes the problems that arise in IEC 61499 development due to the fact that there are no ways of structuring type libraries. As a result of this analysis we derived requirements for integrating modules into the IEC 61499 specification. The modules that are portable among several runtime providers and vendors can be imported into IEC 61499 systems. Every module contains a set of function blocks that can be used inside the application. The proposed IEC 61499 module has its own version and namespace. It is also capable of defining dependencies on each other. Reusability from types can be increased by dividing the type library into several parts with the help of the proposed modules.

In recent years, the field of industrial automation is experiencing a dramatic increase of software development and maintenance effort. Driven by shorter product life-cycles and customizable products, production systems are becoming more and more complex, presenting new challenges for control software engineers. In this paper, we report on a visualization concept we applied to industrial automation software. It allows automation software developers to take a look at their software system from a new perspective. Various ways of interacting with the visualization offer further benefits, such as the convenient tracing of control and information flow across multiple hierarchies. We conducted a workshop with five industrial domain experts as a first evaluation of the usefulness of the visualization. Based on their feedback, we discuss open questions and next steps.

The software architecture of PLC-software has a direct influence on its adaptability, modularity, and flexibility. The software component (Program organization unit, POU) is the smallest unit of PLC-software that is responsible for providing certain machine functionality in an overall production system. The way these software components interact with each other has a significant role in the overall PLC-software architecture. To address current market demands, software components need to be atomic, modular, and loosely coupled. PLC-Service bus-based architecture enables such PLC-software. We are using this architecture as a basis. In this paper, we are evaluating available messaging interaction patterns from the enterprise IT domain. Our evaluation is based on requirements defined by the PLC-Service bus architecture. Therewith, we identified a list of interaction patterns that can be used to design interactions between software components in a PLC-Service bus environment. We use a reference production cell as a running example. To evaluate our findings, we first explain what the PLC-Service bus concept would look like for our running example. Later, we used four practical process scenarios from our running example to evaluate the applicability of identified messaging integration patterns for the PLC-Service bus.

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.

Modern production plants are complex Cyber-Physical Production Systems with an ever-increasing share of software controlling and automating their operation. The customization of these systems to the needs of their customers and their frequent evolution over a typically long life-cycle result in a plethora of variants to be managed. However, reuse still is mainly done in an opportunistic way, relying on copy-paste-modify strategies. More systematic, strategic reuse would help to reduce costs and time to market, but requires approaches that can be applied to domain-specific languages for developing distributed control software. In this paper, we propose an approach to manage variability in IEC 61499-based systems using delta-oriented variability modeling. We discuss open challenges and outline a research agenda for variability management in IEC 61499.

Refactoring is a key technology for improving the quality of a software system. A higher quality will lead to a clearer structure, which facilitates sharing work across multiple teams. This is important especially in the domain of cyber-physical production systems, where different engineering disciplines meet at their cutting point. IEC 61499 tries to abstract the increasing complexity of such systems. This work gives an overview of existing refactoring techniques from software engineering and provides a first insight on how to apply refactoring to IEC 61499 systems.

Bad Smells are certain suboptimal structures or patterns in software. They can cause maintenance issues and hinder understandability. Therefore, it is essential to avoid Bad Smells in software. While the topic is well researched in other fields, it is still an open issue in industrial automation. In this work, we are taking a step towards closing that gap and propose a catalog of IEC 61499 Bad Smells.

IEC 61499 emerged as a language for modeling distributed control systems. An Application is a platform-independent model that is comprised of modular components. High reusability of these components and high reconfigurability of the underlying system configuration can only be achieved with advanced design patterns. We show two example implementations of such designs and extended a pattern to foster reuse. All designs are compared based on a set of evaluation criteria. We show that our proposed design provides improved understandability and adaptability, while maintaining a slim library with highly reusable Function Block types.

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.

Industrial standards define domain-specific languages that are frequently used for developing control software. For instance, IEC 61499 standardizes a graphical modeling language that includes a platform-independent application model. The application is composed of Function Blocks. A runtime can execute the model by implementing the semantics that is described in the standard in natural language. By defining an interpreter for IEC 61499 models, we can directly execute them without prior code generation. This enables providing feedback directly on the model level. We present an interpreter for Basic Function Blocks, which encapsulate a state-based Execution Control Chart. An existing EMF meta-model for IEC 61499 was extended with an operational semantics implemented in Java and Xtend. The test cases are defined either in Java or as an interface model. Such a model is standardized in IEC 61499 as Service Sequences. We evaluate our interpreter by executing the Basic Function Blocks that are defined in the standard and compare our results to those of the open-source runtime 4diac FORTE. As a practical use case, we show how developers can use the interpreter for unit testing self-defined Basic Function Blocks.

The control software of manufacturing systems has to interact with the mechanical and electrical machine parts, hence, their engineering is closely interrelated. A high-level model of this system can provide an abstract view on the system's behavior and is therefore beneficial for any engineering discipline. The language GRAFCET was developed as a domain-specific tool for specifying the operation of a production system. GRAFCET models can be structured hierarchically to regulate the behavior of a subsystem with forcing orders and enclosing steps. Based on a Grafcet, control software can be implemented in the executable modeling language IEC 61499. In this paper, we describe a step-by-step approach for implementing hierarchical features of GRAFCET with IEC 61499 models. The resulting application is well-structured and thus maintainable.

automated Production Systems (aPS) represent a special type of mechatronic system characterized by a high complexity in hardware and software, lifetimes of up to several decades, and strong coupling of the involved disciplines, i.e., mechanics, electrics/electronics, and control software. Questionnaire studies have proven to be a valuable means of identifying obstacles in industrial software development that hinder the implementation of emerging technologies in the context of Industry 4.0 and, thus, the realization of Cyber-Physical Production Systems. However, the heterogeneity of different industrial sectors in terms of, e.g., the type of production processes or legal specifications, makes it difficult to compare the maturity of control software development across companies, even within the same industry. A software maturity benchmark for companies operating in similar industries is, however, a prerequisite for assessing a company’s strengths and weaknesses and thereby applying tailored solutions to improve the software and, thus, the competitiveness. This paper describes the results of a questionnaire study in two international companies operating in the same industrial sector. Specifically, location-, company-, and industry-specific maturity characteristics are analyzed and discussed, and it is concluded that the selected questionnaire is capable of identifying deviations and similarities in software maturity, even in an international environment, given that the companies are prefiltered based on the covered supply chain step. Hence, assuming a sufficiently large number of participants per industry, it enables a questionnaire-based industry comparison in future work, which was not possible until now.

Industrial control applications are usually designed by domain experts instead of software engineers. These experts frequently use visual programming languages based on standards such as IEC 61131-3 and IEC 61499. The standards apply model-based engineering concepts to abstract from hardware and low-level communication. Developing industrial control software is challenging due the fact that such systems are usually one-of-a-kind systems that have to be maintained for many years. These challenges, together with the growing complexity of control software, require very usable model-based development environments for visual programming languages. However, so far only little empirical research exists on the practical usefulness of such environments, i.e., their usability and utility. In this paper, we discuss common control software maintenance tasks and tool capabilities based on existing research and show the realization of these capabilities in 4diac IDE. We first performed a walkthrough of the demonstrated capabilities using the cognitive dimensions of notations framework from the field of human-computer interaction. We then improved the tool and conducted a user study involving ten industrial automation engineers, who used 4diac IDE in a realistic control software maintenance scenario. Our findings demonstrate how the usefulness of IDEs can be successfully investigated using a multi-phase approach that includes a walkthrough and a user study. We discuss lessons learned and derive general implications with respect to large-scale applications for developers of IDEs that we deem applicable in the context of (visual) model-based engineering tools.

Interoperability is one of the important characteristics of the cyber-physical system (CPS) based automation system. Engineers connecting field devices and control applications in an automation system regularly encounter interoperability problems. ISO/IEC/IEEE 21451 is a series of standard, which provide the building blocks to enable interoperability among field devices and control applications. transducer electronic datasheets (TEDS) are provided as a standard transducer description format by ISO/IEC/IEEE 21450. This format provisions the syntactic interoperability among heterogeneous field devices. However, open platform communication unified architecture (OPCUA) is a key enabling technology to achieve semantic and network interoperability. Therefore, the aim of this paper is to provide an integration approach for ISO/IEC/IEEE 21450 TEDS and devices in the OPCUA semantic model. We propose an ISO/IEC/IEEE 21450 based device integration concept with service oriented architecture.

Automation system engineering becomes more complex, due to the trend toward more flexible, reconfigurable, and modular design approaches, like Industry 4.0. For the modeling and design of the according software, two standards are present: IEC 61131-3 and IEC 61499. In order to satisfy the requirements for modern, large scale, highly distributed applications while also supporting still existing legacy systems, the demand for a combined development framework arises, where the best of breed tool can be chosen for a given automation task. Considering that, the IEC 61499 model is extended to allow the dual development and execution of IEC 61131-3 programs, and enabling easy and correct interaction between the two paradigms. In order to verify the validity of the chosen approach, an IEC 61499 development tool and a runtime environment is modified to support IEC 61131-3. A sample application is implemented, which comprises a pure IEC 61131-3 part with a 1 ms cycle time, a pure IEC 61499 part, and a part with interaction between both subparts, in order to evaluate possible interference between the runtime parts. Experimental results show that no interference is occurring, and the chosen development approach allows the seamless integration of IEC 61131-3 and IEC 61499 in one combined development framework.

How flexible and adaptive a production system can be, unquestionably depends on its software architecture and the level of modularity, flexibility, and adaptability of its software components. Programmable Logic Controllers (PLCs) are responsible for the functionalities of machines in the production system. Therefore PLC-software architecture and its software components play a vital role in a flexible, modular, and adaptive production system. In the current scenario, PLC software components use global variables to interact with each other to deliver certain machine functionality. Having global variables in PLC-software, increase hidden dependencies, reduces flexibility thus results in a less modular and less adaptable production system. In this paper, we are evaluating a service bus concept for modular and adaptable PLC-software that controls modular machines and production cells. As a result, a list of requirements for realizing such a concept is proposed.

Applying service-oriented concepts in industrial control and automation systems requires developing new architectural concepts to make it more adaptable to this context. In the scope of service-oriented systems one of the main challenges is defining the right granularity for every service in the system. This paper presents a systematic classification of methods to decompose the services. Identifying and using the correct granularity for each service is expected to lead to higher system flexibility, scalability, and in general to improving service deployment and maintenance. To find the best granularity for a service several approaches have been proposed, some of which are based on modeling and others based on service quality analysis. The approach we propose is based on modeling.

The search for making industrial systems smarter is a challenge present in the Industry 4.0 scope. In this new industrial era, the automation processes operate in a more flexible and adaptable way, even if there is a system fault. However, depending on the level of complexity of the system operation, faut diagnosis and fault handling procedures can become difficult to evaluate and implement, especially when it is necessary to integrate them into the control system. Based on this challenging scenario, this article presents RAFAH, a reconfiguration architecture for fault handling in industrial systems. RAFAH is composed by three operational stages that autonomously compute flexible fault tolerant control strategies, combining formal methods for faults diagnosis in discrete event systems, supervisory control theory's extensions for modelling and designing control systems, and IEC 61499 resources for developing distributable and reconfigurable applications. The proposed methodology is validated by a case study in a fluid mixing process in which it is applied to diagnose faults and provide a new control strategy.

A Grafcet is a standardized model for describing the behavior of systems which is popular among automation engineers. As the Grafcet standard excludes implementation details, the models are typically translated to automation software. Such software was traditionally programmed in one of the languages specified in IEC 61131-3. Nowadays, automation software is increasingly modelled in IEC 61499 which facilitates designing distributed control systems. In this paper, we define a standardized translation methodology, so that automation engineers can benefit from the advantages of IEC 61499 while continuing to use Grafcet. We discuss the differences between Grafcet and IEC 61499. We translated a Grafcet model into an IEC 61499 application to illustrate the process and derive guidelines for application designers. For the core concepts of Grafcet, we present the corresponding structure in IEC 61499.

This paper presents a work in progress on a modular architecture design of industrial HMIs. The proposed approach is based on a micro frontend architecture style for developing web applications. It allows developers and integration engineers to build an HMI from distributed and modular shop-floor components called micro frontend. Each micro frontend is end-to-end integrated from its data acquisition to the user interfaces. This approach introduces an agile and modular development style of an industrial HMI for a modular and adaptive production system.

When proposing new design patterns or design guidelines for IEC 61499 Applications, their performance and quality has to be compared to alternative solutions. Software measures are a way of achieving that. Although first attempts towards software measures for IEC 61499 were made, the standard still lacks a solid set of measures to evaluate applications. Taking a first step in that direction, we propose a set of measures for an IEC 61499 Basic Function Block.

Component-based software engineering has emerged as a principle of software design to facilitate reuse and improve the software quality. This principle is supported by the domain-specific language IEC 61499, where Function Blocks are fully encapsulated software components. For a Function Block definition, a static interface description and an internal implementation are required. Service sequences describe the event flow at a component interface and are an optional dynamic interface model in IEC 61499. In general, dynamic interface models are a powerful tool for various use cases, yet service sequences are rarely used in practice due to their low expressiveness. Therefore, we identify the domain-specific requirements for a comprehensive dynamic interface model and use them for our analysis of service sequences, where several issues are identified.

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.

Foreseeing a component based automation system architecture in the future, AutomationML consortium is developing a meta-model named AMLComponentMetamodel. The AMLComponentMetamodel defines different entities for modeling mechatronic aspects of an automation component in AutomationML. However, providing a methodology for using AMLComponentMetamodel for component oriented automation system engineering is beyond the scope of the AMLComponentMetamodel. We propose a novel methodology and modeling means for planning and engineering component based automation systems in AutomationML. A tool implementation demonstrate the use case of the presented methodology and modeling means. The discussion shows that our approach brings substantial improvement to the state of the art engineering process and simplifies the component based automation system engineering.

Technological progress leads to an increased utilization of data analysis and Business Intelligence that support manufacturing management decisions. Many promising solutions utilize semantic technologies. However, the deployment and maintenance of semantic technologies especially in reconfigurable manufacturing environments require a lot of manual effort. Concepts to embed them in an automated environment, as required by Reconfigurable Manufacturing Systems, are limited. In this paper, we present an approach to reuse systems engineering data to guide an automated process that updates a production data knowledge base. Thereby, an ontology that integrates distributed operational data to compute Key Performance Indicators such as the Overall Equipment Effectiveness index can be updated during the manufacturing reconfiguration process. This reduces the effort to handle the required changes of semantic data integration systems and enables a cost-effective adaption of the Business Intelligence for Reconfigurable Manufacturing Systems.

Plug & Produce is an important part of the 4thindustrial revolution (I4.0) that focuses on product development and production scenarios, demanding rapid adaptation to customer needs, with minimum effort, and no business interruption. Achieving this requires the use of flexible and agile automation systems. Microservices Architecture can be an opportunity to bring such flexibility and agility to industrial automation systems. Since Microservices Architecture is a new paradigm in service-oriented systems, an in-depth analysis from the industrial automation perspective is necessary in order to figure out why and how this new architecture could be helpful to build flexible automation systems. In this paper we first clearly describe and characterize the Microservices Architecture. We next discuss an existing paradox in microservice granularity, and suggest an approach to solve the mentioned paradox. Then we compare this new approach to the Service Oriented Architecture, highlight the key (dis)advantages of utilizing Microservice Architecture in building flexible automation systems that fits in 4thindustrial revolution needs, and describe the challenges to its future adoption.

The main challenge of exposing IEC61499 or IEC61131-3 Function Blocks as a service remains in adopting service-oriented concepts in function block programming. Implementing an IEC61499 or IEC61131-3 Function Block that is being accessed via service-oriented protocols is straight forward. The main challenge remains in modeling a Function Block as a service. Adopting service-oriented concepts like Service Oriented Architecture or Microservice Architecture requires tackling challenges like service granularity, (de)composition, etc. For instance, too coarse-grained services could lead to significant drawbacks, while too fine-grained services could increase the system's overall complexity, introducing semantic tight coupling and bringing about communication overhead. Therefore, understanding whether a service (de)composition is adding any value could help us to identify the best service granularity. Finding the best service granularity means knowing how many Function Blocks could be exposed into one service. This could undeniable lead to improvement in resource consumption especially in constraint environments. In this paper we design a cost analysis function for calculating the overhead of service decomposition. This work will help to answer one of the most important aspects of the service-oriented approach, called service granularity in the scope of Function Block as a Service.

Different causes have contributed to the shift of paradigm in the automation field from centralized to modular and distributable. Software and hardware of Programmable Logic Controllers (PLCs) have evolved to be synchronized with the demands nowadays and new standards are trying to follow this trend. One of them is the IEC 61499 standard, which is intended for modelling distributed industrial solutions with a vendor-independent format. This shifting is also bringing new challenges and this paper focuses on the virtual commissioning of plants, which can become a harder task when the system is distributed and involves different interconnected modules. A major problem when doing a virtual commissioning is the coupling between the different physical systems and controlling tools since many vendors still offer closed integrated solutions. Functional Mockup Interface (FMI) is a standard for a cosimulation interface which intends to fill the gaps between different modelling tools, by packaging the models into Functional Mockup Unit (FMU) and allowing a co-simulation master algorithm to have access to the inside model through the proposed interface. This paper presents a mapping between IEC 61499 models and the FMI standard and an implementation of a tool that can export IEC 61499 models into FMUs, which would allow the co-simulation of physical plants and the PLCs software that controls it. An experiment is shown where a simple Proportional-Integral-Derivative (PID) controller of a tank system is exported as an FMU and co-simulated together with a tank system modelled using OpenModelica.

The industrial automation systems are slowly changing from a centralized architecture to a modularized, system of systems architecture nowadays. Subsequently, there are efforts to replace the classical sequential plant engineering by systems engineering, where the distributed automation entities in a plant represent a system. Considering this revamp, we propose AutomationML based mechatronic models as an enabler for automation systems engineering. Aggregating requirements from a motivating example, a prototypical implementation of a mechatronic model in AutomationML and its potentials concerning automation systems engineering are presented. A use case and its evaluation is detailed where these mechatronic models are visualized for model-based automation engineering or re-engineering. Initial results and future directions are presented.

We have attempted to create affordable programmable logical controllers (PLC) that can be used to train millions of students in developing countries. Version 1 of the PLC is based on AtMega16 and costs 600 ($10). Using the free and open source software (FOSS) LD Micro, one can learn ladder logic. To enhance the capabilities, using Raspberry PI, Version 2 of the PLC, costing 1,500 ($25) is made. We can use this device with the FOSS OpenPLC to learn ladder logic. We can also learn function block based programming using the FOSS 4DIAC. As ladder logic and function block based programming are industrial standards, students trained using our approach will be useful to industry.

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.

Current industrial automation systems integrate structural information and component configuration data within the code of their programmable logic controllers. This prevents the demanded flexibility and adaptability of Industrie 4.0 systems. The asset administration shell provides a defined mechanism for finding, accessing and interpreting standardized and vendor specific data of an asset. Within this work the asset administration shell has been analyzed according to its structure, its location, and its implementation forms. Based on that a concept is proposed to provide event driven run-time access for components to the asset administration shell, which enables an automatic self-configuration infrastructure for component instances. The proposed concept is applied on the logistic part of an aluminium cold rolling mill, provided by the SMS group. For demonstration the structural information of the logistic components has been described in terms of an AutomationML file, which has been loaded into a BaseX Database. The database content represents the asset administration shell, which is accessed during runtime by XQuery requests.

The papers in this special section focus on information technology in industrial automation applications. Information technologies play a crucial role in the current and future developments of industrial automation. There are numerous strategic agendas on future manufacturing that have appeared recently worldwide and all of them emphasize the role of information technologies in automation in shaping up the future of production industries. For example, according to the German development agenda Industrie 4.0, the main driving force of the new industrial revolution is the Internet of things (IoT) and Cyber-Physical Systems (CPS). The IoT concept is becoming a major driver for many industrial applications. In manufacturing, it leads to flattening of the control pyramid, thus, increasing flexibility and enabling unprecedented level of production flexibility and adaptability, making it possible and feasible to produce products in smaller amounts, with shorter time to markets and higher economic efficiency. In the manufacturing environment, CPS comprise smart machines, storage systems, and production facilities capable of autonomously exchanging information, triggering actions, and controlling each other independently. The research community effort has been focusing on systems interoperability, performance, and efficiency of the design process, as well as assurance in the correctness of systems behavior.

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.

Nowadays it is desirable to operate flexible production plants, where products can be produced in various individual designs. As a result, more functionality needs to be integrated into existing control systems, which rapidly increases the complexity of the control applications and brings the programmable logic controllers to their limits. Unfortunately, control applications are hardly reusable for other platforms. Increasing the reusability of control applications is, therefore, an important task, which can be achieved by a strict separation of control logic and hardware configuration. Current standards lack this separation, as there is usually hardware dependent software on the application level. This paper introduces a generic device configuration model, applicable to common standards in the industrial automation domain. With this model, it is shown how to control applications can specify generic I/O requirements which are then linked to the specific I/Os during the final deployment of the specific control devices.

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.

As networks continuously grow (keyword Internet of Things) the configuration and management of industrial networks gets more complex. Additionally the trend towards Ethernet networks in the domain of industrial automation leads to the adoption of new Ethernet based technologies for factory automation. One of these technologies is Software Defined Networking (SDN), which provides a programmable and more flexible method for network control through an abstract network view. This work focuses on the evaluation of SDN in the field of industrial automation. It provides the implementation of a prototype SDN controller for direct multicast routing of industrial traffic in a cyclic switched Ethernet network using the Ryu SDN framework. For evaluation, experiments about the performance penalty introduced by switch-controller-communication are performed. An IEC 61499 compliant development environment is used for the experiment definition. The experiment results and the prototype implementation of the SDN controller showed that SDN provides great opportunities for a flexible and reliable network setup in the automation industry and is suited for real-time traffic.

The fourth industrial revolution introduced additional requirements on the industrial systems' control software in order to cope with current manufacturing systems' flexibility demands. These requirements include, among others, a dynamic reconfigurability, software reusability and an external service orchestration. This work presents the design of an industry 4.0 compliant control software architecture resulting from an iterative design process. The architecture is based on the reconfiguration services of the IEC 61499 standard and the service orchestration via OPC UA. We demonstrate the software architecture's compliance to the industry 4.0 requirements on an aluminum cold rolling mill plant demonstrator.

A technical plant behavior using a functional description forms the basis for common understanding of different disciplines and is used for the draft of hardware and software. Correlations between specific functions of the automation components and system can be allowed or denied in the behavior model describing the tended reaction. This contribution proposes an approach for modeling and verifying formal behavioral constraints of automation systems. The approach is realized either with finite state machines or with regular expressions. Furthermore, this work presents a methodology to convert verbalized constraints into finite state machines or regular expressions. The approach is evaluated by means of a pick & place unit.

Engineering and computer science have come up with a variety of techniques to increase the confidence in systems, increase reliability, facilitate certification, improve reuse and maintainability, improve interoperability and portability. Among them are various techniques based on formal models to enhance testing, validation and verification. In this paper, we are concentrating on formal verification both at runtime and design time of a system. Formal verification of a system property at design time is the process of mathematically proving that the property indeed holds. At runtime, one can check the validity of the property and report deviations by monitoring the system execution. Formal verification relies on semantic models, descriptions of the system and its properties. We report on ongoing verification work and present two different approaches for formal verification of IEC 61499-based programs. We provide two examples of ongoing work to exemplify the design and the runtime verification approaches.

Within the multi-disciplinary engineering process of a cyber-physical production system, the information about the plant is increasing steadily. Different departments work on separate domain-specific models and tools allowing a specialized view of the same system. However, data exchange and linking the heterogeneous information across domains is a critical issue. This paper investigates behavior modeling of automation components out of interdependencies coming from different disciplines such as mechanics, electrics, and software engineering. By this, the interlinking of the domain-specific models, as an enabling step towards early cross-domain validation and facilitated system evolution, allows a common understanding of the correct functionality of the system. The concept will be explained through the example of a pneumatic stopper and evaluated in AutomationML, an emerging standard in automation, to store and exchange artifacts between domain-specific engineering tools.

Technology trends and market changes force modern manufacturing companies to employ complex, standalone mechatronic components for automating their production. The complexity of mechatronic components induces adverse effects on their corrective maintenance. Handling downtime of these components requires knowledge of system composition, effect of external and internal disturbances on the component etc. Recognizing the human efficiency in industrial maintenance, this paper introduces a human centered corrective maintenance methodology for mechatronic components leveraging the cross disciplinary engineering data of these components. A 3D simulation model of the components' cyber-physical principles derivable from its engineering data is proposed for supporting the human doing maintenance action. A software intensive system architecture and application methods substantiating the concept are advocated.

Programming industrial robots requires experts -not only to create the robot applications, but also for changing them later due to different product requirements. Part of the reason for this is that all robot vendors provide their own robot programming language. Due to the language differences, robot applications cannot be reused for different robot types. Often, additional experts are required since one expert is trained only for a special robot type. This makes the use of robots uneconomical for small and medium sized enterprises. The ReApp project addresses this problem by providing a workbench based on ROS (Robot Operating System). A central part of this workbench is the skill and solution modeling tool, which allows the model-based design of robot applications composed of reusable components, and is described in this paper.

The commission and adaptation of modern automation systems is cost-intensive, error-prone and requires expertise. A large part is attributed to the engineering and programming process of manufacturer-specific components. Unifying the way of describing and controlling hardware results in a higher flexibility of the utilized hardware. This paper introduces a metamodel which allows a more efficient and flexible engineering of industrial automation systems throughout the system life cycle. The resulting model-based engineering approach utilizes highly abstracted models of automation components stored in the metamodel to form more specific models. By applying inheritance and classes, paradigms of object-oriented programming are followed to ensure better re-usability and interchangeability of modeled components. For evaluating the proposed concept the corresponding engineering data model is implemented in AutomationML.

For future manufacturing systems with a high variety in products and a dynamic production environment, concepts for adapting production are becoming more important. Errors in processes need to be detected quickly and a fast reaction is necessary to prevent failures. Minimizing production stops and swiftly getting back to production is one main goal. Manufacturing systems have to become more intelligent to be able to autonomously react on errors. We propose an approach for explicitly modeling error handling steps in production workflows and using these models to influence the production process. Depending on the type of error, different strategies for resolving the error are executed. The error handling is embedded into an autonomous planning architecture for adaptable manufacturing systems. The approach is evaluated using an experimental setup that is designed for educational purposes. The results are presented and discussed in this paper.

Adaptability and changeability are becoming the key features of future manufacturing. With adaptability comes a need to dynamically and frequently change factory topologies throughout the life-cycle of manufacturing systems. These changes are necessary to respond to changes in markets that result in new products, production volumes, and product variants. In addition to flexibly switching between different setups, the resulting schedules still have to be optimal to a certain extent to stay profitable. In this paper, we extend a capability-based planning approach to generate timed automata models that are used to solve the scheduling problem. The capability-based approach automatically generates an action sequence that defines all necessary production resources and operations for a product. The action sequence is then automatically transformed into models in UPPAAL - a model-checker for timed automata - and used to generate a schedule for production orders. The result can then be executed on the different production resources. An example scenario based on an industrial production system used for educational purposes shows the suitability of this approach.

We present work on extending IEC 61499 with behavioral types-based specifications. Identifying components and establishing interface specifications is already a key concept of IEC 61499. Components and their interfaces are a well established concept facilitating the development, maintenance, and refactoring of software systems. Behavioral types further extend the expressiveness of interface specifications by adding regular expression-based, protocol-like usages of components. We motivate the concept and focus on a particular application area: runtime monitoring of behavioral specifications in components. This allows us to catch deviations from specified behavior automatically in an already deployed system. We present the integration into the 4DIAC runtime environment using an example.

This paper presents ideas towards automatic monitoring of industrial automation devices by using a cloud based monitoring infrastructure. We are in particular aiming at fine grained timed properties that can be described using formal specification techniques such as behavioral types. Possible applications are in the areas of remote maintenance and servicing as well as commissioning and testing. Our work is based in the IEC 61499 standard.

To cope with the need for flexibility of industrial applications, and other customer related requirements, functional control behavior is shifted from hardware to software. This leads to higher software complexity. Therefore, testing of industrial software is a key technique to ensure overall system quality. Based on an analysis of testing approaches in software engineering and requirements in industrial automation system design with IEC 61499 function blocks a new unit testing process is proposed. The implementation of a platform independent test framework for IEC 61499 function blocks shows the applicability of the proposed testing process with representative examples. The presented solution is the first test framework based on the test first development approach to increase the software quality for industrial automation systems.

Future manufacturing systems have to be more adaptable to be able to compete in fast changing markets and address specific customer demands. To increase adaptability of production systems, the software and communication infrastructures have to be adaptable as well. Current communication paradigms tightly couple manufacturing systems to communication infrastructures. Changes in the manufacturing system require manual reconfiguration of software and communication infrastructure. In this paper we define the requirements for future adaptable manufacturing systems. They have to be loosely coupled, dynamic, adaptable, and capable of plug & play. We also propose a data-centric approach to make communication systems more adaptable. Using a simplified industrial setup, we show that the approach is feasible for manufacturing systems and increases the adaptability.

Manufacturing enterprises can only stay profitable if they manage to flexibly respond to changes in markets by adapting their products, product variants, and product volumes. To support such variety in products, we suggest a capability-based approach for production planning and scheduling. Production plans and machines are described in terms of required capabilities and provided capabilities respectively. Additionally, the topology of the factory is described. We propose to combine these descriptions to automatically generate production schedules that consider the material flow in the factory. For each production plan, our approach generates a valid schedule for the currently available machines in the factory without manually reconfiguring the software. The evaluation of the approach on an industrial production system used for educational purposes shows the suitability of this approach.

In order to cope with changing markets and reduced product life-cycles production systems need to get more adaptive and allow to easily introduce new products and product variants. Current solutions require that all control equipment need to be modified in such cases. In this work we propose a different approach with a strong separation of basic control of production resources from product specific behavior. The product specific behavior is managed by a central control entity which sends parts of the execution tree required for a certain to thin controllers managing the production resources. With this approach we can on one hand achieve the needed flexibility and at the other hand side achieve the timing requirements of production.

This special issue - organized by the IEEE SMC TC on Distributed Intelligent Systems - targets recent research results, trends, and practical developments of distributed intelligent systems that accomplish advanced tasks in the industrial areas of manufacturing, power and energy, and logistics. Five high-quality contributions to this special issue have been selected in a strict peer review process supported by reputed international experts. Three submissions focus mainly on technical aspects related to the design, development and validation process of distributed, intelligent automation systems, whereas the other two papers treat application-related topics.

Classical programming approaches are no longer enough to implement and integrate evolved control software for Industrial Automation Systems (IASs). The multidisciplinary implementation of increasingly-sophisticated IAS capabilities makes developers look for more effective methodologies to efficiently design, build, and evaluate such software. This paper identifies gaps in the development process of IASs. Filling these gaps can help improving the coding of IAS control applications by overcoming current development limitations. This paper argues for a requirements-driven development process and an interactive integration framework to mitigate drawbacks set by engineering tools. It shows gaps given by what current tools can provide and what is needed.

In order to cope with the upcoming demands for flexible adaptive production system a new architecture for industrial automation systems has been introduced called IEC 61499. Up to now no monitoring and debugging infrastructure has been defined for IEC 61499 although, this is a key feature for industrial automation systems as break downs and unexpected standstills needs to be solved immediately. To improve this situation this work evaluates whether existing IEC 61499 means can be used for monitoring and debugging. As existing means are either not powerful enough or not suitable for small embedded control devices a new monitoring and debugging approach is developed. The developed infrastructure has been implemented as part of the 4DIAC open source framework. Testing the new monitoring and infrastructure showed that it is capable of fulfilling the requirements and that it greatly improves distributed control system development.

The objective of this paper is to propose a methodology for strictly separating fault detection and fault handling methods from control code in discrete manufacturing systems. In order to enable the separation, two different design patterns are elaborated. Based on an analysis of typical faults in manufacturing systems, a library of reusable function blocks for fault detection, handling, and also fault recovery is developed. These function blocks are implemented according to the international standard IEC 61499 and are applied within the design patterns. The design patterns are evaluated with the sequential control of an injection molding machine. It is shown, that the design patterns simplify the engineering and the separation of the fault detection and fault handling from control code significantly, since they provide clear design rules. Applying the proposed design patterns reduces the complexity of industrial control applications drastically. Furthermore, the function block library provides reusable and proven fault detection and fault handling methods.

Current engineering tools for control software development of Industrial Automation Systems (IASs) are no longer capable of dealing with the architectural demands they entail. Increasingly-complex control software architectures make developers look for more efficient modeling methodologies to deal with such complexity. This paper discusses modeling gaps by focusing on the requirements analysis and architectural/detailed design stages of the IASs. It argues for having a good requirements notation on models to order to lead developers to end up in right control software for IASs. Following this hypothesis, the objective of this paper is to review existing modeling methodologies and technologies for control software architectures from factory automation and high-integrity systems. Thus, weaknesses and strengths can be identified in the industrial automation domain but also modeling capabilities from other domains can be added. This paper reveals modeling gaps given by what current approaches can provide and what is needed. It also discusses a mitigation way to close the above gap.

Behavioral event contracts constrain the ordering of input events received and possible output events returned from a software component. Interface automata as introduced by de Alfaro and Henzinger are a light-weight formalism that allow capturing such temporal aspects of software component interfaces and the associated theory allows answering such fundamental questions as interface compatibility, component composition, and refinement. The work presented in this paper applies the results from the theory of interface automata in a hierarchical design and verification approach for IEC 61499 automation solutions. IEC 61499 adapters and service sequences are used for specification of rich behavioral component interfaces. In this approach, components are built hierarchically in master-slave arrangements where each component defines a provided interface contract for its upper-level and specifies required interface contracts for its subcomponents. Verification methods allows verifying if a component uses all its subcomponents according to their contracts, allows checking if a concrete component satisfies a given contract, and allows computing an abstraction of a component representing its externally visible behavior.

A higher flexibility and adaptability in industrial automation systems is an important requirement which has to be addressed in industrial systems today. New software architectures for the corresponding control environments allowing to develop modular and reusable code, are necessary. The IEC 61499 standard was especially developed for distributed industrial automation systems addressing such needs but its realization and the provision of corresponding software tools can be cost intensive. Using open source developments can provide helpful benefits. This paper therefore investigates the usage of the IEC 61499 compliant open source environment 4DIAC for developing modular and reusable control code. Moreover, future improvements are identified in order to enhance its usability for industrial automation applications.

This article presents a new formal approach to validation of on-the-fly modification of control software in automation systems. The concept of downtimeless system evolution (DSE) is introduced. The DSE is essentially based on the use of IEC 61499 system architecture and formal modeling and verification of the hardware and software of an automation device. The validation is performed by means of two complimentary techniques: analytic calculations and formal verification by model-checking.

The IEC 61499 modeling language pursues a component-based approach with modular building blocks coupled by ports and arranged in a hierarchical manner. Like similar approaches, the IEC 61499 language does not define how functional hierarchies of upper- and lower-level functional entities should be built. In this paper we outline structuring principles for IEC 61499 programs with purely hierarchical control architectures. We present elementary design guidelines for structuring automation solutions in several hierarchical layers, outline which elements of the IEC 61499 language to use, discuss patterns that arise when implementing hierarchical control solutions, and illustrate the approach with a case study.

Reusability of control code is crucial for future industrial automation in order to allow the development of high quality control systems in less time and with less cost. A key stopper for automation software reuse is the current intertwining of control logic with hardware specific code. Existing approaches that tackled such a problem could lead to improvements but will not sufficiently solve this issue. In this work we investigate a concept based on a logical grouping of I/Os to so called Instrumentation- and Control-Points and decoupling them from the control application by applying IEC 61499's adapter concept. In two industrial motivated application examples we show that this concept fulfills the requirements for increasing the reusability of control code by separating control logic from hardware specific code. Moreover, it leads to a better application software structure which is easier to maintain and to understand.

Automation systems (ASs) based on Service-Oriented Architecture (SOA) are becoming more wide-spread. Due to their inherent property of separating the hardware-specific implementation from the logical work- or control-flow, SOA-based application programming is regarded as the next logical step in AS programming. Several successful attempts for implementing SOA-based AS have been made, but always with non-industrial, non-standard software like Devices Profile for Web Services. Based on the requirements of typical industrial SOA-based AS application, we will show that the industry standard data acquisition software OPC Unified Architecture is capable to serve as a SOA-based middleware.

The effort for design and implementation of process automation systems increases with the complexity of modern production plants. To shorten the implementation phase we propose a conceptual approach for automated code generation for programmable logic controllers (PLCs) based on knowledge acquisition from standardized engineering artifacts and their corresponding tool database. Ontologies are defined for each engineering domain artifact, representing the concepts and relations specified in the associated domain standards. An automated data extraction and population of the domain-specific ontologies together with semi-automated mapping definitions between common engineering objects then enables a rule-based code generator to query the ontologies. The query results are translated afterward into PLC code by applying a rule transformation algorithm.

Modern automation and control systems used in industrial large-scale applications are characterized by its distributed nature in the areas of power and energy systems, manufacturing, building automation, and logistics. In order to cope with different communication needs and changing requirements in such large-scale scenarios over its life-time, the main aim of this paper is to propose a programmable and (re-)configurable communication gateway device compliant to domain standards. This approach is therefore based on the IEC 61499 reference model for distributed and reconfigurable automation and uses the service interface function block concept and highlevel communication patterns to achieve a hardware-independent access to communication services. Moreover, the utilization of the IEC 61499 management model supports the possibility of the online-reconfiguration of communication links and therefore provides a very flexible structure and implementation for an industrial automation gateway device.

In the field of industrial automation systems software becomes an important factor because engineers tend to move the realization of functional requirements from hardware to software components. The main reason for this is that software components allow increasing product flexibility. As a consequence software complexity increases rapidly and requires systematic, automation-supported and agile testing approaches. Thus, systematic and agile testing are key challenges in industrial control software development to ensure and improve systems quality. Further different implementation standards, i.e., IEC 61131-3 and IEC 61499, arise additional challenges in constructing and testing industrial automation systems software. This paper presents an agile and keyword-driven test approach with focus on testing implementations based on both important industrial standards and illustrates the applicability of the purposed approach in a sample implementation, i.e., a High Speed Pick and Place unit. Main results show the applicability of keyword-driven testing based on a defined subset of keywords (common for IEC 61131-3 and IEC 61499) and thus enable agile and automation-supported testing more effective and efficient.

Existing industrial automation projects require automated methods for faster changes and updates as well as continuous improvement and maintenance. Software Engineering uses Model Driven Development to shorten the development time by keeping documentation, models and code consistent during the whole development time and by using code generators to create many similar code artifacts and code for different platforms. To make this concept also available for automation projects we present an IEC 61131 model based on the Extended Backus Naur From provided by the standard. For the proposed IEC 61131 model also related application areas are outlined.

An increasing number of functionality in today's machine and plant automation is being shifted from pure mechanics or electronics into software. Therefore the system behavior must be checked for compliance with the demanded software functionality by software tests. The precondition for test case execution is a start state, the system has to take in. In order to evaluate the testability of a system, it must be verified whether the test case triggering system state is reachable. We propose a transformation approach of the control software model and the corresponding environment model (physics) to timed automata for model checking to exploit the power of the query language Timed Computation Tree Logic for start state reachability analysis. The applicability is demonstrated on a laboratory plant.

Future automation systems exhibit a growing demand for downtimeless evolution. There have been already several approaches for this so called online change but most of them are manly designed to work within a device. The increasing distribution of automation systems needs an efficient mechanism for downtimeless reconfiguration even if the change affects more devices. So this paper will show an approach how this distributed online change can be done for IEC 61499 systems. Distributed reconfiguration needs a synchronisation of the involved devices which will be done in this approach by synchronised clocks. The basis for this paper builds an existing approach for downtimeless reconfiguration (eCEDAC-Approach) which will be extended to get an efficient mechanism for distributed online change.

Operating industrial plants at their maximum energy and resources efficiency often means to operate them close at their design limits. Due to strict safety and process parameter constraints, it is challenging to control them close to the optimal setpoints. Currently process performance improvement projects are realized by application of PC based model predictive controllers as add-ons. Applications of up-to-date optimizing control algorithms are characterized by high requirements on software architecture, numerical computing power and realtime behavior. These requirements are not accomplishable running optimizing control algorithms on Programmable Logic Controllers (PLCs) by current available software architectures. Therefore the aim of the Embedded Energy Efficiency Industrial Controller Platform (E3ICP) project is the development of an infrastructure for running state-of-the-art model predictive controllers on industrial embedded PLCs.

Nowadays the design and configuration of control applications is traditionally done manually once for a designated system layout. Manufacturing components, which autonomously embed themselves into the existing control system without requiring extensive human involvement, are regarded as vitally important to achieve more flexible and reconfigurable manufacturing systems. In this paper we investigate the feasibility of an automated configuration of the hardware-near control application for physical manufacturing components based on agent technology. We employ automation agents, which have an ontological representation of the physical components they control. Based on this knowledge, the agents use a reconfiguration infrastructure for control software based on the standard IEC 61499. Using our approach, the hardware-near control application does not have to be designed and instantiated manually as this is performed automatically.

The reconfiguration of control software is regarded as an important ability to enhance the effectiveness and efficiency in future manufacturing systems. Agent technology is considered as a promising approach to provide reconfiguration abilities, but existing work has been focused mainly on the reconfiguration of higher layers concerned with production scheduling and planning. In this paper, we present an automation agent architecture for controlling physical components that integrates “on the fly” reconfiguration abilities on the low-level layer. Our approach is combined with an ontological representation of the low-level functionality at the high-level control layer, which is able to reason and initiate reconfiguration processes to modify the low-level control (LLC). As current control systems are mostly based on standards and principles that do not support reconfiguration, leading to rigid control software architectures, we base our approach on the promising Standard IEC 61499 for the LLC, extended by an innovative reconfiguration infrastructure. We demonstrate this approach with a case study of a reconfiguration process that modifies the LLC functionality provided by the automation agent of a physical component. Thereby, we obtain the ability to support numerous different LLC configurations without increasing the LLC's complexity. By applying our automation agent architecture, we enhance not only the flexibility of each component's control software, but also achieve the precondition for reconfiguring the entire manufacturing system.

The standard IEC 61499 claims to be a standard for a distributed control environment consisting of a set of heterogeneous control devices from different vendors. Previous work on the implementation of IEC 61499 pointed out ambiguities in the standard, resulting in different execution behavior of IEC 61499 elements on different control devices. One of the key deficiencies is the lack of a definition for execution models of the device, the resource, and the function blocks. This paper discusses different design and execution issues related to the aforementioned problems for IEC 61499 distributed automation and control systems.

In the design of plants and machines the complexity is permanently increasing. Model-driven design methodologies in the field of Industrial Automation and Control Systems, as proposed by the MEDEIA project, help to cope with current requirements like limited budget and reduced ramp-up time. Concurrent development in all involved domains is facilitated by the introduction of simulation in the development process. We propose the use of an IEC 61499 industrial automation runtime environment to simulate plants' behavior. The concept for the simulation framework is based on the coupling of the control application and the plant simulation application via Instrumentation and Control points. The introduction of physical links in the plant simulation application enhances the behavior model of the plants, thus increasing the quality of the obtained simulation results.

Current component-based approaches for distributed control systems enable the reuse of mechatronic components, for example specific grippers or conveyor belts, but do not allow full application reuse as the actual hardware configuration is an implicit part of the software solution. In contrast to the current object-oriented or component-based engineering models for automation engineering, this paper will introduce a new Model-Driven Architecture based application and hardware modeling approach. Through separation of the logical application domain and the specific hardware domain the logical application is completely independent of the concrete physical plant configuration. Therefore development time for automation applications can be vastly reduced and software quality can be improved.

Traditional fault detection systems in industrial control applications are just able to report occurring faults. Fault diagnosis systems are more desirable for plant operators, as such systems are capable to reduce the number of occurring alarms by elimination of consecutive alarms and prioritization of critical alarms. The disadvantage of those systems is that they have to be implemented anew for every control application, as the system dependencies vary from application to application. Ontology-based fault diagnosis systems do not have this disadvantage. Only the ontology has to be created for the new system, which greatly reduces time and effort for new systems, as old ontologies can be reused for the new system.

During the last decades production automation research has been focused on improving the flexibility and adaptability in order to cope with the arising challenges of mass customization. Much work was devoted to the higher-planning and scheduling-levels of automation systems. However, the lower level real-time control infrastructure was widely neglected. Therefore, we are currently faced with an adaptive flexible high level control connected to a rigid low level control. This work presents a dynamic reconfiguration architecture for the low level control of industrial automation systems. This architecture allows to reconfigure real-time control applications during full operation of the controlled plant. In an example implementation we prove that this is also possible on small embedded control devices as they are typically used as field devices in industrial automation systems.

In order to succeed on the ever-changing conditions on the global market, industrial companies have to rely on flexible production systems. Concerning automation systems, distributed solutions offer more flexibility than rigid centralized control software architectures. IEC 61499 introduces suitable models for the design of flexible distributed control software. Evidently, it was not designed for realizing the functionalities of a batch management system that incorporates for instance the creation and maintenance of recipes. Therefore it is of importance to show its usability in conjunction with a batch management system. This paper presents the implementation of a distributed control system based on IEC 61499 in conjunction with the commercially available batch management system FactoryTalk Batch.

This paper provides a possibility for a semantic correct transformation of existing IEC 61131-3 projects into the newer IEC 61499 standard. Based on a model driven development approach as well as proper concepts and rules this paper describes a suitable way to overcome some semantical problems which occurred during the transformation process. Those semantical problems regard some differences between the libraries of IEC 61131-3 and IEC 61499 as well as the extraction of the actual execution sequence of IEC 61131-3 programs. Both issues are supposed to be solved by auxiliary transformations. One static transformation which converts IEC 61131-3 function blocks into simple function blocks. And one project dependent transformation which extracts the execution order of IEC 61131-3 function block networks.

Production systems will become increasingly complex to handle flexible business processes and systems. Engineering systems and tools from several sources have to cooperate for building agile component-based systems. While there are approaches for the technical integration of component-based industrial automation systems, there is only little work on the effective and efficient integration of engineering tools and systems along the automation systems lifecycle. In this paper we introduce the concept of the ldquoautomation service busrdquo (ASB) based on technical and semantic integration concepts for general software engineering tools and systems. Based on real-world use cases from automation systems engineering we discuss the state of the art, innovation benefits and limitations of the ASB concept, and derive research issues for further work.

Today's automation systems are increasingly composed of heterogeneous distributed components. The components of such systems communicate via different protocols and need to provide a pre-specified quality of service (QoS). For modeling such distributed applications new concepts like the standard IEC 61499 are available. But IEC 61499 does not sufficiently cover the description of the communication properties between subcomponents. However the architecture analysis and design language (AADL) seems to allow sufficiently formal modelling of communication parameters and QoS parameters. This paper compares the application modelling with IEC 61499 and AADL on the basis of a simple example and shows an approach how to map IEC 61499 applications to AADL. Both contribute to derivation of communication links between reliable distributed real time components automatically out of a system independent application description, a system description and mapping parameters.

Developers maintaining distributed control systems are facing significant problems when dealing with changing customer requirements during the development and operation of industrial production facilities. Research has so far largely focused on implementation-level engineering challenges. Model-driven approaches are seen as promising for dealing with the increasing complexity of adapting distributed control systems. We present an approach for capturing architectural variability of distributed IEC 61499 automation and control systems based on product line variability models. Our automated approach supports decision-driven derivation and adaptation of systems at runtime.

Adaptive manufacturing is one of the most important objectives of the MANUFUTURE technology platform. To realize the vision of zero downtime, automation and control systems that react robust on system faults and changes by reconfiguration need improvements, mainly on the control and software level. A reconfigurable manufacturing system has the ability to easily and repeatedly change its structure by adding or removing hardware and/or software components in order to optimally adapt to fast changes in product requirements. This paper presents an adaptive and reconfigurable control framework which enables production systems to react more flexible on changes in the product demands. Concepts and requirements that will be needed for such a framework will be highlighted. Furthermore, a first approach for a control framework will be presented.

The aim of this paper is to describe a research roadmap for a multi-domain model-driven embedded systems design approach and the corresponding meta-model which is applicable to the domain of complex Industrial Automation and Control Systems (IACS). The special requirements of the industrial automation sector are taken into account by this novel approach, utilizing existing model-driven techniques. This approach is currently being developed in the Framework Seven (FP7) Embedded Systems Design project MEDEIA funded by the European Commission.

This paper provides a possibility to convert existing IEC 61131-3 projects into the newer IEC 61499 standard and therefore offers the use of its modern concepts also for the currently applied standard. Based on a model driven development approach as well as proper concepts and rules an implementation method for a transformation of IEC 61131-3 into IEC 61499 is presented. The transformation process is realized through an IEC 61131-3 and IEC 61499 compliant engineering environment. And an appropriate example model is provided by an IEC 61131-3 convenient development tool. After the transformation an available IEC 61499 development tool is used to check the transformation outcome.

A unified configuration interface is an important requirement for a heterogeneous distributed control environment as defined by IEC 61499. Most of the current IEC 61499 implementations solve this problem through the use of XML. Although XML is flexible, extensible, and human readable it has the main drawbacks of a great overhead and that it is elaborative to parse. A binary XML representation promises to reduce the overhead and ease the parsing process and therefore allowing to be used on small embedded control systems. This work applies three common binary XML formats to the configuration interface of IEC 61499 and compares their characteristics.

Flexible production systems represent key commodities for industrial companies in order to successfully persist on the global market. Batch processes and modifiable recipes already provide a certain flexibility concerning the design of production processes. However, the employed automation systems demonstrate deficits concerning reconfiguration and reusability. IEC 61499 introduces new paradigms to the automation domain by offering generic architectures suitable for reconfigurable distributed control systems. This paper introduces an engineering method for process automation using a component based design and applied industrial standards to show the feasibility and benefits of designing a distributed control system based on the standard IEC 61499.

The automation of plants and machines is becoming more and more complex due to the extensive usage of intelligent field devices as for instance programmable actuators and sensors. The graphical programming languages used are typically for the automation domain, and control applications tend to be become increasingly complex which results in higher engineering costs for establishment and maintenance. The new IEC 61499 standard for distributed control systems provides an interesting engineering concept called subapplications. This concept has, in principle, the potential to provide a cost-effective solution for industrial automation applications, but is currently only being used in a few instances. The goal of this paper is to introduce a simpler, more effective, engineering approach to structure large scale distributed control programs based on a hierarchical plant structure model together with IEC 61499 subapplications.

Frequent changes in the production requirements demand for improvement of adaptation and modification ability of production systems. To address these requirements we propose a concept and system architecture in order to provide the reconfigurability of machine tool systems in assembly shop floor. This approach allows machines and plants to flexibly adapt themselves to changing demands and interact with each other to fulfil the overall goal. Through reuse of components, their ontology-based interaction in a multi-agent architecture as we propose the time for design and building of manufacturing systems can be reduced.

Over the last decade the automation industry has experienced a huge growth worldwide but the major automation markets are still in Europe and the USA with the highest absolute growth as some recently published studies show. In order to better determine the future technologies the European automation industry attempt to adopt in the next years, we conduced 2005 a trend study with the name "Trend Study for the Identification of Application Domains for Distributed Automation". Main propose of this survey was the identification of applications, key product and services requirements which can provide a basis for our future research issues in our core technology the distributed intelligent automation. The study has shown that the European automation industry has a big interest in distributed intelligence in automation technology particularly in the modular systems and machines applications and logistic system applications. But for the success of this technology following requirements should be fulfilled: (1) it has to lead to a major customer cost benefit and (2) advanced engineering tools are necessary to hide the complexity of distributed systems. In general this segment of European automation market waits for a sign from a global player.

This paper presents a methodology for the characterization of an IEC 61499 runtime environment by use of a benchmarking procedure. Due to the usage of IEC 61499 for low-level control as well as the paradigm of application centered engineering1, it is necessary to describe the capability to execute IEC 61499 function block networks. There are two most characteristic items that need to be taken into consideration: the execution of a basic function block and the execution of function block network structures. The adaptability of the presented methodology is demonstrated on two different runtime implementations.

In today's globalized markets the manufacturing industry in traditional high-wage countries highly depends on flexible and automated manufacturing systems to remain competitive. State-of-the-art industrial control and automation systems do not sufficiently solve the problem of downtimeless reconfiguration of control applications. This paper presents an approach for structured modeling of controlled reconfigurations of control applications based on IEC 61499. The reconfiguration process itself with this paper defined as evolution allows close interaction with applications or physical processes while modeling knowledge from control engineering is reused for evolution engineering. An example points out the evolution engineering process as well as the benefits of this new approach.

The ever increasing complexity of manufacturing systems demands for new real-time control infrastructures. With the new standard IEC 61499 the IEC introduced a base for such a control infrastructure. An open issue of this standard is the missing definition of real-time execution. Based on existing real-time execution theory different execution models for real-time execution of IEC 61499 control applications are analyzed in this work. A novel execution approach for an efficient execution model is presented. This new approach would serve as basis for a new IEC 61499 execution environment

The new reconfigurable manufacturing paradigm requires development of systematic methods, and software tools, for the rapid design and builds up of production systems that change the capacity and functionality in response to the market demand. The effectiveness of reconfiguration depends upon the development of such tools. In this work, the new concept consisting of ontology knowledge based systems in connection with software agents are applied for the solution of the reconfiguration problem. Reconfigurability is achieved by the employment of the most modern technologies such as ontology driven solution