A method for designing and implementing service-oriented industrial software components that support temporal semantics

Abstract

This invention discloses a method for designing and implementing service-oriented industrial software components that support time semantics. The method includes the following steps: Step 1: OT application design; Step 2: Generating OT service applications using code generation tools; Step 3: Deploying and running OT service applications. The industrial software constructed by this invention has scalability, a better ecosystem, and better real-time characteristics. When business requirements change, only the connection relationships between components need to be dynamically constructed, without modifying already developed components. Utilizing IT technologies, a series of frameworks and components such as AI, cloud-native, and big data can be used to build more comprehensive and powerful industrial software. In terms of real-time performance, through the DDS component and the modification of the traditional microservices technical framework, this technology is superior to native microservices in terms of real-time performance.

Description

Technical Field

[0001] This invention belongs to the fields of operational technology and information technology, and relates to a method for designing and implementing industrial software components, specifically a method for designing and implementing service-oriented industrial software components that support time semantics. Background Technology

[0002] Modern industrial automation and control systems are primarily based on distributed electromechanical equipment. These devices use built-in controllers to perform predetermined functions, ranging from programmable logic controllers (PLCs) to robot controllers, digital controllers, and general-purpose motion controllers. In the era of the Industrial Internet, industrial manufacturing methods are shifting from mass production to mass customization. Industrial automation and control systems are facing constantly changing business needs and the urgent need to restructure production lines, which poses challenges to the scalability, reliability, and interoperability of industrial software systems.

[0003] Most current industrial systems rely on vendor-specific solutions, where vendors provide hardware and their control cores as black boxes, offering only limited scalability and proprietary application programming interfaces (APIs). To facilitate industrial application development, the industry developed the IEC 61499 standard, which defines a set of software components for distributed information and control systems. Using a component-based approach to software development not only improves software reliability but also facilitates application integration and enhances device interoperability by defining a unified data format. However, this standard still has certain shortcomings in the field of industrial software servitization. One important point is that, from a deterministic and temporal ordering perspective, temporal semantics are not well addressed in the IEC 61499 standard.

[0004] In the traditional industrial software framework, industrial applications are often written in languages ​​such as ST and ladder diagrams. Such development means that the development ecosystem is relatively closed and cannot use new and efficient technical frameworks such as large models and cloud computing in the IT field. It also means that the development efficiency is relatively low.

[0005] In the process of integrating OT and IT technologies, the following challenges are faced: there are barriers to the integration of hardware and software devices from different vendors, making it difficult to promote and use a unified industrial software component model; the related technologies in the IT / OT domains are very different, making it difficult for relevant personnel to develop complete cross-domain applications in a unified manner. Summary of the Invention

[0006] This invention provides a method for designing and implementing service-oriented industrial software components that support time semantics. This method has a series of characteristics such as distributed nature, scalability, ecosystem compatibility, event-driven nature, determinism, and time semantics, and effectively solves the above-mentioned technical problems existing in the integration of OT and IT technologies.

[0007] The objective of this invention is achieved through the following technical solution:

[0008] A method for designing and implementing service-oriented industrial software components that support time semantics includes the following steps:

[0009] Step 1: OT Application Design

[0010] Step 1.1: Familiarize yourself with and understand the relevant concepts of industrial software component models, as well as their related rules and constraints;

[0011] Step 1.2: Divide the application scenarios into functional parts, consider which OT services to design, and the functions of each OT service;

[0012] Step 1.3: After completing the design, model the OT service in 4diac IDE, including designing the types of OT components, external interfaces, kernel functions, and connection relationships of OT components;

[0013] Step 1.4: Export all OT component types and applications that the OT application depends on as .fbt and .sys files;

[0014] Step 2: Use a code generation tool to generate the OT service application.

[0015] Step 2.1: Understand and deploy the code generation tool;

[0016] Step 2.2: Place the .fbt and .sys files exported in Step 1.4 into the input folder in the root directory of the code generation tool;

