Daedalus is conceived to enable the full exploitation of the CPS' virtualized intelligence concept, through the adoption of a completely distributed automation platform based on IEC-61499 standard, fostering the creation of a Digital Ecosystem that could go beyond the current limits of manufacturing control systems and propose an ever-growing market of innovative solutions for the design, engineering, production and maintenance of plants' automation.

Nowadays an increasing number of industries are considering moving towards being Industry 4.0 compliant. But this transition is not straightforward: transfer to new system can lead to significant production downtime, resulting in delays and cost overruns. The best way is systematic seamless transition to newer and advanced technologies that Industry 4.0 offers. This paper proposes a framework based on automatic synthesis methods that learns the behavior of an existing legacy programmable logic controller (PLC) and generates state machines that can be incorporated into IEC 61499 function blocks. Proposed algorithms are based on Boolean satisfiability (SAT) solvers. The first algorithm accepts a set of noisy PLC traces and produces a set of candidate state machines that satisfy the traces. The second algorithm accepts error-free traces and synthesizes a modular controller that may be distributed across several physical devices. The toolchain architecture is exemplified on a laboratory scale Festo mechatronic system.

Today, more and more industries are considering moving towards being Industry 4.0 compliant. But this transition is not straightforward due to many reasons: in particular, transfer to new system can lead to significant production downtime and could result in delays and cost overruns. The best way is systematic seamless transition to newer and advanced technologies that Industry 4.0 offers. This paper proposes an automated synthesis framework that learns the behavior of existing legacy and often black-box programmable logic controllers and generates state machines that can be incorporated into IEC 61499 function blocks. The paper presents the toolchain architecture and exemplifies it on a laboratory scale Festo didactic mechatronic system.

An approach for automatic reconstruction of automation logic from execution scenarios using a metaheuristic algorithm is proposed. IEC 61499 basic function blocks are chosen as implementation language and reconstruction of Execution Control Charts for basic function blocks is addressed. The synthesis method is based on a metaheuristic algorithm that combines ideas from ant colony optimization and evolutionary computation. Execution scenarios can be recorded from testing legacy software solutions. At this stage results are only limited to generation of basic function blocks having only Boolean input/output variables.

This paper presents an approach for automatic reconstruction of automation logic from execution scenarios using a metaheuristic algorithm. The IEC 61499 basic function blocks is chosen as implementation language and reconstruction of Execution Control Charts for basic function blocks is addressed. The synthesis method is based on a metaheuristic algorithm most closely related to ant colony optimization and evolutionary computation. Execution scenarios can be recorded from testing legacy software solutions. At this stage results are only limited to generation of basic function blocks having only Boolean input/output variables

We are in the era of continued adoption of Industry 4.0 vision and standard. As the Industrial Cyber-Physical System applications move from centralized to decentralized systems, there is a need to follow a newer and better software design patterns and refactoring techniques for dependable software for these systems. There have been few works that present diverse design patterns and refactoring methods, and this article presents a case study of applying couple of refactoring methods and techniques in order to improve readability, maintainability, reuse-ability and debugging friendliness of existing function block applications. The goal of the article to validate the claim of refactoring advantages by applying the existing techniques with the help of empirical study.

This paper presents service-oriented implementation of distributed automation systems and the results of a practical performance measurement of Web-services deployed on different platforms. In the experiments we used a technique that allows one to separate the characteristics of the Web-service, such as the delays introduced by the medium of communication. It is shown that the technology development and deployment of Web-services significantly affect their performance

This paper presents a framework for employing cloud- deployable web services in the design of distributed control systems in industrial automation. The paper demonstrates how a part of the control logic can be developed as a web service and deployed in the cloud to improve reusability and flexibility. In order to demonstrate the use of the framework we consider an example of Pick-and-Place Manipulator, which was originally designed as IEC 61499 function block application with a distributed control consisting of a high level and a low-level control logic. Firstly the high level control and its functionality is converted to a web services and deployed to a cloud. Secondly the application is modified such that the low level control interacts with these newly developed web services. The paper also presents an interface between low level control and web service using dynamic linked library that bridges communication between the two components It concludes with the simulation results of the of Pick-and-Place Manipulator implemented using the proposed framework.

