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.

Smart manufacturing systems adapt to changes in the environment, which are detected via sensors. Decisions are then made by the control software of such manufacturing systems, e.g., by integrated AI-based algorithms. The design and evaluation of such algorithms require the availability of high-quality datasets. This paper provides an overview of the existing publicly available manufacturing datasets, offering a detailed exploration of the current landscape of shared data resources in the manufacturing sector and highlighting the utility of these datasets. The review identifies nine notable datasets with extensive documentation and comprehensive data coverage. Each of these datasets is described in detail and can be used for developing intelligent manufacturing systems, assessing their quality, and reporting on open gaps.

Control software for production systems is typically developed by domain experts, despite its high complexity. The increasingly available Large Language Models (LLMs) can assist developers with code generation and debugging. However, their suitability for generating control software for production systems is still unexplored. Therefore, this study explores the generation of Structured Text (ST) according to IEC-61131-3 by different LLMs. We selected 21 coding examples that are representative of PLC programming and developed an approach for comparing the outputs of different LLMs using metrics for testing generated code (CodeBERTScore, pass@k, generation time). The strategies for prompt optimization that were developed as part of this work can be directly used for improved ST generation. Our results show that, at the time of the study, ChatGPT-4 had the highest reliability in generating syntactically correct ST code that expresses the desired functionality.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.