Intelligent control method and system of industrial logic based on semantic processing

Abstract

This invention discloses an intelligent control method and system for industrial logic based on semantic processing. The invention relates to the field of semantic processing technology. It marks the data version corresponding to a data tree, compares this data version with a preset target version, outputs the corresponding version difference content, traces the version difference content to determine the corresponding difference patch, and determines the corresponding row-level change information based on the parsing of the difference patch, thus improving the accuracy of the row-level change information. The difference tree is loaded into a visualization interface, displaying the change status of each node in the difference tree. Developers can dynamically reconstruct the tree structure based on user selections to form a merged tree semantic model. The merged tree semantic model is then reverse-serialized into an industrial control logic file of the corresponding format to achieve version synchronization, improving the accuracy of the tree semantic model and the intelligent control effect of the industrial control logic file.

Description

Technical Field

[0001] This invention relates to the field of semantic processing technology, and in particular to an intelligent control method and system based on semantic processing industrial logic. Background Technology

[0002] In the development and maintenance of industrial control systems, control logic is typically stored in various file formats (such as JSON, XAML, TXT, etc.). With the development of industrial intelligence, collaborative development by multiple developers and multiple version iterations have become the norm. The analysis and merging of differences in logic files has become a core requirement. However, existing technologies have the following significant problems in practical applications:

[0003] Existing differential processing technologies often lack the ability to understand the unified semantics of industrial control logic data in different formats. Due to the lack of a unified tree node conversion mechanism, it is impossible to effectively construct a data tree containing semantic levels (such as equipment layer, functional layer, and program layer). This makes it difficult to control the data tree as a whole when processing multi-source heterogeneous data, which affects the control of the data tree and results in poor accuracy of row-level change information, thus failing to guarantee the intelligent control effect of industrial control logic files. Summary of the Invention

[0004] The purpose of this invention is to overcome the shortcomings of the prior art. This invention provides an intelligent control method and system based on semantic processing industrial logic.

[0005] This invention provides an intelligent control method for industrial logic based on semantic processing, comprising:

[0006] Collect industrial control logic data in different formats, convert the data according to the corresponding format type, output multiple tree nodes, and construct a data tree containing semantic hierarchy based on multiple tree nodes;

[0007] The data version corresponding to the data tree is marked, and the data version is compared with the preset target version. The corresponding version difference content is output, and the corresponding difference patch is determined by tracing the version difference content. The corresponding row-level change information is determined based on the parsing of the difference patch.

[0008] The row-level change information is mapped, and during the mapping process, it is identified as semantic change content. The corresponding semantic difference type is marked, and the corresponding difference tree is generated by combining each tree node and data tree. The semantic difference information is then presented in the visualization dimension.

[0009] The system collects the corresponding visualization interface and loads the difference tree into it, displaying the change status of each node in the difference tree. It supports developers to dynamically reconstruct the tree structure based on the selection results through checkbox operations, forming a merged tree semantic model. The merged tree semantic model is then reverse-serialized into an industrial control logic file of the corresponding format to achieve version synchronization.

[0010] This invention provides an intelligent control system based on semantic processing industrial logic, which is applied to the aforementioned intelligent control method based on semantic processing industrial logic. The intelligent control system based on semantic processing industrial logic includes:

[0011] The data tree module is used to collect industrial control logic data in different formats, convert the data according to the corresponding format type, and output multiple tree nodes. Based on the multiple tree nodes, a data tree containing semantic hierarchy is constructed.

[0012] The row-level change information module is used to mark the data version corresponding to the data tree, compare the data version with the preset target version, output the corresponding version difference content, determine the corresponding difference patch by tracing the version difference content, and determine the corresponding row-level change information based on the parsing of the difference patch.

[0013] The difference tree module is used to map the row-level change information, identify the semantic change content during the mapping process, mark the corresponding semantic difference type, generate the corresponding difference tree by combining each tree node and data tree, and present the semantic difference information in the visualization dimension.

[0014] The dynamic reconstruction module is used to collect data from the corresponding visualization interface and load the difference tree into the visualization interface, displaying the change status of each node in the difference tree. It supports developers to dynamically reconstruct the tree structure based on the selection results through checkbox operations, forming a merged tree semantic model. The merged tree semantic model is then reverse-serialized into an industrial control logic file of the corresponding format to achieve version synchronization.

[0015] Compared with the prior art, the beneficial effects of the present invention are:

[0016] (1) Collect industrial control logic data in different formats, and convert the data according to the corresponding format type to output multiple tree nodes. Based on the multiple tree nodes, construct a data tree containing semantic hierarchy; mark the data version corresponding to the data tree, compare the data version with the preset target version, output the corresponding version difference content, trace along the version difference content to determine the corresponding difference patch, and determine the corresponding row-level change information based on the parsing of the difference patch. Multiple tree nodes are introduced to control the data tree and improve the accuracy of row-level change information.

[0017] (2) Map the row-level change information and determine it as semantic change content during the mapping process. Mark the corresponding semantic difference type, generate the corresponding difference tree by combining each tree node and data tree, and present the semantic difference information in the visualization dimension. Collect the corresponding visualization interface and load the difference tree into the visualization interface to display the change status of each node in the difference tree. Support developers to dynamically reconstruct the tree structure based on the developer's selection operation to form a merged tree semantic model. Reverse serialize the merged tree semantic model into an industrial control logic file of the corresponding format to achieve version synchronization. The difference tree is introduced and the difference tree is visualized to realize the dynamic reconstruction of the tree structure, which improves the accuracy of the tree semantic model and the intelligent control effect of the industrial control logic file. Attached Figure Description

[0018] Figure 1 This is a flowchart illustrating the intelligent control method for industrial logic based on semantic processing in an embodiment of the present invention.

[0019] Figure 2 This is a flowchart illustrating step S11 in the intelligent control method for industrial logic based on semantic processing in this embodiment of the invention.

[0020] Figure 3 This is a flowchart illustrating step S12 in the intelligent control method for industrial logic based on semantic processing in this embodiment of the invention.

[0021] Figure 4 This is a flowchart illustrating step S13 in the intelligent control method for industrial logic based on semantic processing in this embodiment of the invention.

[0022] Figure 5 This is a flowchart illustrating step S14 in the intelligent control method for industrial logic based on semantic processing in this embodiment of the invention.