This paper presents a novel approach to automationof flexible manufacturing systems with mechatronic intelligenceand distributed control. The mechatronic intelligence layer isimplemented using a combination of wireless sensor/actuatornetworks with service-oriented architecture, where services arelocated at the device level, as well as in local and global Cloudsfollowing the Arrowhead framework.The machine/floor level coordination is implemented using thedistributed automation architecture of IEC 61499, which is alsoused as a graphical tool for orchestration of services.The paper discusses the enablers developed in-order to combineIEC 61499 and Arrowhead and the use is illustrated ona laboratory scale flexible factory example. By integration ofIndustrial IoT with IEC 61499, we envision that large gains interms of engineering effort and system operation performancecan be made.

This paper presents the development of a flexible product-driven manufacturing exemplified in a case study. The case study is based on Festo EnAS (“Energieautarke Aktoren und Sensoren” or “energy efficient actuators and sensors” in English) platform, enhanced with a mobile robot for logistics and a camera for automated visual-based product inspection. IEC 61499-based and wireless-capable embedded controllers are used to enable decentralized control architecture. In this case study, a software design pattern is considered to enable easier development of modular production systems with physically reconfigurable layout during the production process. This paper applies the software design pattern into production systems where product-driven approach is adopted, i.e. the overall production process is determined based on the product specifications/requirements from the customer.

This paper proposes a formal model for industrial cyber-physical systems (CPS) with distributed control based on IEC 61499 standard and supporting time-aware computations for better adaptation to the ever changing environment conditions. Main features of the model include usage of timestamps, flattening, unified and independent behaviour of function block interfaces. This allows to make correct implementation of time-aware systems and significantly simplify the construction of models for verification and simulation, as well as ensure fairness of the model and determinism of the function block system execution at a resource level. The model formalism is based on a well-known abstract state machines (ASM) notion, which can be used as an intermediate formal representation to generate a variety of models for different purposes, e.g. formal verification, and executable code. This paper exemplifies this approach by the generation of models in the SMV language. The paper discusses the time-aware computation concept and its application in a few related case studies.

In this paper a new modelling approach is presented to be used for formal-verification of block-diagram executable specifications of distributed industrial cyber-physical systems following the IEC 61499 standard. The approach allows usage of timers and arithmetic operations in the controller code. SMV model-checker is used as the target tool. The function block modelswith multiple communicating plant-controller closed-loops are transformed to the SMV modelling language using a dedicated model-generator tool. The paper first deals with SMV modelling of the IEC 61499 specific timer function block types. In particular, modelling of hierarchical function block systems with timers located at different levels of hierarchy is addressed. The paper then presents plant abstraction techniques so that the complexity of cyber-physical systems models is reduced. The abstraction uses discrete-timed state machine model implemented in UPPAAL. Delays in the plant model are interpreted as model time constraints. The approach is illustrated with an example of formal verification of a modular mechatronic automated system. The achieved results extend the abilities in validation of real cyber-physical automation systems. The paper also demonstrates how this result helps in counterexample guided simulation in Ciros 3D simulation environment, which improves practical usability of formal verification

Cyber-physical agnosticism (CPA) is a property of software in cyber-physical systems (CPS) to withstand various disturbances and keep maintaining the required behaviour of the physical process. With the increased research on the use of internet of things (IoT) in industrial automation (IoT-A), there is a need for robust distributed automation control systems that can take into account some overheads of using wireless devices in such an IoT setup. For example, data transfer delays between wireless sensors and the controller might result in the controller acting on a stale sensor value. In this paper, we present an approach of using time-aware computations to let the controller to assess quality of the input data and formal verification as a method to check the CPA property of the IoT-A applications. The paper specifically considers IEC 61499 standard for implementation of distributed IoT-A application. Ptolemy II PTIDES inspired time stamped event semantics is used in the application to keep track of the origin of different events. Timed automata are used to model the plant. The IEC 61499 application together with abstract plant model is then converted to SMV language and NuSMV model checker is used for formal verification. The paper presents a case study of an elevator example to demonstrate the proposed approach. A random delay is used to model the communication delay in the wireless network. It is shown that if the communication delay was not accounted for, then the elevator would stop in-between the floors and open the doors that is considered unsafe. The paper then shows how time-aware computation is used to make sure that the elevator always follows safe behaviour.

