Service industrial software component design and implementation method supporting time semantics

Abstract

The invention discloses a service industrial software component design and implementation method supporting time semantics. The method comprises the following steps: step 1, OT application design; 2, the code generation tool generates an OT service application; and step 3, OT service application deployment and operation. The industrial software constructed by the method has expandability, better ecology and better real-time characteristics. When the business demand is changed, only the connection relationship between the components needs to be dynamically constructed, and the components which are already developed do not need to be modified; by utilizing the IT technology, more comprehensive and powerful industrial software can be constructed by virtue of a series of frameworks and components such as AI, cloud native, big data and the like; in the aspect of real-time performance, through the DDS component and transformation of the technical framework of the traditional micro-service, compared with the original micro-service, the technology is better in the aspect of real-time performance.

Description

Technical Field

[0001] The present invention belongs to the fields of operation technology and information technology, and relates to an industrial software component design and implementation method, and specifically to a service-oriented industrial software component design and implementation method that supports time semantics. Background Art

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

[0003] Most current industrial systems rely on solutions from specific vendors, who provide hardware devices and their control kernels as black boxes to customers, that is, vendors only provide limited scalability and proprietary application programming interfaces. In order to facilitate industrial application development, the industry proposed the IEC 61499 standard, which defines a set of software components for distributed information and control systems. The use of a component-based approach to software development not only improves software reliability, but also helps integrate applications and improve device interoperability by defining a unified data format. However, this standard still has certain defects in the field of industrial software service. One important point is that from the perspective of determinism and time order, time semantics is not well addressed in the IEC 61499 standard.

[0004] Under the traditional industrial software framework, industrial applications are often written in languages ​​such as ST and ladder diagrams. Such development means that its 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 development efficiency is relatively low.

[0005] In the process of technological integration between OT and IT fields, the following challenges are faced: there are barriers to integration between software and hardware devices provided by different suppliers, making it difficult to promote and use a unified industrial software component model; the relevant technologies in the IT / OT domains vary greatly, making it difficult for relevant personnel to uniformly develop complete cross-domain applications. Summary of the invention

[0006] The present invention provides a method for designing and implementing service-oriented industrial software components that supports time semantics. The method has a series of characteristics such as distribution, scalability, ecological compatibility, event-driven, deterministic, and time semantics, and can well solve the above-mentioned technical problems existing in the process of technical integration between OT and IT fields.

[0007] The objective of the present invention is achieved through the following technical solutions:

[0008] A method for designing and implementing a service-oriented industrial software component supporting time semantics includes the following steps:

[0009] Step 1: OT Application Design

[0010] Step 1.1: Be familiar with and understand the concepts of industrial software component models, and understand their related rules and constraints;

[0011] Step 1.2: Functionally divide the application scenarios, 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 type of OT components, external interfaces, core 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: Code generation tool generates OT service application

[0015] Step 2.1: Understand and deploy the use of code generation tools;

[0016] Step 2.2: Put 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 checking, type generation, application generation, and configuration generation, a set of OT service applications is obtained. During the dependency checking, it is necessary to ensure that the .fbt and .sys files placed in the root directory input folder meet the dependency relationship;

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

[0019] Step 3: OT service application deployment and operation

[0020] Step 3.1: Understand and deploy Java17, Maven, and Spring Boot basic development environment;

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

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

[0023] Step 3.4: By configuring the parameters in the OT service, set the nodes for service deployment and the DDS runtime configuration parameters, and modify the pom file so that the jar dependencies related to the DDS topic are 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 turn and wait for the services to discover each other;

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

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

[0027] 1. By using the method of the present invention, on the basis of industrial software designed according to the formal model, OT service components using microservice technology can be written according to the method, and convenient deployment can be carried out 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 the present invention has scalability, better ecology and better real-time characteristics. When business needs change, it is only necessary to dynamically build the connection relationship between components, and there is no need to modify the components that have been developed; using IT technology, 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 DDS components and the transformation of the technical framework of traditional microservices, this technology is better in real-time performance than native microservices. BRIEF DESCRIPTION OF THE DRAWINGS