[0023] Figure 6 This is a schematic diagram of the structural composition of an intelligent control system based on semantic processing industrial logic in an embodiment of the present invention. Detailed Implementation

[0024] The technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention.

[0025] Please see Figures 1 to 6 A semantic processing-based intelligent control method for industrial logic, applied to semantic processing scenarios; the semantic processing-based intelligent control method for industrial logic includes:

[0026] Step S11: Collect industrial control logic data in different formats, convert the data according to the corresponding format type, output multiple tree nodes, and construct a data tree containing semantic hierarchy based on the multiple tree nodes;

[0027] Step S12: Mark the data version corresponding to the data tree, compare the data version with the preset target version, output the corresponding version difference content, determine the corresponding difference patch by tracing the version difference content, and determine the corresponding row-level change information based on the parsing of the difference patch.

[0028] Step S13: Map the row-level change information, identify it as semantic change content during the mapping process, mark the corresponding semantic difference type, generate the corresponding difference tree by combining each tree node and data tree, and present the semantic difference information in the visualization dimension;

[0029] Step S14: Collect the corresponding visualization interface and load the difference tree into the visualization interface to display the change status of each node in the difference tree. Developers can dynamically reconstruct the tree structure based on the selection results to form a merged tree semantic model. The merged tree semantic model is then reverse-serialized into an industrial control logic file of the corresponding format to achieve version synchronization.

[0030] refer to Figure 2 In step S11, the specific steps are as follows:

[0031] S111: Acquire an extensible parser framework, input multiple industrial control logic data into the parser framework, mark the format type of multiple industrial control logic data, perform deep parsing of the industrial control logic data and the corresponding format type, and trigger corresponding data transformation during the parsing process to output the corresponding tree node;

[0032] S112: Obtain multiple tree nodes in the same spatial system, perform multi-factor fusion on the multiple tree nodes, and determine a data tree containing semantic layers during the fusion process. The semantic layers cover the device layer, functional layer and program layer.

[0033] In the embodiments of this application, a scalable parser framework is acquired, multiple industrial control logic data are input into the parser framework, and the format types of the multiple industrial control logic data are marked. The industrial control logic data and the corresponding format types are deeply parsed, and the corresponding data conversion is triggered during the parsing process to output the corresponding tree nodes, thus introducing the output of the corresponding tree nodes.

[0034] At this point, a parser framework based on the "driver-plugin" model is introduced. The framework kernel defines a unified abstract syntax tree (AST) interface specification, while the specific parsing logic is encapsulated in independent parsing plugins. The framework has the ability to dynamically load at runtime, and can flexibly expand the parsing module according to the customized needs of the industrial site (such as the private logic description language of a specific manufacturer) without refactoring the core system, thereby ensuring the system's adaptability to complex scenarios such as industrial logic.

[0035] The system receives multiple industrial control logic data streams through the data access layer. Before the data enters the parsing engine, the system uses "feature retrieval" technology, which combines file extensions (such as .json, .xaml) and file header magic number for double verification to automatically mark the data format type. For mixed description files commonly found in industrial logic, the system marks them as "composite" and triggers a multi-level parsing process to ensure accurate identification of the data source.

[0036] Based on the format type of the tags, the framework schedules the corresponding parser to perform deep parsing: For structured data (such as JSON): the parser performs recursive descent parsing, breaking the data stream into a token sequence, identifying key-value pairs and array structures, and triggering "objectification transformation" to map the flat text stream into node objects with parent-child reference relationships; For markup language data (such as XAML): the parser extracts element tags, attributes, and nesting relationships based on the Document Object Model (DOM) theory, triggering "structured mapping," focusing on preserving the binding relationship between interface elements and control logic; For plain text data: the parser performs lexical analysis and line segmentation, triggering "serialization mapping," encapsulating each line of logical instructions into an independent leaf node, and accurately recording the line number index for subsequent tracking.

[0037] During the parsing and conversion process, the system generates standardized tree nodes in real time; each node object encapsulates metadata information, including a unique node identifier, semantic type, original value, source code line number, and parent-child level pointers; the final output is a set of tree nodes that are free from the limitations of the original file format and have unified semantic features.

[0038] Specifically, in the intelligent control scenario of industrial logic, the control core of a large-scale automated production line involves three heterogeneous data sources: a JSON file describing the device interface configuration, a XAML file defining the human-machine interface, and a TXT script file containing the core control instruction set; the system activates an extensible parser framework and simultaneously accesses the above three data sources.

[0039] After recognizing JSON files, the system marks them as "structured configuration type." The parser recursively reads device parameters, converting data such as "servo motor speed" and "IO port mapping" into configuration-type tree nodes. For XAML files, the system marks them as "interface description type." The parser extracts button events and display controls, converting them into interactive-type tree nodes while preserving the binding attributes between controls and underlying logic variables. For TXT scripts, the system marks them as "instruction sequence type." The parser splits control instructions line by line, converting lines of code such as "start signal judgment" and "alarm logic jump" into logic-type tree nodes. These nodes, originating from different file formats, have all had their original syntactic shells stripped away, uniformly transforming them into standard tree nodes containing semantic information (such as "this is an input parameter" or "this is a jump instruction"). This provides standardized basic components for subsequently building a complete data tree containing device, functional, and program layers.

[0040] Furthermore, multiple tree nodes are acquired within the same spatial system. Multi-factor fusion is performed on these multiple tree nodes, and a data tree containing semantic levels is determined during the fusion process. The semantic levels cover the device layer, functional layer, and program layer, which is compatible with the overall consideration of multi-factor fusion of multiple tree nodes and ensures the accuracy of the data tree containing semantic levels.

[0041] At this point, the system extracts multiple sets of tree nodes generated by S111 from the output buffer of the parsing framework. Although these nodes have been standardized and encapsulated (including attributes such as name, row number, value, and type), they are still logically discrete "islands". The system loads these nodes into the same memory space system to build a unified topology construction field, providing a spatial basis for subsequent cross-domain associations.