The growing need for smart and flexible systems in many areas of industry, such as manufacturing, smart grids,building automation systems and others, has resulted in new design approaches such as Cyber-physical systems (CPS). This raised the need for formal modelling of these systems to address reliability and robustness requirements. This paper addresses the problem of developing a formal semantics, based on abstract state machines (ASM), for modelling of distributed control systems for industrial CPS based on the IEC 61499 standard. The developed approach allows to build formal models of flexible distributed control systems for analysis and verification of various properties.

This paper introduces the application of formal modelling to cyber-physical systems for the purpose of formal verification of cyber-physical agnosticism properties of decentralised automation software. Service-oriented cyber-physical systems are modelled using the IEC 61499 function block architecture. Then, the IEC 61499 model is represented in terms of SMV formal language, which is verified using the nuXmv model checker. The timestamped events mechanism is implemented in IEC 61499 using the existing syntax of the standard. The impact of jitter on the behaviour of physical system is demonstrated in both simulation within IEC 61499 execution environment and in counter-examples extracted from nuXmv. The methodology presented in this paper creates the premise for automatic verification of the cyber-physical agnosticism of systems

This paper presents initial results on formal verification of protection functions in a smart power distribution grid. Informal properties of the smart grid were formalized in the language of LTL and formal verification is performed using NuSMV model checker on the closed-loop plant-control model which consists of IEC 61499-based control logic and an abstract plant model of distribution grid with fault scenario. The paper presents the results of verification of dependability, liveliness, safety and security properties. The results show the effectiveness of the closed-loop formal verification methodology.

Integrating smart manufacturing ecosystems with industrial-grade smart energy and building automation systems enables real-time adaptation to changes in demands and factory conditions, the supply chain, and the needs of customers and society. However, integrating, managing, and controlling data exchange usually incurs high overheads in such a collaborative industrial environment. Smart home IoT technologies are a cost-effective solution for smart energy and building automation systems; they are not fully interoperable with industrial IoT technologies. This paper presents a mechanism to solve this interoperability problem using the Eclipse Arrowhead framework. The proposed solution provides a microservice-oriented architecture to develop protocol-specific smart adapter systems for the Arrowhead framework. These smart adapter systems provide seamless and highly scalable integrations between smart home and industrial IoT technologies. Our solution enables smart manufacturing ecosystems to meet Industry 5.0’s core values and reduce their carbon footprint to save the planet. We present the performance of our solution using an example from a real-world use case of a smart heating system scenario in a smart factory.

This paper presents a feasibility study of implementing parts of a distributed function block application as TinyOS modules running on Wireless Sensors as a part of Wireless Sensor Network. The paper first briefly describes underlying technologies and gives motivation for implementation of function blocks in TinyOS. The paper then presents implementation details about TinyOS realization of the one of the function block, which is a part of bigger distributed control application with the help of distributed function block application.

With increase in use formal verification tools and methods in distributed systems, it is becoming more challenging to analyse the execution traces generated by formal verification tools. This paper presents a method for unification of execution traces of industrial automation systems, based on IEC 61499 standard. Execution trace of a system is a sequence of events, where each event represents a change in the state of the system. Execution traces allow developers to explore safely behavior of control software. Execution traces can be obtained several ways, including monitoring of a real system (or its simulator), or as a counterexample build by model checker. In the paper we explore unification of execution traces for debug task in FBME - modular IDE for IEC 61499 applications. We present the formal model of the execution trace representation and show the working on a simple example.

This paper presents a swarm-based architecture for the composition of mechatronic systems from smart components complemented by a Virtual Commissioning (VC) environment. The architecture is based on the IEC 61499 standard. The proposed solution enables plug-and-play composition of the system which is ready to operate ”out of the box” right after it was composed without extra programming.

The protection system is a crucial part of the power grid. It protects people, equipment, and property. Reliability of such mission critical systems is of an extreme importance. Protection systems have strict requirements to reliability including dependability, security and timeliness. Although it undertakes rigorous testing and commissioning, it fails in some circumstances causing faults in the network, resulting in loss of power. It is hard to catch these hidden and undetectable errors in the design and installation. Since protection function is essentially a piece of code, formal methods can be used for rigorous testing of the software and provide definitive proof of the system properties. This paper proposes a formal model (to use in formal verification techniques) for protection systems. The paper develops closed loop model of the electrical network with its protection system. The model is developed in IEC 61499 language for the further generation of its formal model in SMV language. The model is validated via simulation and comparison with a comprehensive model of the electrical network in Matlab Simulink. In future work, the generated SMV model will be used to formally verify reliability requirements of the protection system.