[0029] Figure 1 It is a schematic diagram of OT service component application;

[0030] Figure 2 It is the runtime architecture diagram of OT service components;

[0031] Figure 3 To formalize the model representation;

[0032] Figure 4 Modeling industrial scenarios;

[0033] Figure 5 Applying software package structures for OT services;

[0034] Figure 6 Develop processes for OT service applications;

[0035] Figure 7 Generate tool flow chart for code;

[0036] Figure 8 This is an example of an OT service with the controller component as the core. DETAILED DESCRIPTION

[0037] The technical solution of the present invention is further described below in conjunction with the accompanying drawings, but is not limited thereto. Any modification or equivalent replacement of the technical solution of the present invention without departing from the spirit and scope of the technical solution of the present invention should be included in the protection scope of the present invention.

[0038] The present invention provides a method for designing and implementing a service-oriented industrial software component supporting time semantics, the method comprising the following steps:

[0039] Step 1: OT Application Design

[0040] Step 1.1: Be familiar 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 scenarios into functions, consider which OT services to design, and the functions of each OT service.

[0042] Step 1.3: After completing the design, you need to model the OT service in 4diac IDE, including designing the type of OT components, external interfaces, core functions, and connection relationships of OT components.

[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: Code generation tool generates OT service application

[0045] Step 2.1: Understand and deploy the use of code generation tools.

[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 checking, type generation, application generation, and configuration generation, a set of OT service applications is obtained. During the dependency checking, it is necessary to ensure that the .fbt and .sys files placed in the root directory input folder meet the dependency relationship;

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

[0049] Step 3: OT service application deployment and operation

[0050] Step 3.1: Understand and deploy basic development environments such as Java17, 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 in 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 nodes for service deployment and DDS runtime configuration parameters, and modify the pom file so that the jar dependencies related to the DDS topic are 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 turn and wait for the services to discover each other.

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

[0056] Figure 1 This is a schematic diagram of the OT service component application. The industrial software component application designed by the present invention is a distributed architecture that can be deployed on a terminal device or on a server. Each OT service is implemented with the help of the relevant technology of the microservice architecture, which contains OT components designed in accordance with the IEC 61499 standard. Each OT service is connected through DDSDataBus, and the transmission of events and data can be realized through the pub / sub mechanism.

[0057] Figure 2The runtime architecture of OT service component applications is described. The underlying operating system can be a modern operating system such as Linux / Windows, on which a Java17 virtual machine runs and is associated and called with OpenDDS through JNI technology. On the Java17 virtual machine, the present invention implements a state machine based on Stateless4j, and provides a series of tool libraries for industrial communication protocols and a custom thread scheduler, through which three different types of function blocks in the IEC 61499 standard are supported. On the basis of OpenDDS, its combination with OT services is realized through a custom toolkit. Finally, the OT service component and the DDS connection relationship together constitute the OT service, and the OT services are then associated with each other to form a complete industrial software.

[0058] Figure 3 The industrial software component model proposed in this invention is described in a formalized form. The concepts related to applications include system, resource, and device. Device refers to real devices in the physical world, and resource refers to some resources in the device, such as virtual machines, containers, control groups, etc. Each resource can uniformly manage and control the internal processes. Subsequently, definitions of OT components and service-related concepts are provided, including concepts such as 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 trolley moves from the initial position to the front of the No. 1 robotic arm. The No. 1 robotic arm takes the object to be processed from the unprocessed shelf according to the task number and places it on the trolley. Next, the trolley transports the object to the workbench position, and the No. 2 robotic arm places it on the workbench. Then, the laser printer engraves the custom pattern on the object according to customer needs, and the No. 2 robotic arm places the processed object on the trolley. Finally, the trolley transports the processed object to the No. 3 robotic arm. The No. 3 robotic arm takes the processed object and places it at the designated number on the shelf, and the trolley returns to the initial position. The present invention mainly models the controller business and the most complex robotic arm equipment.

[0060] Figure 5 Describes the structure of the OT service application software package. Types contains all the function blocks generated by .fbt. IDL 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 one by one. The Controller_0 module represents the software package of the OT service.

[0061] Figure 6 The OT service application development process is described. First, the user needs to design the functions and modules of the application scenario, and then model the OT service in the 4diac IDE, including designing the type of OT components, external interfaces, kernel functions, and connection relationships of OT components. All OT component types and applications of the application need to be exported as .fbt and .sys files. After the code generator performs dependency checking, type generation, application generation, and configuration generation, a set of OT service applications is obtained. After the algorithm in the service interface function block is filled, it can be deployed and run after the OT service is configured.

[0062] Figure 7 It is a flowchart of the code generation tool. After starting the generation, the script will first clear the previously generated code and automatically detect whether these files meet the dependencies, that is, whether the types used in the .sys application file are defined in the .fbt, and whether the types used in the function block network of the composite function block are defined in other .fbt files. If it is found that the dependency is not satisfied, the generation is exited. After the dependency check passes, the corresponding classes or software packages are generated according to the function block type. After that, the microservice code for each function block component in the application is generated, including the yml configuration file, the pom dependency file, the function block class of each microservice application component, the API class, and the dds tool class. Finally, the idl topic message structure file in the DDS protocol is generated based on the connection relationship between the function block instances recorded in .sys.

[0063] Figure 8 Shows an example of OT service with controller component as the core.

Claims

1. A design and implementation method for service-oriented industrial software components supporting time semantics, characterized in that The method comprises the following steps: Step 1: OT Application Design Step 1.1: Be familiar with and understand the concepts of industrial software component models, and understand their related rules and constraints; Step 1.2: Functionally divide the application scenarios, 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 type of OT components, external interfaces, core 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: Code generation tool generates OT service application Step 2.1: Understand and deploy the use of code generation tools; Step 2.2: Put 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 the code generator performs dependency checking, type generation, application generation, and configuration generation, a set of OT service applications is obtained. During the dependency checking, it is necessary to ensure that the .fbt and .sys files placed in the root directory input folder meet the dependency relationship; Step 2.4: Copy the generated project in the output folder to the custom project path; Step 3: OT service application deployment and operation Step 3.1: Understand and deploy Java17, Maven, and Spring Boot basic development environment; Step 3.2: Download and compile OpenDDS, and get familiar with its related concepts and constraints; Step 3.3: Use DDS related tools to compile the topic.idl file in the idl directory in the custom project path, and place the generated dynamic link library in a directory under the environment variable path; Step 3.4: By configuring the parameters in the OT service, set the nodes for service deployment and the DDS runtime configuration parameters, and modify the pom file so that the jar dependencies related to the DDS topic are consistent with the path of the jar obtained by compiling topic.idl in step 3.3; Step 3.5: Start each OT service in turn and wait for the services to discover each other; Step 3.6: Control the entire application through the RESTful API reserved by the OT service and observe the application's actions or outputs.

2. The method for designing and implementing a service-oriented industrial software component supporting time semantics according to claim 1 is characterized in that In the industrial software component model, application-related concepts include system, resource, and device; and OT components and service-related concepts include OT service application, DDS connection, OT service, OT component, and time semantics.

3. The method for designing and implementing service-oriented industrial software components supporting time semantics according to claim 1 is characterized in that Each OT service is connected through DDSDataBus, and the transmission of events and data is achieved through the pub / sub mechanism.

4. The method for designing and implementing a service-oriented industrial software component supporting time semantics according to claim 1 is characterized in that The specific steps of step 2.3 are as follows: the script first clears the previously generated code and automatically detects whether these files meet the dependencies, that is, whether the types used in the .sys application file are all defined in the .fbt, and whether the types used in the function block network of the composite function block are defined in other .fbt files. If it is found that the dependencies are not met, the generation is exited; after the dependency check is passed, the corresponding classes or software packages are generated according to the function block types; then, the microservice code of each function block component in the application is generated, including the yml configuration file, the pom dependency file, the function block class of each microservice application component, the API class and the dds tool class; finally, according to the connection relationship between the function block instances recorded in .sys, the idl topic message structure file in the DDS protocol is generated.

Images