[0042] In a unified topology construction field, the system adopts a multi-factor fusion approach to perform deep association processing on discrete nodes. The fusion process mainly relies on the following three key dimensions: Reference dependency analysis: scanning the attribute fields of nodes to identify cross-file type reference identifiers; for example, parsing the "Binding" attribute in a XAML node to find the variable source in its corresponding JSON configuration node and establish cross-tree link relationships; Semantic similarity calculation: based on the text similarity of node names and context, identifying the membership relationship between functional nodes and program nodes, and resolving the matching gap caused by namespace inconsistencies; Logical topology reconstruction: breaking the physical storage boundaries of the original files, and reorganizing related nodes into parent-child or sibling structures according to the execution flow (input > processing > output) and hierarchical relationship (hardware > function > code) of the control logic.

[0043] After fusion processing, the system generates the final semantic data tree. This tree structure is strictly divided according to the abstract hierarchy of industrial control logic: Device layer: located at the bottom or root of the data tree, it encapsulates physical device interfaces, IO port mappings, and hardware parameter configurations, and is the physical carrier of control logic; Functional layer: located in the middle layer, it encapsulates specific process units and control modules (such as PID control and logic interlocks), reflecting the functional intent of the control system; Program layer: located at the top or leaves of the data tree, it contains specific instruction sequences, code logic implementation, and script execution flow, and is the final implementation form of control logic.

[0044] Specifically, the system obtains three types of node sets output by S111: the “IO_Config” node group from JSON, the “UI_Monitor” node group from XAML, and the “Control_Logic” node group from TXT, and places them in the same logical topology space.

[0045] The system detected that the "Start Button" control in the XAML node contained a binding reference to the variable "Motor_Start_Signal". Through reference dependency analysis, the system automatically located the configuration item named "Motor_Start_Signal" in the JSON node set and established a semantic connection between the two. At the same time, the system analyzed the TXT script node and found that the "jump" instruction referenced the signal variable. Based on the logical flow, the system associated the JSON configuration node as a data source prerequisite for the TXT instruction node.

[0046] The system constructs a complete semantic data tree: Device layer: composed of nodes parsed from JSON, such as "servo motor port" and "sensor address", serving as the root node or infrastructure node of the entire tree and providing underlying data support; Functional layer: composed of integrated logical modules, such as the "automatic operation mode" functional node, which aggregates related XAML interface elements and TXT logical blocks to form an intermediate layer; Program layer: specific TXT script instruction nodes (such as "wait for signal" and "delay trigger") are attached as leaf nodes under the functional layer, completing a complete semantic loop from hardware configuration to interface interaction to code execution.

[0047] refer to Figure 3 In step S12, the specific steps are as follows:

[0048] S121: Detect the data and determine the data version corresponding to the data tree during the detection process. At the same time, obtain the preset target version, trigger the comparison between the data version and the preset target version in the same data environment, and determine the corresponding difference markers during the comparison process. Then, determine the corresponding version difference content by tracing each difference marker.

[0049] S122: In the version difference content, multiple key contents are identified based on the detection of version difference content, and the corresponding patch areas are determined according to the tracing of each key contents. The patch areas are fused by multiple factors, and the corresponding difference patches are determined in the fusion process. The difference patches are parsed, and a full lifecycle management mechanism is introduced in the parsing process, and the corresponding row-level change information is determined.

[0050] In the embodiments of this application, the data is detected, and the data version corresponding to the data tree is determined during the detection process. At the same time, a preset target version is obtained, and a comparison between the data version and the preset target version is triggered in the same data environment. During the comparison process, the corresponding difference markers are determined, and the corresponding version difference content is determined by tracing along each difference marker. This approach takes into account the overall consideration of tracing each difference marker and ensures the accuracy of the corresponding version difference content.

[0051] At this point, the system performs integrity verification and version fingerprint extraction on the constructed semantic data tree; the detection process traverses all nodes of the data tree and uses a hash method to calculate the topological fingerprint of the tree structure, which uniquely represents the current logical structure state; the system reads the metadata attributes of the root node or the associated version control log, extracts the version identifier corresponding to the current data tree, and determines it as the current "data version".

[0052] Based on the developer's collaboration request or merge task configuration, the system retrieves and pulls a preset "target version" from the version repository. This target version represents the remote branch baseline or historical stable version in collaborative development. At the same time, the system loads the logical file corresponding to the target version and uses the same parsing and fusion mechanism described in S111-S112 to reconstruct the comparison data tree of the target version in memory, ensuring that subsequent comparisons are performed on the same semantic dimension.

[0053] The system places the current data tree and the target data tree in the same isolated data environment (memory topology space) for structured comparison. The comparison method adopts a depth-first search strategy, comparing the names, types, values, and parent-child reference relationships of nodes layer by layer. During the comparison process, the system generates "difference markers" in real time for nodes with attribute discrepancies or structural mismatches. The difference markers not only record the position of the node, but also mark its changed attributes, such as "inconsistent values", "missing nodes", or "level changes", thus forming a difference marker map covering the entire tree.

[0054] Based on the generated difference marker map, the system initiates a reverse tracing mechanism; the system extracts specific change payloads along the node paths pointed to by the difference markers; the tracing process maps abstract structural differences into specific logical change descriptions, namely "version difference content", which includes a comparison of node values ​​before and after the change, the affected layer range (whether it involves the device layer, functional layer or program layer), and the timestamp and operator information of the change, thereby providing a precise location index for subsequent parsing of difference patches.

[0055] Specifically, the system examines the data tree generated by S112, which integrates the fusion logic of JSON configuration, XAML interface and TXT script; the system reads its root node metadata and confirms that the current working version is "V2.1_Dev", which contains the servo motor acceleration parameters that the engineer just modified.

[0056] The system retrieves the preset target version "V2.0_Release" (remote main branch version) and reconstructs the V2.0 version's data tree in memory. This tree represents the stable logical state of the current production line. In a unified data environment, the system compares the two trees. At the device level, the system detects a difference in the nodes corresponding to the JSON. Because the "maximum speed of the servo motor" parameter was changed from 3000 rpm to 3500 rpm in version V2.1, the system immediately marks the node with a "modified" difference. At the program level, the system finds that a new "overload protection logic" line has been added to the TXT script node in version V2.1, while this node does not exist in version V2.0. The system marks this node with a "new" difference.

[0057] The system traces along the aforementioned difference markers to extract specific version difference content: for JSON file differences, it traces "the speed parameter on line 15 of the device interface configuration file has changed"; for TXT script differences, it traces "the control instruction set on line 102 has added overload protection judgment logic". These differences are summarized and output to provide a high-precision semantic location basis for subsequent parsing of Git difference patches, avoiding blind searching in the entire text.

