In the domain of Programmable Logic Controller (PLC) programming, converting a Ladder Diagram (LD) into a Sequential Function Chart (SFC) is an inherently challenging problem, primarily due to the lack of domain-specific knowledge and the issue of state explosion in existing algorithms. However, the rapid development of Artificial Intelligence (AI) - especially Large Language Model (LLM) - offers a promising new approach.Despite this potential, data-driven approaches in this field have been hindered by a lack of suitable datasets. To address this gap, we constructed several datasets consisting of paired textual representations of SFC and LD programs that conform to the IEC 61131-3 standard.Based on these datasets, we explored the feasibility of automating the LD-SFC conversion using LLM. Our preliminary experiments show that a fine-tuned LLM model achieves up to 91% accuracy on certain dataset, with the lowest observed accuracy being 79%, suggesting that with proper training and representation, LLMs can effectively support LD-SFC conversion. These early results highlight the viability and future potential of this approach.

Loosely coupled systems are benefited from higher changeability. They are less rigid and more flexible because they are loose but still connected as they are coupled. On the other hand, they could behave unpredictably in the course of sudden change. While many studies and industrial practices are trying to make PLC-based control and automation software more loosely coupled, this paper aims to bring the attention of subject matter experts to the fact that making PLCbased control and automation software too loosely coupled could demolish the main characteristic of these systems, which relies on their predictability and reliability.

Although generally speaking, modularisation is not a new topic in the software industry, industrial control and automation software systems based on industrial computers recently received greater attention from academia and industry due to the impact of modularisation on managing software complexities, particularly changeability. While there is a direct correlation between coupling and modularisation and their impact on software changeability and reusability, not all modularisation techniques could bring higher changeability unless it is performed in the direction of changeability. How to modularise in the direction of changeability is the core topic of this paper.

The capabilities demonstrated by Large Language Models (LLMs) inspire researchers to integrate them into industrial production and automation. In the field of Programmable Logic Controller (PLC) programming, previous researchers have focused on using LLMs to generate Structured Text (ST) language, and created automatic programming workflows based on it. The IEC 61131 graphic programming languages, which still has the most users [1], have however been overlooked. In this paper we explore using LLMs to generate graphic languages in ASCII art to provide assistance to engineers. Our series of experiments indicate that, contrary to what researchers usually think, it is possible to generate a correct Sequential Function Chart (SFC) for simple requirements when LLM is provided with several examples. On the other hand, generating a Ladder Diagram (LD) automatically remains a challenge even for very simple use cases. The automatic conversion between LD and SFC without extra information also fails when using prompt engineering alone.

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.

Execution time of IEC 61131-3 applications depends heavily on the approach and techniques used to compile the programs into executable code. In this paper the authors describe an effort to create an IEC 61131-3 front-end to the LLVM family of compilers, and provide the results of execution timing tests run on an x86 and an ARM platform. A comparison is made to the execution time of programs compiled by CODESYS.

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.

Beremiz is a project that is currently developing a software based PLC (Programmable Logic Controller) distributed under the open source GNU Public License (GPL). Recent activity has focused on adding support for several industrial communication protocols. This paper describes the implementations and integration with Beremiz of several industrial protocols already completed, as well as current activity and possible future directions.

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.

The IEC 61499 standard defines a framework for the development of distributed control applications, including a modeling language and its associated execution semantics. Traditionally industrial control applications run on a single computing device. When moving to a distributed solution new failure models need to be taken into account. In previous work the authors have this proposed a framework to support the development of fault tolerant distributed IEC 61499 applications, based on the use of active replicas. Special communication protocols were considered in order to guarantee replica determinism and synchronization. In this paper we relax the replica determinism requirement and explore other possible implementations for the replication framework that do not require special communication protocols and are easier to implement in practice.

Modern industrial environment control programs are distributed among several devices. The IEC 61499 standard defines function blocks with which distributed control applications may be developed, and how these are interpreted and executed. Its functionality and the inherent support for dynamic reconfiguration provide the required infrastructure for Industry 4.0 and industrial IoT applications. However, by their distributed nature new challenges are posed, especially about how modes of failure are handled. To avoid system malfunctions and breakdowns due to partial failures, the authors propose a new framework were the concept of replication can be applied maintaining internal state synchronised. This paper presents an example of how the replication framework on the FORTE IEC 6499 execution platform can be developed and voting strategies, along with the results obtained in the implementation with the standard communication SIFBs available on the Eclipse 4diac™.