[0017] Step 2.3: After the code generator performs dependency checks, type generation, application generation, and configuration generation, an OT service application is obtained. During dependency checks, it is necessary to ensure that the .fbt and .sys files placed in the input folder in the root directory meet the dependency requirements.

[0018] Step 2.4: Copy the generated project from the output folder to the custom project path;

[0019] Step 3: Deployment and Operation of OT Service Applications

[0020] Step 3.1: Understand and deploy the basic development environment of Java 17, Maven, and Spring Boot;

[0021] Step 3.2: Download and compile OpenDDS, and familiarize yourself with its related concepts and constraints;

[0022] Step 3.3: Use DDS-related tools to compile the topic.idl file in the idl directory of the custom project path, and place the generated dynamic link library in a directory under the environment variable path;

[0023] Step 3.4: Configure the service deployment node and DDS runtime configuration parameters by configuring the parameters in the OT service, and modify the pom file to ensure that the path of the DDS topic-related JAR dependencies is consistent with the path of the JAR obtained by compiling topic.idl in step 3.3;

[0024] Step 3.5: Start each OT service in sequence and wait for the services to discover each other;

[0025] Step 3.6: Control the overall application and observe its actions or outputs through the RESTful API reserved by the OT service.

[0026] Compared with the prior art, the present invention has the following advantages:

[0027] 1. Using the method of the present invention, OT service components using microservice technology can be written based on industrial software designed according to a formal model, and conveniently deployed using microservice-related technologies, thereby improving the efficiency of OT / IT cross-domain integration and providing a conversion standard for such cross-domain integration.

[0028] 2. The industrial software constructed by this invention has scalability, a better ecosystem, and better real-time characteristics. When business requirements change, only the connection relationships between components need to be dynamically constructed, without modifying the components that have already been developed. Utilizing IT technologies, it can leverage a series of frameworks and components such as AI, cloud-native, and big data to build more comprehensive and powerful industrial software. In terms of real-time performance, through the DDS component and the modification of the traditional microservices technical framework, this technology is superior to native microservices in terms of real-time performance. Attached Figure Description

[0029] Figure 1 A schematic diagram of OT service component applications;

[0030] Figure 2 Runtime architecture diagram for OT service components;

[0031] Figure 3 Formal model representation;

[0032] Figure 4 Modeling industrial scenarios;

[0033] Figure 5 OT service application software package structure;

[0034] Figure 6 Development process for OT service applications;

[0035] Figure 7 Flowchart for code generation tool;

[0036] Figure 8 This is an example of an OT service with a controller component at its core. Detailed Implementation

[0037] The technical solution of the present invention will be further described below with reference to the accompanying drawings, but it is not limited thereto. Any modifications or equivalent substitutions to the technical solution of the present invention that do not depart from the spirit and scope of the technical solution of the present invention should be covered within the protection scope of the present invention.

[0038] This invention provides a method for designing and implementing service-oriented industrial software components that support time semantics, the method comprising the following steps:

[0039] Step 1: OT Application Design

[0040] Step 1.1: Familiarize yourself with and understand the relevant concepts of the industrial software component model, such as OT services, OT service applications, OT components, OT component instances, resources, systems, time semantics, etc., and understand their related rules and constraints.

[0041] Step 1.2: First, users need to divide the application scenario into functional parts, consider which OT services to design, and the functions of each OT service.

[0042] Step 1.3: After completing the design, the OT service needs to be modeled in 4diac IDE, including designing the type of OT component, external interface, kernel function, and connection relationship of OT component.

[0043] Step 1.4: All OT component types and applications that the OT application depends on need to be exported as .fbt and .sys files.

[0044] Step 2: Use a code generation tool to generate the OT service application.

[0045] Step 2.1: Understand and deploy the code generation tool.

[0046] Step 2.2: Place the .fbt and .sys files exported in Step 1.4 into the input folder in the root directory of the code generation tool.