[0058] Furthermore, within the version difference content, multiple key elements are identified based on the detection of these differences. Corresponding patch areas are determined by tracing each key element. These patch areas are then fused using multiple factors, and the corresponding difference patches are identified during the fusion process. These difference patches are then parsed, and a full lifecycle management mechanism is introduced during the parsing process. This process also determines the corresponding row-level change information, taking into account the overall consideration of tracing each key element and ensuring the accuracy of the corresponding patch areas. Simultaneously, multiple tree nodes are introduced to control the data tree, improving the accuracy of row-level change information.

[0059] At this point, the system performs a deep scan of the version differences output by S121. The detection method is based on a preset key feature library (such as control logic keywords, parameter threshold identifiers, and node fingerprint changes). Irrelevant format changes (such as blank lines and comment changes) are filtered out from a large number of difference descriptions. The core change points that affect the control logic are accurately identified as "key content". This key content represents substantial modifications at the system's functional level.

[0060] The system traces the path backward along the identified key content. By indexing the location coordinates of the key content in the data tree, the system locates the affected code range in the underlying version control system and delineates the "patch area". The patch area not only includes the specific lines of code that have been changed, but also covers their context dependency boundaries, ensuring the completeness of the scope of the change.

[0061] Since industrial control logic often involves cross-file associations, the system adopts a multi-factor fusion approach to integrate scattered patch areas. This process comprehensively considers the logical dependencies, temporal relationships, and topological structures between areas, eliminates overlapping or conflicting area definitions, and finally generates a structured "difference patch". This difference patch is a standard carrier describing file changes and records all change instructions from the source version to the target version.

[0062] The system calls the parsing engine to decode the difference patch. In this process, a "full lifecycle management mechanism" is introduced, which means that when parsing each line change, its metadata attributes are extracted and encapsulated synchronously, including the change initiator, timestamp, reason for change and associated work order number. The parsing engine converts the patch instructions into specific "line-level change information", accurately records the line number and content of the added, deleted or modified lines, and ensures that each line change information has complete traceability.

[0063] Specifically, the system detected differences in the output of S121 and found changes in the "servo motor speed parameters" and "overload protection logic". The system filtered out irrelevant formatting adjustments in the JSON file and identified these two substantial logical changes as the key content. For the "servo motor speed parameters", the system traced back to the underlying storage of the JSON configuration file and designated lines 12-15 as the patch area. For the "overload protection logic", the system traced back to the TXT script file and designated lines 100-105 (containing the judgment logic and jump instructions) as the patch area.

[0064] System analysis revealed that the parameter changes in the JSON and the logical changes in the TXT occurred simultaneously (parameter adjustments triggered new protection logic). Through multi-factor fusion, the system integrated these two physically separate but logically related patch areas into a unified difference patch, marked as "V2.1 version performance optimization patch".

[0065] When the system parses the difference patch, it activates the full lifecycle management mechanism. For the newly added "overload protection instruction line" in the TXT file, the parsing not only extracts the code text, but also associates it with the R&D requirement number "REQ-2026-03", the change time "2026-03-03", and the operator information. The final output line-level change information clearly indicates that the instruction IFSpeed>3500THENAlarm has been added to line 102 of the TXT script, along with complete lifecycle metadata, providing detailed decision-making basis for subsequent intelligent conflict arbitration.

[0066] refer to Figure 4 In step S13, the specific steps are as follows:

[0067] S131: Input the row-level change information into a preset mapping space, perform corresponding mapping in the mapping space, monitor the mapping process in real time, determine multiple semantic change items based on the identification of the mapping process, determine the corresponding sub-semantic change content based on the detection of each semantic change item, construct the corresponding semantic change content based on the multiple sub-semantic change content, and mark the corresponding semantic difference type.

[0068] S132: Collect each tree node and data tree, synthesize each tree node, data tree and each semantic change content through multiple factors, determine multiple corresponding difference branches during the synthesis process, determine the corresponding difference tree based on the fusion of multiple difference branches, visualize the difference tree, and present the corresponding semantic difference information through visualization dimensions.

[0069] In the embodiments of this application, the row-level change information is input into a preset mapping space, and corresponding mapping is performed in the mapping space. The mapping process is monitored in real time. Multiple semantic change items are determined based on the identification of the mapping process. The corresponding sub-semantic change content is determined based on the detection of each semantic change item. The corresponding semantic change content is constructed based on the multiple sub-semantic change content, and the corresponding semantic difference type is marked. This approach takes into account the overall consideration of detecting each semantic change item and ensures the accuracy of the corresponding sub-semantic change content.

[0070] At this point, the system loads the row-level change information parsed by S122 into the preset "semantic mapping space". This mapping space integrates a knowledge graph and syntax rule base in the field of industrial control, and defines the mapping operator from "text character features" to "logical control semantics". The mapping space acts as a translator, responsible for converting the underlying code modification instructions into the upper-level logical operation intentions.

[0071] Within the mapping space, the system starts the mapping engine to perform semantic parsing on each line of change information; at the same time, the system deploys real-time monitoring probes to track the entire mapping process; the monitoring mechanism is used to detect ambiguities or anomalies (such as undefined syntax structures) in the mapping process and record the mapping path to ensure that each line-level change can accurately correspond to the node behavior of the semantic layer.

[0072] The mapping engine identifies multiple "semantic change items" based on the characteristics of the changed lines; each item represents an independent logical change unit; for each item, the system further detects its specific attributes to determine the "sub-semantic change content"; the sub-semantic change content describes in detail the details of the change, such as the drift of parameter values, the addition or deletion of logical conditions, or the change of node paths. This process refines the coarse "text differences" into fine-grained "attribute differences".

[0073] The system aggregates multiple sub-semantic changes to construct a complete "semantic change content". Based on this, the system automatically marks the corresponding "semantic difference type" according to the degree of impact of the change on the control logic structure. Common types include: addition: introducing a new control node or logic branch; deletion: removing an existing logic unit; modification: the node structure remains unchanged, only the attribute values ​​or parameters change; movement: the node's level or position in the logic tree is moved (this is the most difficult type to identify in traditional text comparison).