The second edition of the IEC 61499 standard aims to clarify the interpretation ambiguities of function block’s execution semantics. This resolves the pivotal issue of realizing portable and interoperable implementations of the IEC 61499 reference architecture. As the IEC 61499 standard is about entering its technology takeoff phase, these clarifications are timely and important. It is hence expected that more innovators of automation software tools, runtime environments, and control hardware will start adopting this technology. To assist such adoption, this paper presents a study of existing IEC 61499 tools’ portability issues. In particular, the features of currently active IEC 61499 tools, such as FBDK, ISaGRAF, 4DIAC, and nxtStudio are outlined. Their incompatibility issues due to different execution semantics are exemplified. Moreover, it is also illustrated in this paper how these issues can be addressed by complying with the updated norms.

Industrial automation is facing challenges related to a manufacturing change from mass pro-duction to mass customization. As a result, the focus of automation has been shifting to flexi-bility, reconfigurability and safety assurance resulting in a new class of systems that is heavilymodular. We call this new class of systems as Component-Based industrial Automation Sys-tems (CBAS).

Given the current challenges and shift in focus, the current engineering practices and meth-ods need to be changed or upgraded. One of these practices is software verification and valida-tion (V&V) techniques. Simulation is one of the well-known V&V techniques used currentlyin CBAS. Simulation is performed by building simulation models for the physical process,for example, simulation using Matlab. However, development of simulation models is time-consuming and does not guarantee 100% validation of the automation control software makingjust simulation inadequate for CBAS. To address this problem, formal verification has beenconsidered as a proper complementary V&V technique. Discrete state model checking is oneof such approaches, which is the process of automatically verifying whether a set of desiredformal specifications is satisfied over the target system model. While model checking is com-putationally resource hungry, it has been successfully used in other adjacent areas of computersystems engineering, such as hardware design, proving its ability to handle problems of rea-sonably large complexity. This suggests that model checking can be applied in the industrialautomation domain, and there has been an impressive number of works towards this goal.

Despite moderate successes and promises the reality is that formal techniques are rarelyused in the development practice by industrial automation engineers. It seems that the existingtools and methods do not fit into the current Software Development Life Cycle (SDLC) of au-tomation systems engineering. This thesis first looks at current state of art with comprehensiveliterature review, identifying 3 main challenges for lack of industrial adoption of formal verifi-cation. The thesis then presents various formal method approaches to address these challenges.The main contribution of the thesis is a method for the formal verification of IEC 61499 func-tion block applications using Abstract State Machines (ASM) and model checking. A formaldescription for main artifacts of the standard is presented in the thesis. Further, ASM rules fortranslation for function blocks to the input format of the SMV model checker is presented. Inthis way, the proposed verification method enables the formal verification of the IEC 61499control systems.

As results, the thesis presents an application of this framework to industrial automation usecases to check for functional and non-functional requirements. It also presents use cases wherethe proposed framework is used for verifying portability of IEC 61499 based control applica-tions across different implementation platforms compliant with the IEC 61499 standard.

Formal verification of embedded control systems using closed-loop plant-controller models is getting increasingly popular. In this paper we propose a new method reducing complexity of model-checking on account of infusing non-determinism into certain parts of the plant model during formal verification process guided by a software tool. Net Condition/Event Systems (NCES) formalism is used for modular design of closed-loop models which are verified by ViVe and SESA model-checkers. Its performance is compared to modelling with finite state verified with SMV and UPPAAL and is proven to be superior.

In this paper we address practical aspects of applying the model-checking method for industrial automation systems verification. Several measures are proposed to cope with the high computational complexity of model-checking. To improve scalability of the method, cloud-based verification tools infrastructure is used. Besides, closed-loop plant controller modelling and synchronization of transitions in the SMV (input language for symbolic model checking) model aim at complexity reduction. The state explosion problem is additionally dealt with by using an abstraction of the model of the plant with net-condition event systems, which is then translated to SMV. In addition, bounded model-checking is applied, which helps to achieve results in cases when the state space is too high. The paper concludes with comparison of performance for different complexity reduction methods