[0047] Step 2.3: After the code generator performs dependency checks, type generation, application generation, and configuration generation, an OT service application is obtained. During dependency checks, it is necessary to ensure that the .fbt and .sys files placed in the input folder in the root directory meet the dependency requirements.

[0048] Step 2.4: Copy the generated project from the output folder to the custom project path.

[0049] Step 3: Deployment and Operation of OT Service Applications

[0050] Step 3.1: Understand and deploy basic development environments such as Java 17, Maven, and Spring Boot.

[0051] Step 3.2: Download and compile OpenDDS, and familiarize yourself with its related concepts and constraints.

[0052] Step 3.3: Use DDS-related tools to compile the topic.idl file in the idl directory of the custom project path, and place the generated dynamic link library in a directory under the environment variable path.

[0053] Step 3.4: Configure the parameters in the OT service, set the service deployment node and DDS runtime configuration parameters, and modify the pom file to ensure that the path of the DDS topic-related JAR dependencies is consistent with the path of the JAR obtained by compiling topic.idl in step 3.3.

[0054] Step 3.5: Start each OT service in sequence and wait for the services to discover each other.

[0055] Step 3.6: Control the overall application and observe its actions or outputs through the RESTful API reserved by the OT service.

[0056] Figure 1 This is a schematic diagram of an OT service component application. The industrial software component application designed in this invention is a distributed architecture that can be deployed on end devices or servers. Each OT service is implemented using microservice architecture technologies and contains OT components designed according to the IEC 61499 standard. Each OT service is connected via DDSDataBus, and the transmission of events and data is achieved through a pub / sub mechanism.

[0057] Figure 2This paper describes the runtime architecture of the OT service component application. The underlying operating system can be a modern operating system such as Linux / Windows, running a Java 17 virtual machine on top of the system and communicating and calling OpenDDS through JNI technology. On the Java 17 virtual machine, this invention implements a state machine based on Stateless4j and provides a series of industrial communication protocol tool libraries and a custom thread scheduler, which support the three different types of functional blocks in the IEC 61499 standard. Based on OpenDDS, a custom toolkit is used to achieve its integration with OT services. Finally, the OT service components and the DDS connection relationship together constitute the OT service, and the OT services are then interconnected to form complete industrial software.

[0058] Figure 3 The proposed industrial software component model is described in a formalized form. Application-related concepts include System, Resource, and Device. Device refers to a real device in the physical world, and Resource refers to resources within the device, such as virtual machines, containers, and control groups. Each resource can uniformly manage its internal processes. Definitions are then provided for OT components and service-related concepts, including OT service applications, DDS connections, OT services, OT components, and time semantics.

[0059] Figure 4 An industrial scenario was modeled. The task flow of this scenario can be described as follows: After the main controller starts the task, the cart moves from its initial position to in front of robotic arm number one. Robotic arm number one removes the workpiece to be processed from the unprocessed shelf according to the task number and places it on the cart. Next, the cart transports the workpiece to the workbench, where robotic arm number two places it on the workbench. Subsequently, a laser printer engraves a custom pattern onto the workpiece according to the customer's requirements, and robotic arm number two places the processed workpiece back onto the cart. Finally, the cart transports the processed workpiece to robotic arm number three, which removes the processed workpiece and places it at the designated number on the shelf, and the cart returns to its initial position. This invention mainly focuses on modeling robotic arm equipment with the most complex controller operations and functions.

[0060] Figure 5 This describes the structure of the OT service application package. The types section contains all the functional blocks generated by the .fbt file. The idl section contains the DDS topic message definition file topics.idl and the generated jar file topics.jar. There are also some .cpp, .h, .java, and .class files generated during the compilation process, which are not listed here. The Controller_0 module represents the OT service package.

[0061] Figure 6 This describes the OT service application development process. First, users need to design the functions and modules of the application scenario. Next, they need to model the OT service in the 4diac IDE, including designing the types of OT components, external interfaces, kernel functions, and the connection relationships between OT components. All OT component types and applications that the application depends on need to be exported as .fbt and .sys files. After dependency checking, type generation, application generation, and configuration generation by the code generator, a set of OT service applications is obtained. After the algorithms in the service interface function blocks are filled in, the OT service is configured and can be deployed and run.