[0074] Specifically, the system inputs the line-level change information output by S122—including parameter modification lines in the JSON file and instruction addition lines in the TXT script—into a preset mapping space, which pre-sets the three-layer mapping rules of industrial logic: "device-function-program".

[0075] Regarding changes to the JSON file, the mapping engine identified the line as a configuration item belonging to the "device layer"; the monitoring mechanism confirmed that the mapping path conforms to the rule of "parameters > device interface"; regarding changes to the TXT script, the mapping engine identified the line as a control instruction belonging to the "program layer"; the monitoring mechanism traced the instruction to a logical jump, which is a critical change.

[0076] The system identified a semantic change item as "servo motor parameter adjustment"; its sub-semantic change content was detected as: "the value of node 'MaxSpeed' changed from 3000 to 3500"; the system identified another semantic change item as "safety logic enhancement"; its sub-semantic change content was detected as: "a new child node 'OverloadCheck' was added under the 'RunStatus' node".

[0077] For “servo motor parameter adjustment”, the system constructs semantic change content and marks it as “modification” type, indicating that this is an update of existing node attributes and does not change the tree structure; for “safety logic enhancement”, the system constructs semantic change content and marks it as “addition” type, indicating that a new node has been inserted into the existing logic tree; in addition, if a control node is moved from “array index [2]” to “array index [5]” in the JSON file, the system can identify that this is a “move” type, rather than a simple “delete index [2]” and “add index [5]”, thereby avoiding misjudgment by traditional text comparison and ensuring the semantic integrity of industrial control logic.

[0078] Furthermore, each tree node and data tree is collected, and the tree nodes, data trees, and semantic changes are synthesized using multiple factors. During the synthesis process, multiple difference branches are determined, and the corresponding difference tree is determined based on the fusion of multiple difference branches. The difference tree is then visualized, and the corresponding semantic difference information is presented through the visualization dimension. This approach takes into account the overall consideration of the fusion of multiple difference branches, ensuring the accuracy of the corresponding difference tree.

[0079] At this point, the system extracts the original "data tree" (containing the complete logical structure of the device layer, functional layer, and program layer) built in stage S112 and the set of atomic "tree nodes" generated in stage S111 from the memory space. This step ensures that the construction of the difference tree is based on a solid semantic foundation, rather than disordered change fragments.

[0080] The system starts a multi-factor synthesis engine, using the "semantic change content" marked by S131 as a synthesis factor and injecting it into the corresponding node position of the original data tree. The synthesis method dynamically splits or extends "difference branches" in the data tree according to the change type (addition, deletion, modification, movement) and the relationship of the change. The difference branches represent the mutation path of the original tree structure under a specific version comparison, and each branch carries a specific semantic change load.

[0081] The system performs a topology fusion operation on the generated multiple difference branches. This process is not a simple linear superposition, but rather, based on the hierarchical constraints of industrial control logic (such as equipment layer changes cannot exist without equipment nodes), it re-weaves each branch into the main tree structure. The fusion engine handles the cross-references and dependencies between branches, eliminates redundant nodes, and finally generates a structurally complete and logically rigorous "difference tree". This difference tree retains the skeleton of the original logic tree and accurately carries all change information.

[0082] The system calls the visualization rendering module to map the difference tree into a graphical interface. The rendering process uses a state-color mapping mechanism to convert semantic difference types into visual signals: New nodes are highlighted in green and have a "+" icon; Deleted nodes are displayed in red, showing a dashed outline and the original value; Modified nodes are marked in orange, with "remote value" and "local value" displayed side by side next to the node; Moved nodes display a guide line connecting the original and new positions. The system fully presents semantic difference information in a visualization dimension, allowing developers to intuitively traverse change details through a tree view.

[0083] Specifically, the system extracts the data tree constructed by S112. The root node of this tree is "Automated Production Line Control System," under which are attached "Servo Configuration Node" (originating from JSON), "Monitoring Panel Node" (originating from XAML), and "Control Logic Node" (originating from TXT). For modifications to the rotation speed parameters in the JSON file, the system injects the semantic change content of the "Modification" type into the "Servo Configuration Node," splitting out a difference branch and marking it as "Parameter Change Path." For the overload protection logic added in the TXT script, the system extends a new difference branch under the "Control Logic Node" and marks it as "Logic Enhancement Path."

[0084] The system merges the aforementioned branches of difference; for example, in the functional layer, the "Logic Enhancement Path" is merged with the original "Automatic Run Mode" node to form a new composite node structure; at this time, the difference tree not only shows the underlying code changes, but also reflects the logical evolution of the functional layer - that is, the "Automatic Run Mode" has added security constraints.

[0085] In the visualization interface, the "Servo Configuration Node" in the device layer is displayed in orange (modified), and a floating window shows: remote value (3000) vs local value (3500); the "Overload Protection" node in the program layer is displayed in green (new), clearly indicating that this is a new feature added in this version iteration; through this difference tree, developers can intuitively see that this change involves device parameter adjustment (device layer) and control logic security hardening (program layer), thereby quickly assessing the impact of the change on the overall stability of the system.

[0086] refer to Figure 5 In step S14, the specific steps are as follows:

[0087] S141: Obtain the corresponding visualization interface, mark the loading channel of the visualization interface, load the difference tree along the loading channel to the visualization interface, and present the corresponding nodes in the visualization interface, as well as the change status of each node.

[0088] S142: For each node, assign corresponding permissions to each node, and trigger corresponding permission changes and corresponding check operations based on the developer's personal information to output the developer's check results. Parse the developer's check results and determine the corresponding reconstruction information during the parsing process. Dynamically reconstruct the tree structure based on the reconstruction information to output the merged tree semantic model.

[0089] S143: Perform reverse processing on the merged tree semantic model and perform sequence management in the reverse processing to output an industrial control logic file in the corresponding format, and maintain version synchronization based on the version processing of the industrial control logic file.

[0090] In the embodiments of this application, a corresponding visualization interface is obtained, the loading channel of the visualization interface is marked, the difference tree is loaded onto the visualization interface along the loading channel, and the corresponding nodes are presented in the visualization interface, and the changed state of each node is presented, thus introducing the changed state of each node.