Design patterns in software engineering is a generic solution provided for repeatable problems occurring frequently in a software design. They are used a lot in the field of software engineering, especially for object-oriented software development. Different standards exist for design and development of industrial cyber-physical systems and the IEC 61499 standard is one of them. The standard presents a reference component architecture for design and development of distributed industrial cyber-physical systems. There is a lack of design patterns for application development with IEC 61499 standard and this paper address this by proposing some patterns. The design patterns presented are inspired by popular design patterns used in software engineering.

Industrial Cyber-Physical System applications, especially distributed ones are designed and implemented in many standard approaches, one of them being IEC 61499 distributed programming standard. This article presents a case study of applying couple of refactoring methods and techniques in order to improve readability, maintainability, reuse-ability and debugging friendliness of existing function block applications. The article presents some software metrics for pre and post refactoring function block applications for measuring the effectiveness of refactoring.

The Function Blocks Architecture of the IEC 61499 standard is an executable component model for distributed embedded control systems combining block-diagrams and state machines. The standard aims at the portability of control applications that is however hampered by ambiguities in its execution semantics descriptions. In recent years several execution models have been implemented in different software tools that generate mutually incompatible code.This paper proposes a general approach to neutralizing these semantic ambiguities by formal description of the IEC 61499 in abstract state machines (ASM). The model embodies all known execution semantics of function blocks. The ASM model is further translated to the input format of the SMV model-checker which is used to verify formally properties of applications. In this way the proposed verification framework enables the portability checking of component-based control applications across different implementation platforms compliant with the IEC 61499 standard.The paper first discusses different existing execution semantics of function blocks and the portability issues across different IEC 61499 tools. Then a modular formal model of function blocks’ operational semantics in ASM is introduced and exemplified in the paper by the cyclic execution semantics case for a composite function block. Subsequently, the SMV model is generated and model-checking is illustrated for a simple test case.

IEC 61499 Standard for Function Blocks Architecture is an executable component model for distributed embedded control system design that combines block-diagrams and state machines. This paper proposes approach to formal modelling of IEC61499 function block execution semantics for popular model checking environment of SMV using Abstract State Machines. An operational semantics of IEC 61499 application with two-stage synchronous execution model is presented using this framework. This paper first introduces the importance of model checking function block applications in different execution semantics. It highlights the uses of formal verification, such as, verifying portability (behavior) of component based control applications across different implementation platforms compliant with the IEC 61499 standard. The formal model is applied on an example IEC 61499 application. The paper compares the verification results of this IEC 61499 application with two-stage synchronous execution model and the same application with cyclic execution model presented in the earlier work. With this comparison, we verify the portability of the IEC61499 applications across different platforms.

IEC 61499 Standard for Function Blocks Architecture is an executable component model for distributed embedded control system design that combines block diagrams and state machines. This paper proposes rules for formal modelling of IEC61499 function blocks for popular model checking environment of SMV using Abstract State Machines as an intermediate model. This paper first proposes a formal description of the IEC 61499 in abstract state machines (ASM). The formal description for main artifact of the standard (function block) is presented in the paper. The ASM model is further translated to the input format of the SMV model checker which is used to formally verify properties of applications developed in IEC 61499 standard. In this way the proposed verification framework enables the formal verification of the IEC 61499 control systems. The paper also highlights the other uses of verification such as portability of IEC 61499 based control applications across different implementation platforms compliant with the IEC 61499 standard. The formal model is applied on an example IEC 61499 controller, and the SMV model for the Basic Function block is explained in detail.

This paper presents implementation of one of the Distributed Grid Intelligence (DGI) applications: Load Balancing, using the IEC61499 architecture. This enables system level design of distributed load balancing application with a direct pathway to deployment to hardware. The use of IEC 61499 improves scalability, re-configurability and maintainability of automation software. The application was deployed to commercial programmable automation devices and embedded controller (ARM based TS-7800). The application was verified using co-simulation approach: control and power system simulated using Matlab on PC networked with the number of distributed hardware running load balance algorithm. The use of IEC 61499 facilitates deployment of hardware independent function block model to the variety of compliant hardware.