[0062] Figure 7 This is a flowchart of the code generation tool. After generation begins, the script first clears the previously generated code and automatically checks whether these files satisfy dependencies, specifically: whether all types used in the .sys application files are defined in the .fbt files, and whether types used in the function block network of composite function blocks are defined in other .fbt files. If dependencies are not satisfied, generation exits. After the dependency check passes, the corresponding classes or packages are generated according to the function block type. Next, the microservice code for each function block component in the application is generated, including the yml configuration file, pom dependency file, function block classes for each microservice application component, API classes, and DDS utility classes. Finally, based on the connection relationships between function block instances recorded in the .sys file, the IDL topic message structure file in the DDS protocol is generated.

[0063] Figure 8 An example of an OT service with a controller component at its core is shown.

Claims

1. A method for designing and implementing service-oriented industrial software components that support temporal semantics, characterized in that... The method includes the following steps: Step 1: OT Application Design Step 1.1: Familiarize yourself with and understand the relevant concepts of the industrial software component model, as well as its relevant rules and constraints. In the industrial software component model, the application-related concepts include System, Resource, and Device, while the OT component and service-related concepts include OT service application, DDS connection, OT service, OT component, and time semantics. Step 1.2: Divide the application scenarios into functional parts, consider which OT services to design, and the functions of each OT service; Step 1.3: After completing the design, model the OT service in 4diac IDE, including designing the types of OT components, external interfaces, kernel functions, and connection relationships of OT components; Step 1.4: Export all OT component types and applications that the OT application depends on as .fbt and .sys files; Step 2: Use a code generation tool to generate the OT service application. Step 2.1: Understand and deploy the code generation tool; Step 2.2: Place the .fbt and .sys files exported in Step 1.4 into the input folder in the root directory of the code generation tool; Step 2.3: After dependency checking, type generation, application generation, and configuration generation by the code generator, an OT service application is obtained. During dependency checking, it is necessary to ensure that the .fbt and .sys files placed in the root directory's input folder meet the dependency relationships. The specific steps are as follows: The script first clears the previously generated code and automatically checks whether these files meet the dependencies, i.e., whether the types used in the .sys application files are all defined in the .fbt files, and whether the types used in the functional block network of the composite functional block are defined in other .fbt files. If a dependency is not met, the generation process exits. After the dependency check passes, the corresponding classes or packages are generated according to the functional block type. Then, the microservice code for each functional block component in the application is generated, including the yml configuration file, pom dependency file, functional block classes, API classes, and DDS utility classes for each microservice application component. Finally, based on the connection relationships between functional block instances recorded in the .sys file, the IDL topic message structure file in the DDS protocol is generated. Step 2.4: Copy the generated project from the output folder to the custom project path; Step 3: Deployment and Operation of OT Service Applications Step 3.1: Understand and deploy the basic development environment of Java 17, Maven, and Spring Boot; Step 3.2: Download and compile OpenDDS, and familiarize yourself with its related concepts and constraints; Step 3.3: Use DDS-related tools to compile the topic.idl file in the idl directory of the custom project path, and place the generated dynamic link library in a directory under the environment variable path; Step 3.4: Configure the service deployment node and DDS runtime configuration parameters by configuring the parameters in the OT service, and modify the pom file to ensure that the path of the DDS topic-related JAR dependencies is consistent with the path of the JAR obtained by compiling topic.idl in step 3.3; Step 3.5: Start each OT service in sequence and wait for the services to discover each other; Step 3.6: Control the overall application and observe its actions or outputs through the RESTful API reserved by the OT service.

2. The method for designing and implementing service-oriented industrial software components supporting time semantics according to claim 1, characterized in that... Each OT service is connected via DDS DataBus, and events and data are transmitted through a pub / sub mechanism.

Images