[0091] At this point, the system calls or dynamically instantiates a dedicated "difference arbitration visualization interface" from the interface resource pool according to the current industrial control logic development environment configuration. This interface is based on the Model-View-Controller (MVC) architecture design, has the ability to render complex tree topology structures, and has a pre-set multi-dimensional window layout for displaying the device layer, functional layer and program layer.

[0092] The system scans the underlying resource interfaces of the visualization interface and marks the dedicated "loading channel". The loading channel is the transmission pipeline between the data layer and the view layer. It is responsible for handling the serialization transmission and asynchronous rendering scheduling of high-concurrency node data. By marking the channel, the system ensures that the difference tree data can be accurately and non-blockingly injected into the specified view container, avoiding interface rendering lag.

[0093] The system initiates the data injection process, pushing the difference tree model generated by S132 to the rendering engine of the visualization interface along the marked loading channel. During this process, the system performs view adaptation processing on the difference tree, converting the logical node objects in the background into visual components in the front end (such as tree cards, connecting lines, and status icons), completing the transformation from "in-memory data structure" to "interface display elements".

[0094] The rendering engine parses the attributes of the difference tree nodes, expands and presents each node layer by layer in the interface; for each node, the system dynamically applies visual styles according to its difference type to present the corresponding change status: State mapping: The system reads the "change status" attribute of the node and assigns a specific visual identifier to the node through the state-style mapping table; Information display: For nodes with conflicts or modifications, the interface displays detailed information floating next to the node or embedded in the interface, including a comparison of values ​​before and after the change, the version from which the change originated, etc.

[0095] Specifically, the system launches an interactive window called "Logical Version Conflict Resolver," which is designed with a left-right split structure. The left side displays the logic tree, and the right side displays the specific differences. The system identifies and marks the data injection interface of the tree control on the left side of the window as the "main loading channel," ensuring that the difference tree data to be transmitted can directly drive the refresh of the tree view.

[0096] The system pushes the difference tree containing all change information into the main loading channel; as the data flows through the channel, the background logic automatically parses the tree structure; for example, the "servo motor configuration" branch from the JSON file, the "status monitoring panel" branch from the XAML file, and the "automatic running logic" branch from the TXT script are loaded sequentially under the root node of the interface.

[0097] The interface displays the complete control logic tree. Under the device layer branch, the "Servo Speed ​​Parameter" node is rendered with an orange highlighted background and a double-headed arrow icon next to the node, clearly indicating that it is in a "modified" state. When the mouse hovers over it, a tooltip appears indicating "Value: 3000>3500". Under the program layer branch, the "Overload Protection Logic" node is rendered with a green highlighted background and a "+" icon is displayed before the node, clearly indicating that it is in a "new" state. Through this interface, developers can easily identify which device configurations have been adjusted and which control logics have been enhanced in the core control of the automated production line, thus preparing for the next step of selecting arbitration.

[0098] Furthermore, for each node, corresponding permissions are assigned, and the corresponding permission changes and check-in operations are triggered in combination with the developer's personal information to output the developer's check-in results. The developer's check-in results are parsed, and the corresponding reconstruction information is determined during the parsing process. The tree structure is dynamically reconstructed based on the reconstruction information to output the merged tree semantic model. This approach takes into account the overall consideration of parsing the developer's check-in results and ensures the accuracy of the corresponding reconstruction information.

[0099] At this point, the system traverses the difference tree nodes presented in the visualization interface and dynamically assigns operation permissions to each node according to the preset industrial control security policy. The permission levels are subdivided into "read and write", "read-only arbitration" and "prohibit modification". The permission determination logic comprehensively considers the semantic level to which the node belongs (such as the core equipment layer usually has higher permissions), the node type and the change risk level to ensure that critical control logic will not be arbitrarily overwritten due to misoperation.

[0100] When a developer attempts to operate on a node, the system collects the developer's identity and role information in real time. The system then matches and verifies the developer's role against the node's permissions: if the developer has the necessary permissions, the system activates the checkbox for that node, allowing the developer to select either "Keep Remote" or "Keep Local". If the permission verification fails, the system automatically blocks the selection or triggers a permission change application process. This process ensures that every selection operation has a legitimate operating entity and authorization record.

[0101] After the developer completes the difference review, they submit the arbitration decision in the interface; the system captures the status of all the checked controls in the interface and generates a structured "developer check result". This result not only records the final destination of each conflict node (remote version or local version), but also includes the operator's identity signature and timestamp, forming a complete decision log.

[0102] The system calls the parsing engine to perform semantic parsing on the developer's selection results; the parsing process transforms the user's discrete selection actions into specific tree structure operation instructions, i.e. "reconstruction information"; the reconstruction information precisely describes the sequence of actions that the target tree needs to perform, such as: "delete node A", "replace the attribute value of node B", "move node C from position 1 to position 2", etc.

[0103] Based on the reconstructed information obtained from the parsing, the system triggers the dynamic reconstructing engine of the tree structure; the engine performs operations such as pruning, grafting, and attribute updating on the original difference tree in memory; the system calculates the reconstructed tree topology in real time to ensure that the reference relationship between parent and child nodes and the semantic hierarchy constraints (device layer - functional layer - program layer) remain complete and valid; and outputs a "merged tree semantic model" that has resolved conflicts, is logically complete, and conforms to the developer's intentions.

[0104] Specifically, the system performs the following operations: For the "servo motor speed parameters" node corresponding to the JSON file, the system determines that it belongs to the key parameters of the "device layer" and automatically grants "read-only arbitration" permission, allowing only senior engineers to modify it; For the "overload protection logic" node corresponding to the TXT script, the system determines that it belongs to the new function of the "program layer" and grants "read and write" permission, allowing ordinary developers to make decisions.

[0105] When a junior developer logs into the system and attempts to manipulate the "Servo Motor Speed ​​Parameters" node, the system detects that their role is "Ordinary Developer," and the permission verification fails. The checkbox is grayed out to prevent accidental modification of critical equipment parameters. The developer then moves on to the "Overload Protection Logic" node, where the permission verification passes. The developer believes that the locally added logic is correct, so they check "Keep Local."