An emerging trend in industry 4.0 is to use wireless communication infrastructure and mesh networks in applications requiring high reliability and safety. Although not a typical industrial production process, railway vehicular networks are also an industrial application which come with stringent reliability and safety requirements. Current research is focusing on using vehicular networks as an enabling technology to actively control the separation between two consecutive vehicles, enforcing a safe distance which is nevertheless much shorter than currently used to maintain vehicle separation. In this respect, we analyze a hopping strategy for Time-Slotted Channel-Hopping (TSCH), which was introduced in the IEEE 802.15.4e amendment with a view of improving the reliability of IEEE 802.15.4 networks. We define a probability framework to estimate the chance of successful hopping assuming two previously merged vehicles, and we design a zero-sum game and propose a payoff function to always place communicating nodes in a Nash equilibrium by choosing whether to hop or not, and therefore maximizing the communication throughput by mitigating jamming signals.

Still to this day, there are many industrial sequential processes described in Ladder Diagram (LD), a language not suitable for that purpose, that can be described in SFC, a proper language for describing sequential processes. We provide analysis on the main algorithms for extracting the sequential logic from a LD program that can be found in the literature and point some problems in them. We then propose a new algorithm to extract the sequential logic and produce a state-machine from a LD program. We describe a tool developed to implement said algorithm and show the results.

Industrial control system is a general term that addresses several types of control systems, including supervisory control and data acquisition systems, distributed control systems, Programmable Logic Controllers and etc. There is no doubt that protecting PLCs from cyber-attacks is very important as they directly control industrial processes. In critical infrastructure, any successful attack on PLC could be as serious problem particularly in DCS. In this paper we approach an authentication solution based on cryptography to avoid unauthorized accesses in ICS.

During the development of a new parser for the grammar defined in the latest edition of IEC 61131-3, the authors came across many inconsistencies between the main body of the standard and the formal definition of the grammar. This paper explains the inconsistencies that were uncovered, and suggests corrections to the formal grammar.

One of the aspects that affects the reliability of a software application is the programming language used for its development. In industrial automation applications, the most commonly used languages are those defined in the IEC 61131-3 standard. This work contains an analysis of the semantics of ST and IL expressions, and highlights ambiguities in the standard that might lead to seemingly correct code being executed and evaluated differently in distinct IEC 61131-3 execution environments. Examples of code that may be evaluated to different results are given, and an evaluation of several commercially available IEC 61131-3 compilers is made and compared. A static code analyzer was developed capable of identifying legal IEC 61131-3 code that may result in ambiguous behavior, and this analyzer was used to test source code currently in use in real-world control applications.

TIEC 61499 defines an execution model for distributed industrial control applications, i.e. a single application distributed among several devices. In such an environment partial failures are likely to occur. In order to avoid probable system malfunctions and breakdowns due to partial failures, the authors have previously proposed a framework where the concept of replication may be applied to the IEC 61499 execution model. This paper focuses on describing an implementation of this replication framework on the FORTE IEC 61499 execution platform, along with the results of the first tests of the implementation. A set-up for the full validation of the approach is also described.

In a modern industrial environment control programs are distributed among several devices. This raises new issues and challenges especially in failure modes. Building fault tolerant applications can be the solution in order a failure of one sub-component not to jeopardize the execution of the whole application. The authors have proposed a framework to support replicated IEC 61499 applications. In this paper we augment this framework with the support for different voting strategies, propose an extension of the replication communication protocol, and analyse the resulting fault-tolerance semantics. A limited implementation of the framework is also described.

Being distributed in nature, IEC 61499 industrial control applications are subject to partial failures. Building applications that are tolerant of these failures (i.e. a fault-tolerant application) may be achieved through the use of replication. In this paper we present a framework to support replicated IEC 61499 applications, and study how replica determinism may be achieved in this framework.

Hypervisor-based virtualization provides a natural way to integrate formerly distinct systems into a single mixed-criticality multicore system by consolidating in separated virtual machines. We propose an adaptive computation bandwidth management for such architectures, which is compatible with a potential certification based on the guarantee of specified bandwidth minimums and the isolation of overruns of virtual machines. This management uses periodic servers and an elastic task model to combine analyzability at design time with adaptability at runtime. Mode changes or early termination of VMs trigger a resource redistribution that reassigns spare capacity. In this paper we focus on the integration of an adaptive reservation policy into a virtualization software stack and the co-design of hypervisor and paravirtualized guest operating system. In a concrete implementation on a PowerPC 405, the bandwidth distribution policy incurred in a memory footprint below 2.7KB and a worst-case execution time for the redistribution function below 4 microseconds for realistic low numbers of VMs. Simulations over synthetically generated sets of VMs with random mode changes showed a gain of 13% of computation bandwidth when compared to an approach with fixed partitions and provided a relative error of allocated bandwidth to desired bandwidth 4 times lower.