This paper proposes a framework for formal verification of industrial automation software in an intuitive way. The IEC 61499 function block architecture is assumed to be the input language, and the Intelligent Mechatronic Components (IMC) architecture is assumed as an underlying design pattern for the applications, which implies autonomous control logic in each IMC and their compositions to systems in a plug-and-play way. Then the system is automatically verified using model checking and the counter examples for the failed model checking properties are played back step-by-step and state-by-state in the simulation model that most industrial automation control systems would have built as the basis for initial testing. Net Condition Event Systems formalism (a modular extension of Petri net) is used to model the decentralized control logic and discrete-state dynamics of the plant. The model is then subjected to model checking using the ViVe/SESA tool chain. The method's application is illustrated using a simple pick and place manipulator. A closed loop model of Plant and Controller is used. Controller is extensively verified for safety, liveliness and functional properties of the robot. We then show how a counter example for deadlock detected by the model checker is played back in the simulation model for visualizing how exactly the system deadlocked.

This paper introduces an approach to automatic verification of mechatronic systems designed as plug-and-play of Intelligent Mechatronic Components (IMC). The control logic of the system is composed from autonomous controllers of the IMCs and is automatically verified using model-checking. Net Condition Event Systems formalism (a modular extension of Petri net) is used to model the decentralized control logic and discrete-state dynamics of the plant. A re-configurable pick and place robot is used as an illustrative example. At first a three cylinder pick and place robot is used to design our new master-slave architecture for controller design and then the NCES models are re-used without much modification in a new 6 cylinder pick and place robot. The control model is then subjected to model checking using the ViVe/SESA model checker. A multi closed loop model of Plant and Controller is used and controller is extensively verified for safety, liveliness and functional properties of the robot. Computational Tree Logic (CTL) is used to specify these properties.

Interoperability is one of the most important features expected from distributed automation architectures. Achieving interoperability involves addressing issues related to synchronization of behavior, communication protocols, and data presentation formats. In this paper a case study on deployment of an automation application to a network of control devices with three different hardware/software platforms is presented to exploit benefits of the IEC 61499 architecture. Firstly, an overall control application with essentially distributed logic was created. This control application was then validated using closed-loop simulation and finally deployed to a network of control devices

This paper presents a model-checking framework for the purpose of design and implementation of robust smart grid applications based on distributed intelligence. The paper first introduces distributed grid intelligence approach to smart grid automation and related challenges of their verification. We then introduce the case study example and how model-checking can be applied to the presented system implemented in IEC 61499 standard. In the end we present the initial results of our model-checking application to smart grid applications. The paper will conclude with some issues faced during the research and corrective steps to address these issues in future.

This paper reports on integration of the Industrial Internet of Things (IIoT) service framework Arrowhead with automation systems programmed in the traditional and future automation languages. In particular it focuses on integrating the Arrowhead Datamanager system into the Eclipse 4DIAC IEC 61499 development environment and testing it on a physical system plant.

Industrial automation systems need to be highly dependable; they should not merely function as expected but also do so in a reliable, safe and secure manner. Formal methods are mathematical techniques used to describe computer systems, both hardware, and software. Formal methods can greatly aid in developing dependable systems and can be used across all phases of the system development lifecycle, right from customer requirement gathering through design and implementation, verification and validation (testing), maintenance and even documentation. This state-of-the-art survey reports existing formal approaches for creating more dependable industrial automation systems, focussing on static or offline, as opposed to runtime or online, formal methods. This article categorises existing works as per the requirements engineering, design and implementation, and testing phases of the system development life cycle, allowing us to identify gaps in current research and promising future directions for each of these phases.

Requirements engineering is the first stage in the development of any system. For safety-critical industrial systems like smart-grids, we must ensure that requirements are properly elicited, defined, analyzed and managed. This paper adapts the requirements framework developed in the CESAR European project, called the CESAR requirements meta-model, to support all aspects of requirements engineering for safety-critical systems. This enables the formalization of requirements in order to automate and assist in many aspects of later stages in the system development life cycle. Using a smart grid system from the FREEDM project, we illustrate that the adapted requirements engineering framework is comprehensive and rich for large safety-critical systems. We find that the use of the IEC 61499 function block standard provides an appropriate system modelling and implementation framework, which complements the strengths of the proposed requirements engineering framework. Traceability links between requirements and components of an IEC 61499 system model can help with automatic test case generation and formal analysis of requirements.