[0106] The system captures the developer's operational intent and generates result data: the node ID is "Logic_Overload_001", the decision is "retain local version", and the operator is "Dev_User_01". The parsing engine reads this result and generates refactoring information: under the "automatic run mode" branch, the "insert child node" instruction is executed, the content of which is the overload protection logic code block of the local version. The system dynamically updates the tree structure based on the refactoring information. In the final output merged tree semantic model, the JSON configuration node retains the stable parameters of the remote node due to permission protection, while the TXT script node successfully merges the newly added local protection logic. This model ensures the security of the device layer and realizes the functional iteration of the program layer, forming a legal, complete, and executable version of control logic.

[0107] Therefore, the merged tree semantic model is reverse-processed, and sequence management is performed in the reverse processing to output industrial control logic files in the corresponding format. Version synchronization is maintained based on the version processing of the industrial control logic files. At the same time, a difference tree is introduced and visualized, realizing dynamic reconstruction of the tree structure, which improves the accuracy of the tree semantic model and the intelligent control effect of the industrial control logic files.

[0108] At this point, the system starts the reverse mapping engine and traverses the merged tree semantic model. The core of the reverse processing is "semantic dimensionality reduction", that is, according to the preset grammatical rules, the standardized tree node structure in memory is decomposed and restored into flat text fragments that conform to specific grammatical constraints. During the traversal, the system simultaneously processes the hierarchical relationship of nodes, escapes special characters, and completes grammatical boundary characters (such as curly braces in JSON, angle brackets in XAML, and newline characters in TXT) to ensure the correctness of the generated text content in terms of grammatical structure.

[0109] During text generation, the system introduces a sequence management mechanism. This mechanism is not only responsible for maintaining the byte stream order of the text output and ensuring that the physical positions of parent and child nodes conform to the execution flow of industrial control logic (such as device initialization before logical judgment), but also for adapting and encapsulating the file format. Based on the format type of the original data source (JSON / XAML / TXT), the system calls the corresponding serialization driver to convert the semantic node stream into serialized data with specific indentation, layout, and encoding formats, ensuring the readability and compatibility of the file.

[0110] After sequence management is completed, the system writes the processed text stream to the local storage medium and outputs the final industrial control logic file. The output process overwrites the original conflicting files or generates a new version of the file. At the same time, the system verifies the integrity of the file to ensure that all nodes retained in the tree model have been correctly written to the file without data loss.

[0111] After the file is output, the system automatically triggers the version synchronization process. The system calls the underlying version control interface (such as Git) to add the updated file to the staging area and generate a commit record containing a merge summary. This commit record is pushed to the remote repository as a new version node. Through the push-pull synchronization mechanism, the repositories of other collaborative development ends are automatically updated to the latest state, thereby maintaining the version synchronization state of the entire multi-end collaborative environment and eliminating differences in logical branches.

[0112] Specifically, the system traverses the merged tree model; for the "servo motor configuration" node in the device layer, the reverse engine identifies it as a JSON type and restores it as a key-value pair text fragment; for the "overload protection logic" node in the program layer, the reverse engine identifies it as a TXT type and restores it as an instruction code line with line numbers.

[0113] For JSON files, the sequence manager adds indentation according to the hierarchical depth, serializes scattered node objects into a standard JSON string, and fills in the arbitrated value "3500" in the "MaxSpeed" attribute; for TXT files, the sequence manager ensures that the command lines are in the correct order, inserts the newly added protection logic code into the specified execution position, and generates the correct newline characters.

[0114] The system writes the serialized data to disk; the JSON configuration file is updated to include the new RPM parameters; the TXT script file is updated to include overload protection logic; the XAML file remains unchanged or its bindings are updated synchronously; at this point, the file content on the disk is completely consistent with the logic tree after the developer's decision.

[0115] The system automatically executes the version commit command, submits the updated JSON and TXT files to the local Git repository, and generates logs; the system pushes the commit to the remote central server; at this time, the production line control system and other development terminals can pull the latest version of the industrial control logic, realizing version synchronization of cross-platform, multi-source heterogeneous data.

[0116] Please see Figure 6 , Figure 6 This is a schematic diagram of the structural composition of an intelligent control system based on semantic processing industrial logic according to an embodiment of the present invention; the intelligent control system based on semantic processing industrial logic is applied to the above-mentioned intelligent control method based on semantic processing industrial logic; the intelligent control system based on semantic processing industrial logic includes:

[0117] The data tree module 21 is used to collect industrial control logic data in different formats, and to convert the data according to the corresponding format type, outputting multiple tree nodes, and constructing a data tree containing semantic hierarchy based on the multiple tree nodes.

[0118] The row-level change information module 22 is used to mark the data version corresponding to the data tree, compare the data version with the preset target version, output the corresponding version difference content, determine the corresponding difference patch by tracing the version difference content, and determine the corresponding row-level change information based on the parsing of the difference patch.

[0119] The difference tree module 23 is used to map the row-level change information, determine the semantic change content during the mapping process, mark the corresponding semantic difference type, generate the corresponding difference tree by combining each tree node and data tree, and present the semantic difference information in the visualization dimension.

[0120] The dynamic reconstruction module 24 is used to collect the corresponding visualization interface and load the difference tree into the visualization interface, display the change status of each node in the difference tree, and support developers to dynamically reconstruct the tree structure based on the developer's selection operation to form a merged tree semantic model; the merged tree semantic model is then reverse-serialized into an industrial control logic file of the corresponding format to achieve version synchronization.

[0121] The technical features of the above embodiments can be combined arbitrarily. For the sake of brevity, not all combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

Claims