ROS (Robot Operating System) is a framework for the development of robotic applications widely used throughout research community due to its modular architecture and distributed nature. Using this framework a robot application consists of several nodes that exchange data over a common middle-ware. Programming new nodes is done by using a ROS API (application programming interface) on one of the available programming languages, such as C++ and python. It is our intention to build a robot that needs to be partially programmed in IEC 61131-3, allowing the end-user to adapt it to any specific industrial environment. In this work we have specified a mapping between the concepts defined in IEC 61131-3 and ROS, and started implementing a library through which IEC 61131-3 programs may co-ordinate their actions with the remaining ROS based robotic application.

The IEC 61508 standard recognizes the programming languages defined in IEC 61131-3 as being appropriate for safety-related applications, and suggests the use of static data type analysis of the source code. In this context, we have added a data type semantic verifier to the MatlEC compiler - an open source ST, IL and SFC code translator to ANSI C. In so doing, we have identified several issues related to the definition of the semantics of the IL and ST programming languages, as well as with the data type model defined in IEC 61131-3. In this paper we describe the issues we uncovered, explain how the data type static analyzer of the MatlEC was implemented, explain the options we took, and suggest how the IEC 61131-3 standard could be made more explicit.

The middleware is an important software component when designing an application, facilitating the development and deployment of the applications. In the case of Distributed Embedded Systems (DES), the middleware should provide basic functionalities to abstract the complexity that results from network distribution, namely data consistency, events synchronization and resource management. Often DES applications exhibit real-time requirements and have to deal with dynamic environments that present evolving requirements. While some middleware architectures have been proposed to address resource provisioning and QoS management, none of those middle-wares supports dynamic resource reconfiguration while providing real-time guarantees. This paper proposes a middleware layer, based on the services provided by a flexible real-time communication protocol, addressing distribution abstraction, dynamic reconfiguration and dynamic QoS management under real-time constraints.

The international Electrotechnical Commission (IEC) 61499 architecture incorporated several function block with which distributed control application may be developed, and how these are interpreted and executed. However, due the distributed nature of the control applications, many issues also need to be taken into account. Most of these are due to the new error model and failure modes of the distributed hardware on which the distributed application is executed and also due the incomplete standards definition of the execution models. IEC 61499 frameworks does not clarify how to handle with replication of software and hardware components. In this paper we propose a replication model for IEC 61499 applications and which mechanisms and protocols may be used for their support.

In the last years many standards have been created for the industrial control domain. Some have found wide adoption in the industry, while others seem to never leave the stage of a promising technology. An example of the first type is ISA 88, that defines an architectural design for control applications for the batch process industry. The author is of the opinion that IEC 61499 is an example of the latter. In this paper the author analyzes how the design architecture defined in ISA 88 may be implemented using the programming framework defined in IEC 61499. Even though ISA 88 and IEC 61499 both follow an event based and object-oriented approach, the author uncovers a fundamental constraint of the IEC 61499 related to the dynamic invocation of services from distinct object instances. Without trying to extend the IEC 61499 standard, two approaches are presented to work around this constraint.

The IEC 61499 standard defines function blocks with which distributed control applications may be developed, and how these are interpreted and executed. With the distributed nature of the control application, many issues also need to be taken into account. In this paper we propose a replication management framework for IEC 61499 applications, and discuss some mechanisms and protocols that may be used for this purpose.

When developing applications with high integrity requirements, the choice of programming language is of utmost importance. In fact, IEC 61508 includes a table with suggested programming languages for each SIL (safety integrity level). The languages defined in IEC 61131-3 are included in this table, but are only highly recommended for the higher SILs if a subset of the languages are used. In this paper we propose restrictions and changes to the IEC 61131-3 languages that constitute a subset of the languages with the objective of making them appropriate for the development of high integrity applications.

We have implemented an IEC 61131-3 IL (Instruction List) and ST (Structured Text) compiler that will be part of an open source PLC. In doing so, several issues were found regarding the specification of the IL and ST languages, produced by the IEC (International Electrotechnical Commission ) standards body. The uncovered issues are discussed in this paper, and some changes to the standard are proposed. The architecture used in the compiler implementation is also outlined in the paper.