This paper presents an example of a systematic approach based on domain-specific languages to implement Function Blocks Modelling Environment (FBME): an integrated development environment (IDE) for the international standard IEC 61499. The new open development environment for the standard of growing importance in the Industry 4.0 realm would contribute to the broader adoption of open standard-based development practices and facilitate efficient automation software development.

This paper proposes a new software composition method for automated machines that exploits their mechatronic modularity. It is demonstrated that desired behavior of a certain class of machines can be composed of behaviors of its mechatronic components, including fully decentralized scheduling and operation control. This aims at increased performance of software design and maintenance, as well as systems' flexibility and reconfigurability. The IEC 61499 Function Blocks' (FBs) architecture is used as an implementation platform that enables system-level simulation and transparency of deployment. A configurable pick-and-place (PnP) manipulator with decentralized control synthesized using the proposed approach is chosen as an illustrative example

This paper proposes a step-by-step approach for developing modular and reusable logic controllers of mechatronic systems. Following that, it presents the results of employing three distributed control methods, including master-slave, peer-to-peer and independent controllers on a pick-and-place robot as a simple showcase of implementing a distributed control system on industrial applications, using the emerged IEC 61499 standard. Moreover, it addresses possibilities and challenges of using each approach.

This article proposes a method for the automatic generation of a plant model and monitoring using process mining algorithms based on recorded event logs. The behavioral traces of the system are captured by recording event logs during plant operation in either manual control mode or with an automatic controller. Process discovery algorithms are then applied to extract the logic of the process behavior properties from the recorded event logs. The result is represented as a Petri net, which is used to construct the state machine of the plant model and monitor and is in accordance with the IEC 61499 Standard. The monitor is implemented as a function block and can be deployed in real time to trigger an error signal whenever there is a deviation from the actual process scenario. The plant model and controller are connected in a closed loop and are used for the formal verification of the system with the help of the “fb2smv” converter and symbolic model checking tool NuSMV.

In this paper, we describe a method to automatically derive the controller for an automated process by an interactive learning approach using a simulation model developed in Visual Components 3D simulation software. The latter is used to record the events of the processes and the controller is generated as an IEC 61499 function block. To create different process scenarios, the actuator signals are triggered manually in appropriate order. The controller logic in Petri net is derived by process discovery algorithms with help of recorded events and conversion of Petri net to IEC 61499 function blocks is done by a software tool configured with a set of transformation rules.

This paper introduces the concept of plant model generation from the recorded traces of events using the process mining technique. The event logs are obtained by visually simulating a simple distributed manufacturing system using the OPC UA communication protocol. The process discovery alpha algorithm is used to extract the process model in Petri net format. The system behavior represented in terms of Petri net is then fed to construct the ECC of the basic function block in compliance with IEC 61499 standard using the proposed notation. Finally, the formal verification of the closed-loop system is done with the help of a tool chain that consists of fb2smv converter, symbolic model checker NuSMV, and other tools for representing counter-examples.

In this paper, we discuss how process mining techniques can be applied in industrial control systems for modeling, verification, and enhancement of the cyber-physical system based on recorded data logs. Process mining is used for extracting the process models in different notations from the recorded behavioral traces of the system. The output model of the system’s behavior is mainly derived using an open-source tool called ProM. The model can be used for such applications as anomaly detection, detection of cyber-attacks and alarm analysis in industrial control systems with the help of various control flow discovery algorithms. The extracted process model can be used to verify how the event log deviates from it by replaying the log on Petri net for conformance analysis.

This paper reports on a method of automatic generation of a formal model of plant from the behaviour traces recorded from its digital twin. The traces are observed from simulation in the loop of the digital twin in Visual Components connected with distributed automation software, developed in NxtSTUDIO according to IEC 61499. The generated modular formal model of the closed-loop system is transformed to the model of uncontrolled plant behaviour extended with nondeterminism. The model is then combined in closed-loop with the formal model of controller, generated from its source code using the fb2smv tool. The verification and simulation is done by the symbolic model checker NuSMV tool, which verifies various CTL/LTL specifications of the system.