1. A method for intelligent control of industrial logic based on semantic processing, characterized in that, include: Collect industrial control logic data in different formats, convert the data according to the corresponding format type, output multiple tree nodes, and construct a data tree containing semantic hierarchy based on multiple tree nodes; The data version corresponding to the data tree is marked, and the data version is compared with the preset target version. The corresponding version difference content is output, and the corresponding difference patch is determined by tracing the version difference content. The corresponding row-level change information is determined based on the parsing of the difference patch. The row-level change information is mapped, and during the mapping process, it is identified as semantic change content. The corresponding semantic difference type is marked, and the corresponding difference tree is generated by combining each tree node and data tree. The semantic difference information is then presented in the visualization dimension. The system collects the corresponding visualization interface and loads the difference tree into it, displaying the change status of each node in the difference tree. Developers can dynamically reconstruct the tree structure based on the user's selections through checkbox operations, forming a merged tree semantic model. The merged tree semantic model is then reverse-serialized into an industrial control logic file of the corresponding format to achieve version synchronization. 2.The intelligent control method of industrial logic based on semantic processing according to claim 1, wherein, The process involves collecting industrial control logic data in different formats, converting the data according to the corresponding format types, and outputting multiple tree nodes. These tree nodes form a data tree containing semantic hierarchies, including: An extensible parser framework is acquired, into which multiple industrial control logic data are input and the format type of the multiple industrial control logic data is marked. The industrial control logic data and the corresponding format type are then subjected to deep parsing, and corresponding data transformations are triggered during the parsing process to output the corresponding tree nodes. 3.The method of claim 2, wherein, The process of collecting industrial control logic data in different formats, converting the data according to the corresponding format type, and outputting multiple tree nodes, and constructing a data tree containing semantic hierarchy based on the multiple tree nodes, also includes: Multiple tree nodes are acquired within the same spatial system. Multi-factor fusion is performed on these multiple tree nodes, and a data tree containing semantic layers is determined during the fusion process. The semantic layers cover the device layer, functional layer, and program layer. 4.The method of claim 1, wherein, The process involves marking the data version corresponding to the data tree, comparing this data version with a preset target version, outputting the corresponding version difference content, tracing the version difference content to determine the corresponding difference patch, and determining the corresponding row-level change information based on the parsing of the difference patch, including: The data is inspected, and the data version corresponding to the data tree is determined during the inspection process. At the same time, a preset target version is obtained. The comparison between the data version and the preset target version is triggered in the same data environment, and the corresponding difference markers are determined during the comparison process. The corresponding version difference content is determined by tracing along each difference marker.

5. The method of claim 4, wherein the semantic processing-based intelligent control of industrial logic is characterized by, The process of marking the data version corresponding to the data tree, comparing the data version with a preset target version, outputting the corresponding version difference content, tracing the version difference content to determine the corresponding difference patch, and determining the corresponding row-level change information based on the parsing of the difference patch, also includes: In the version difference content, multiple key contents are identified based on the detection of version difference content. The corresponding patch area is determined by tracing each key content. The patch areas are then fused using multiple factors, and the corresponding difference patch is determined during the fusion process. The difference patch is then parsed, and a full lifecycle management mechanism is introduced during the parsing process to determine the corresponding row-level change information. 6.The intelligent control method of industrial logic based on semantic processing according to claim 1, wherein, The process involves mapping the row-level change information, identifying semantic changes during the mapping process, marking the corresponding semantic difference types, generating a corresponding difference tree by combining each tree node and data tree, and presenting the semantic difference information in a visualization dimension, including: The row-level change information is input into a preset mapping space, and corresponding mapping is performed in the mapping space. The mapping process is monitored in real time. Multiple semantic change items are identified based on the identification of the mapping process. The corresponding sub-semantic change content is determined based on the detection of each semantic change item. The corresponding semantic change content is constructed based on multiple sub-semantic change content, and the corresponding semantic difference type is marked.

7. The method of claim 6, wherein the semantic processing based intelligent control of industrial logic is based on, The process of mapping the row-level change information, identifying it as semantic change content during the mapping process, marking the corresponding semantic difference type, generating a corresponding difference tree by combining each tree node and data tree, and presenting the semantic difference information in the visualization dimension also includes: Collect each tree node and data tree, synthesize each tree node, data tree and each semantic change content through multiple factors, determine multiple corresponding difference branches during the synthesis process, determine the corresponding difference tree based on the fusion of multiple difference branches, visualize the difference tree, and present the corresponding semantic difference information through visualization dimensions. 8.The method of claim 1, wherein, The data collection corresponds to a visualization interface, and the difference tree is loaded onto the visualization interface to display the change status of each node in the difference tree. Developers can dynamically reconstruct the tree structure based on the selection results through check-in operations to form a merged tree semantic model. The merged tree-structured semantic model is reverse-serialized into an industrial control logic file of the corresponding format to achieve version synchronization, including: Obtain the corresponding visualization interface, mark the loading channel of the visualization interface, load the difference tree along the loading channel to the visualization interface, and present the corresponding nodes in the visualization interface, as well as the change status of each node. 9.The method of claim 8, wherein, The data collection corresponds to a visualization interface, and the difference tree is loaded onto the visualization interface to display the change status of each node in the difference tree. Developers can dynamically reconstruct the tree structure based on the selection results through check-in operations to form a merged tree semantic model. The merged tree-structured semantic model is deserialized into an industrial control logic file of the corresponding format to achieve version synchronization. This also includes: For each node, corresponding permissions are assigned, and the corresponding permission changes and check-in operations are triggered in combination with the developer's personal information to output the developer's check-in results. The developer's check-in results are parsed, and the corresponding reconstruction information is determined during the parsing process. The tree structure is dynamically reconstructed based on the reconstruction information to output the merged tree semantic model. The merged tree semantic model is reverse-processed, and sequence management is performed in the reverse-processing to output an industrial control logic file in the corresponding format. The version of the industrial control logic file is processed to maintain version synchronization.

10. An intelligent control system for industrial logic based on semantic processing, characterized in that, The intelligent control system based on semantic processing industrial logic is applied to the intelligent control method based on semantic processing industrial logic as described in any one of claims 1-9; The intelligent control system based on semantic processing industrial logic includes: The data tree module is used to collect industrial control logic data in different formats, convert the data according to the corresponding format type, and output multiple tree nodes. Based on the multiple tree nodes, a data tree containing semantic hierarchy is constructed. The row-level change information module is used to mark the data version corresponding to the data tree, compare the data version with the preset target version, output the corresponding version difference content, determine the corresponding difference patch by tracing the version difference content, and determine the corresponding row-level change information based on the parsing of the difference patch. The difference tree module is used to map the row-level change information, identify the semantic change content during the mapping process, mark the corresponding semantic difference type, generate the corresponding difference tree by combining each tree node and data tree, and present the semantic difference information in the visualization dimension. The dynamic reconstruction module is used to collect data from the corresponding visualization interface and load the difference tree into the visualization interface, displaying the change status of each node in the difference tree. It supports developers to dynamically reconstruct the tree structure based on the selection results through checkbox operations, forming a merged tree semantic model. The merged tree semantic model is then reverse-serialized into an industrial control logic file of the corresponding format to achieve version synchronization.

Images