Industrial task flow dynamic arrangement method and system based on graphical drag operation

Abstract

This invention discloses a method and system for dynamic orchestration of industrial task processes based on graphical drag-and-drop operations, relating to the field of industrial automation technology. The method includes: selecting nodes from a predefined capability library, dragging and dropping them onto a visual interface to form a directed acyclic graph (DAG) and performing real-time topology verification; configuring node parameters, including static parameters and dynamic parameters dynamically bound using a visual real-time data preview; automatically generating a three-layer JSON execution script based on the DAG, dual-granularity topology sorting, and parameter binding, with dynamic parameters written using string addressing expressions; submitting the script to a scheduling framework for execution according to dual-granularity sorting, supporting runtime delayed evaluation, and providing real-time status feedback to the interface. By generating execution scripts through dynamic parameter binding driven by a visual real-time data preview, efficient no-code orchestration and reliable scheduling execution of industrial tasks are achieved.

Description

Technical Field

[0001] This invention relates to the field of industrial automation technology, and in particular to a method and system for dynamic arrangement of industrial task processes based on graphical drag-and-drop operations. Background Technology

[0002] With the deepening development of industrial intelligence, the demand for automated and highly reliable production processes is becoming increasingly urgent. Although existing industrial task scheduling systems adopt unified capability abstraction, three-layer script definition, and a highly available distributed scheduling framework to achieve automatic task scheduling and execution through configuration files, they still require users to manually write or configure cumbersome execution script files. This makes it difficult to promote and apply them, and there are obvious defects: users need to have scripting language knowledge and strictly follow the file format for process arrangement, which makes it difficult to intuitively express complex topological structures, conditional branches, and parallel execution logic, resulting in low efficiency and high error rate.

[0003] Parameter binding between nodes is prone to errors. Users need to manually query the upstream output path and hardcode the string addressing expression. There is a lack of visual assistance and real-time data preview. Parameter compatibility issues are difficult to discover during the configuration phase.

[0004] Pure script-based methods cannot intuitively demonstrate the execution order and parallel relationship of dual granularity, nor do they support runtime delayed evaluation, resulting in high debugging and maintenance costs. Summary of the Invention

[0005] In view of the aforementioned existing problems, the present invention is proposed.

[0006] Therefore, this invention provides a method for dynamic arrangement of industrial task processes based on graphical drag-and-drop operations, which solves the technical problems of dynamic parameter configuration relying on manual input, lack of real-time data verification, easy error and low efficiency in traditional industrial process arrangement.

[0007] To solve the above-mentioned technical problems, the present invention provides the following technical solution:

[0008] In a first aspect, the present invention provides a method for dynamic orchestration of industrial task processes based on graphical drag-and-drop operations, which includes selecting capability component nodes from a predefined capability library, placing the capability component nodes on a visual interface to form a directed acyclic graph structure through drag-and-drop operations, and performing topology verification in real time.

[0009] Node parameters are configured through a graphical interface, including static and dynamic parameters.

[0010] Based on the directed acyclic graph structure, the two-granularity topological sorting results, and the parameter binding relationship, a three-layer JSON format execution script file is automatically generated.

[0011] The execution script file is submitted to the scheduling framework, and the tasks are executed in a dual-granularity topology sort. The runtime of the string addressing expression is supported, the latency is calculated, and the execution status is fed back to the visualization interface in real time.

[0012] The static parameters are the basic parameters for implementing the functionality of the capability components and are used to implement the functions of the components; the configuration of the dynamic parameters adopts a dynamic binding method driven by visual real-time data preview and is written into the execution script file in the form of string addressing expressions.

[0013] As a preferred embodiment of the dynamic orchestration method for industrial task processes based on graphical drag-and-drop operation described in this invention, the predefined capability library is a standardized capability component repository that is pre-built and independently maintained; wherein, each capability component defines functional semantics, input parameter specifications, output parameter specifications, and corresponding executable interfaces through a unified metadata template;

[0014] Users drag and drop capability component nodes from the capability library to the visualization canvas to generate node instances, and establish directed connections by dragging the output port of the source node to the input port of the target node, forming a directed acyclic graph representing task dependencies.

[0015] As a preferred embodiment of the dynamic orchestration method for industrial task processes based on graphical drag-and-drop operation described in this invention, the dynamic binding method driven by the visual real-time data preview includes querying and displaying the complete structured output data of the upstream node's most recent successful execution as a visual data preview when the user's mouse hovers over the upstream node.

[0016] Based on the visual data preview, users can drag and drop the source data path identifier in the output data of the upstream node to the parameter configuration position of the current node.

[0017] The system automatically combines the source node identifier with the source data path identifier, calls the preset expression template engine to perform string replacement and assembly, automatically generates string addressing expressions, and performs two-level real-time verification.

[0018] As a preferred embodiment of the dynamic orchestration method for industrial task processes based on graphical drag-and-drop operation described in this invention, the string addressing expression is a string expression automatically generated by the system with a unified format and standardized syntax, used to accurately locate and obtain specific values ​​in the output data of upstream nodes during task execution.

[0019] As a preferred embodiment of the dynamic orchestration method for industrial task processes based on graphical drag-and-drop operation described in this invention, the two-level real-time verification includes path validity verification and type compatibility verification.

[0020] The first level of path validity verification includes verifying the parsability and existence of the path in the expression based on historical output data snapshots of upstream nodes.

[0021] The second level of type compatibility verification includes verifying the compatibility between the actual numerical type pointed to by the path and the type declared by the input parameters of the current node, according to predefined type rules.

[0022] Only when both levels of validation pass, the string addressing expression is persistently bound to the current node parameter, and the dependencies of the directed acyclic graph are updated.

[0023] As a preferred embodiment of the dynamic arrangement method for industrial task flow based on graphical drag-and-drop operation described in this invention, the dual-granularity topological sorting result is the execution order information obtained after processing the directed acyclic graph with a topological sorting algorithm, including the execution order of coarse-grained process groups and the execution order of fine-grained actions within each process group.

[0024] When generating the execution script file, the order of the process group layer objects in the JSON is organized according to the coarse-grained process group execution order, and the order of the action layer objects in the corresponding process group is organized according to the fine-grained action execution order within each process group.

[0025] When there are multiple independent process groups and actions within the same process group, the execution script file contains a parallel execution identifier. The scheduling framework executes the independent parts concurrently based on the parallel execution identifier during execution.

[0026] As a preferred embodiment of the dynamic arrangement method for industrial task processes based on graphical drag-and-drop operation described in this invention, the three-layer JSON format execution script file includes a task layer, a process group layer, and an action layer.

[0027] The task layer is responsible for carrying the task's metadata and also contains all process group layer objects;

[0028] The process group layer is responsible for carrying the metadata of each process, while also accommodating all action layer objects within the current process, and displaying and manipulating them in the form of a single action unit in the visual interface;

[0029] The action layer is responsible for carrying out the execution details of specific actions. It corresponds to a single capability component node in the directed acyclic graph and is directly provided to the scheduling framework for calling executable interfaces.

[0030] Secondly, the present invention provides an industrial task flow dynamic orchestration system based on graphical drag-and-drop operation, including a modeling unit that selects capability component nodes from a predefined capability library, places the capability component nodes on a visual interface to form a directed acyclic graph structure through drag-and-drop operation, and performs topology verification in real time.

[0031] The configuration unit configures node parameters through a graphical interface, the node parameters including static parameters and dynamic parameters;

[0032] The execution unit automatically generates a three-layer JSON format execution script file based on the directed acyclic graph structure, the dual-granularity topological sorting result, and the parameter binding relationship.

[0033] The scheduling unit submits the execution script file to the scheduling framework, executes tasks according to dual-granularity topology sorting, supports the runtime of the string addressing expression, calculates the latency, and feeds back the execution status to the visualization interface in real time.

[0034] Thirdly, the present invention provides a computer device, including a memory and a processor, wherein the memory stores a computer program, wherein: when the computer program is executed by the processor, it implements any step of the dynamic orchestration method for industrial task flow based on graphical drag-and-drop operation as described in the first aspect of the present invention.

[0035] Fourthly, the present invention provides a computer-readable storage medium having a computer program stored thereon, wherein: when the computer program is executed by a processor, it implements any step of the dynamic orchestration method for industrial task flow based on graphical drag-and-drop operation as described in the first aspect of the present invention.

[0036] The beneficial effects of this invention are as follows: It replaces traditional manual script configuration by using a graphical drag-and-drop component to construct process topology and employing a dynamic parameter binding method driven by real-time visual data preview. Users can achieve zero-code orchestration without programming knowledge, significantly lowering the threshold for industrial task configuration; it automatically generates standardized addressing expressions and performs two-level real-time verification, combined with dual-granularity topology sorting to achieve automated conversion of three-layer JSON scripts, improving orchestration efficiency and accuracy, making it particularly suitable for rapid iteration in flexible production; it supports runtime delayed evaluation and parallel execution, improving scheduling efficiency; and it provides real-time feedback on execution status and graphical data flow display, enhancing process readability and maintainability, and effectively solving the problem of inconsistent parameters between heterogeneous devices, ensuring high reliability and cross-device compatibility of task execution. Attached Figure Description

[0037] To more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings used in the following description of the embodiments will be briefly introduced. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0038] Figure 1 This is a flowchart of a method for dynamically arranging industrial task processes based on graphical drag-and-drop operations. Detailed Implementation

[0039] To make the above-mentioned objects, features and advantages of the present invention more apparent and understandable, the specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings.

[0040] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0041] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0042] Reference Figure 1 This is one embodiment of the present invention, which provides a method for dynamically orchestrating industrial task processes based on graphical drag-and-drop operations, including the following steps:

[0043] S1: Select capability component nodes from the predefined capability library, drag and drop the capability component nodes to the visualization interface to form a directed acyclic graph structure, and perform topology verification in real time.

[0044] The predefined capability library is a standardized capability component repository that is pre-built and independently maintained; each capability component defines functional semantics, input parameter specifications, output parameter specifications, and corresponding executable interfaces through a unified metadata template.

[0045] The predefined capability library standardizes and modularizes the functions and business logic of scattered and heterogeneous industrial equipment, forming a set of visual components with unified interface specifications, thus abstracting and hiding technical details. Users can intuitively build and adjust task flows through drag-and-drop operations, thereby achieving zero-code orchestration and providing a reliable foundation for subsequent topology verification, parameter binding, and script generation.

[0046] The user selects a target component node from the capability library, holds down the mouse button, drags it to the target area of ​​the visualization canvas, and releases the button. The system automatically generates a graphical instance of the node at the release location and assigns it a unique identifier. The user selects the output port of the source node, holds down the mouse button, drags it to the input port of the target node, and releases the button. The system automatically generates a directional arrow connecting the two points. The connection logically represents the dependency relationship of data flow or control flow.

[0047] After each connection operation is completed, the system performs a topology check in real time, converts the visualized process into a graph structure, and uses a depth-first search algorithm to traverse the graph to detect whether there are loops. If a new connection leads to a closed loop, the system immediately rejects the operation and prompts an error; if there are no loops, the internal graph model is updated to record the dependency relationship of the edge.

[0048] Users can adjust the layout by dragging and dropping nodes, or remove dependencies by deleting connected nodes. The system re-verifies the legality of the topology after each change to ensure that the final graph structure always satisfies the directed acyclic constraint.

[0049] By using a directed acyclic graph structure and topology verification, we can achieve intuitive, code-free orchestration of industrial task processes, significantly reducing the configuration threshold, improving the accuracy of topology logic and orchestration efficiency, and providing a reliable process structure foundation for subsequent parameter binding and automatic generation of execution scripts.

[0050] S2: Configure node parameters through a graphical interface. The node parameters include static parameters and dynamic parameters.

[0051] The static and dynamic parameters of nodes are configured through a graphical interface. Static parameter configuration provides the fixed inputs and environment settings required for task execution; dynamic parameter configuration establishes data dependencies and flow relationships between nodes. By binding the output of upstream nodes to the input of downstream nodes, automatic data transfer and contextual association between tasks are achieved, transforming the process from a collection of individual steps into an organically collaborative data processing pipeline. Together, these two mechanisms transform a flowchart with only a structural skeleton into specific work instructions carrying complete execution information, which can be directly driven by the scheduling engine.

[0052] The configuration of dynamic parameters adopts a dynamic binding method driven by visual real-time data preview.

[0053] When a user configures the current node parameters in the graphical interface and hovers the mouse over the upstream node icon, the system immediately detects the hover event and automatically queries the complete structured output data of its most recently successfully executed node in real time, based on the upstream node's unique identifier. After the query is completed, the system displays an interactive visual data preview panel on the interface or sidebar, fully presenting the actual historical output data structure and sample values ​​of the upstream node, allowing users to intuitively see the real data content, rather than abstract port definitions.

[0054] Users browse the output data tree of upstream nodes in the visual data preview panel to locate the specific field they need. Users directly select the source data path identifier corresponding to that field, and then drag and drop the path identifier to the target parameter input slot in the current node's parameter configuration area. During the dragging process, the system displays a real-time path preview and a floating tooltip for the target parameter to ensure accurate user operation.

[0055] After capturing the drag-and-drop event, the system automatically extracts the unique identifier of the source node and the identifier of the source data path selected by the user. It then calls a pre-built expression template engine to perform string replacement and assembly, generating a standardized string addressing expression with a unified format. This step is fully automated, requiring no manual input of any path string by the user, avoiding the tediousness and errors of traditional hard-coding methods.

[0056] The string addressing expression is a string expression automatically generated by the system with a unified format and standardized syntax, used to accurately locate and obtain specific values ​​in the output data of upstream nodes during task execution.

[0057] After generating the string addressing expression, the system immediately performs two levels of real-time validation:

[0058] The first level of path validity verification includes checking whether the expression syntax is correct, whether the path format is standardized, whether the parentheses match, and verifying the existence and parsing of the path based on a snapshot of the actual historical output data from the visual preview.

[0059] The second level of type compatibility verification includes comparing the actual data type pointed to by the path with the expected type declared by the input parameters of the current node, based on a predefined type rule library.

[0060] If any level of validation fails, the system immediately highlights the error message on the interface, and the user can drag and drop to adjust it again based on the same preview data; only when both levels of validation pass will the system confirm that the binding is successful, persist the generated string addressing expression to the current node parameter, and automatically update the dependency relationship of the directed acyclic graph.

[0061] The dynamic binding method driven by real-time data preview allows for real-time preview of the actual historical output data of upstream nodes and supports drag-and-drop field paths for binding. The system automatically generates string addressing expressions and performs two-level checks on path validity and type compatibility, thereby improving the accuracy and ease of use of parameter binding and avoiding errors associated with traditional manual configuration.

[0062] S3: Based on the directed acyclic graph structure, the dual-granularity topological sorting results, and the parameter binding relationship, automatically generate a three-layer JSON format execution script file.

[0063] The system parses and identifies process groups within the directed acyclic graph (DAG) structure. First, it traverses the DAG constructed by the user in the visual interface, analyzing the dependencies between nodes. Based on preset rules, the DAG is divided into multiple process groups and independent action nodes. Each process group is represented as a collapsible single action unit in the interface, but may contain multiple sequential or parallel action nodes, thus achieving a dual-granularity hierarchical partitioning.

[0064] The dual-granularity topological sorting result is the execution order information obtained after processing the directed acyclic graph with a topological sorting algorithm, including the execution order of coarse-grained process groups and the execution order of fine-grained actions within each process group.

[0065] Topological sorting is an algorithm that arranges all nodes in a directed acyclic graph into a linear sequence, such that the source node of each directed edge (from the source node to the target node) is always preceding the target node in the sequence. The execution order is constructed by repeatedly selecting and removing nodes with an in-degree of 0 (i.e., nodes with no predecessor dependencies).

[0066] First, calculate the in-degree of each node in the graph (the number of edges pointing to that node).

[0067] Place all nodes with an in-degree of 0 into a queue.

[0068] Repeatedly remove a node from the queue, add it to the sorted sequence, and decrement the in-degree of all adjacent nodes pointed to by that node by 1.

[0069] If the in-degree of an adjacent node decreases to 0, then add it to the queue.

[0070] Repeat the above process until the queue is empty.

[0071] In a dual-granularity scenario, the topology sorting algorithm is first applied to the coarse-grained layer (process groups are regarded as nodes) to obtain the execution order of the process groups, and then applied to the fine-grained layer (actions are regarded as nodes) within each process group to obtain the execution order of actions within each group, thus forming a complete dual-granularity topology sorting result.

[0072] Based on the above dual-granularity topological sorting results, when generating the execution script file, the order of the process group layer objects in the JSON is organized according to the coarse-grained process group execution order, and the order of the action layer objects in the corresponding process group is organized according to the fine-grained action execution order within each process group.

[0073] When there are multiple independent process groups and actions within the same process group, the execution script file contains a parallel execution identifier. The scheduling framework executes the independent parts concurrently based on the parallel execution identifier during execution.

[0074] Iterate through all nodes and extract the configured parameter information. For static parameters, write the corresponding values ​​directly; for dynamic parameters, write the standard string addressing expressions that have passed two-level validation and were previously generated through the visual real-time data preview-driven binding method as parameter values. All parameter binding relationships are converted into a script-parsable key-value structure.

[0075] Based on the directed acyclic graph structure, the dual-granularity topological sorting results, and the parameter binding relationship, an execution script file in three-layer JSON format with a task layer, a process group layer, and an action layer is automatically generated.

[0076] The task layer is located at the outermost layer and is responsible for carrying the task's metadata, while also containing all process group layer objects.

[0077] Each element in the task layer array corresponds to a process group, which is responsible for carrying the metadata of each process, while also accommodating all action layer objects within the current process, and displaying and operating them in the form of a single action unit in the visual interface.

[0078] Each action array element within a process group corresponds to a single capability component node in a directed acyclic graph, responsible for carrying the execution details of specific actions. It is directly provided to the scheduling framework for calling executable interfaces.

[0079] In the parameter object of the action layer, the addressing expression of the dynamic parameters is directly written as a string, ensuring that the scheduling framework can perform delayed evaluation at runtime, while injecting necessary runtime metadata. Finally, the system serializes the complete three-level nested object into a formatted JSON string to generate the final execution script file.

[0080] The three-layer JSON format execution script file realizes a fully automated conversion from a graphical DAG model to a structured three-layer JSON script that can be directly submitted to the scheduling framework for execution. This ensures that the script logic is consistent with the user's visual orchestration, supports coarse-grained parallel optimization and dynamic parameter runtime evaluation, thereby guaranteeing the efficient and reliable execution of industrial tasks.

[0081] S4: Submit the execution script file to the scheduling framework, execute tasks according to dual-granularity topology sorting, support the runtime of the string addressing expression, calculate the latency, and provide real-time feedback of the execution status to the visualization interface.

[0082] After completing the workflow orchestration and confirming its correctness in the visual interface, the user clicks the "Deploy" or "Execute" button. The system will automatically generate a complete three-tier JSON execution script file and submit it to the backend scheduling framework via API or message queue. Upon receiving the script, the scheduling framework first performs basic syntax validation and version registration, registers the task as pending execution, and assigns a unique task instance ID.

[0083] When executing tasks, the scheduling framework first parses the dual-granularity topological sorting result in the script: coarse-grained scheduling activates each process group sequentially according to the order of the process group layer, and performs concurrent scheduling for process groups without dependencies, achieving parallel execution at the process group level; within each process group, fine-grained scheduling executes specific actions according to the order of the action layer. If there are no dependent action nodes within the same process group, they are executed concurrently according to the parallel execution flag in the script, thereby improving resource utilization and overall execution efficiency. Simultaneously, the scheduling framework maintains a global dependency graph, ensuring that the execution of downstream nodes is triggered only after all upstream dependent actions or process groups are completed, thus guaranteeing the strict correctness of the task logic and efficient parallelism.

[0084] When the scheduling framework is ready to execute an action node, it parses all input parameters of the current node. If the parameter value is a regular static value, it is injected directly; if the parameter value is a string addressing expression, the scheduling framework does not evaluate it in advance, but uses a delayed evaluation mechanism.

[0085] Parse the string addressing expression and extract the unique identifier of the upstream node and the JSON path referenced within it.

[0086] Check whether the upstream node referenced in the expression has completed execution and produced output data.

[0087] If all upstream nodes have completed their tasks, the system will parse and evaluate the actual output data from the upstream nodes according to the JSON Path in real time, obtain the specific values, inject them into the input parameters of the current node, and start the executable interface of the current action.

[0088] If any upstream node has not yet completed, the current node remains in a waiting state and does not block the entire task thread; once the upstream node completes and pushes the output completion event, the scheduling framework immediately triggers the delayed evaluation of the current node, and executes the action after completing the parameter injection.

[0089] The deferred evaluation mechanism ensures that dynamic parameters always use the latest actual output of the upstream node and avoids the injection of invalid or erroneous data caused by static binding. It also supports the robustness to slight changes in the upstream output data structure, and can be correctly evaluated as long as the JSONPath path is still valid, thereby significantly improving the reliability and flexibility of industrial task processes in complex and dynamic environments.

[0090] Throughout the entire task execution lifecycle, the scheduling framework pushes real-time status changes of each node to the front-end visualization interface via WebSocket, SSE, or polling mechanisms. Statuses include ready, running, successful, failed, and skipped. Upon receiving an update, the front-end immediately dynamically renders the corresponding node icon on the canvas, such as color changes, progress bar display, icon animation, or prompt labels, while simultaneously aggregating and displaying the overall status on the process group unit. If a node fails, detailed error logs and upstream output samples are also pushed, allowing users to directly locate problems, view data flow, and quickly iterate and adjust the process on the interface. Furthermore, the system supports an overall task progress bar, execution time statistics, and historical record viewing, achieving closed-loop monitoring of the entire process.

[0091] By submitting the execution script to the scheduling framework and supporting runtime parameter evaluation, this invention transforms static process design into dynamic and monitorable distributed task execution, and achieves closed-loop linkage between orchestration and runtime environment through delayed evaluation and status feedback.

[0092] This embodiment also provides a dynamic orchestration system for industrial task flows based on graphical drag-and-drop operations, including:

[0093] The modeling unit selects capability component nodes from a predefined capability library, places the capability component nodes on the visualization interface through drag-and-drop operations to form a directed acyclic graph structure, and performs topology verification in real time.

[0094] The configuration unit configures node parameters through a graphical interface, including static parameters and dynamic parameters.

[0095] The execution unit automatically generates a three-layer JSON format execution script file based on the directed acyclic graph structure, the dual-granularity topological sorting result, and the parameter binding relationship.

[0096] The scheduling unit submits the execution script file to the scheduling framework, executes tasks according to dual-granularity topology sorting, supports the runtime of the string addressing expression, calculates the latency, and feeds back the execution status to the visualization interface in real time.

[0097] This embodiment also provides a computer device applicable to the dynamic arrangement method of industrial task flow based on graphical drag-and-drop operation, including: a memory and a processor; the memory is used to store computer-executable instructions, and the processor is used to execute the computer-executable instructions to realize the dynamic arrangement method of industrial task flow based on graphical drag-and-drop operation proposed in the above embodiment.

[0098] The computer device can be a terminal, comprising a processor, memory, communication interface, display screen, and input devices connected via a system bus. The processor provides computing and control capabilities. The memory includes non-volatile storage media and internal memory. The non-volatile storage media stores the operating system and computer programs. The internal memory provides an environment for the operation of the operating system and computer programs stored in the non-volatile storage media. The communication interface is used for wired or wireless communication with external terminals; wireless communication can be achieved through Wi-Fi, carrier networks, NFC (Near Field Communication), or other technologies. The display screen can be an LCD screen or an e-ink screen. The input devices can be a touch layer covering the display screen, buttons, a trackball, or a touchpad on the computer device's casing, or an external keyboard, touchpad, or mouse.

[0099] This embodiment also provides a storage medium storing a computer program that, when executed by a processor, implements the method for dynamically arranging industrial task flows based on graphical drag-and-drop operations as proposed in the above embodiments. The storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as Static Random Access Memory (SRAM), Electrically Erasable Programmable Read-Only Memory (EEPROM), Erasable Programmable Read-Only Memory (EPROM), Programmable Red-Only Memory (PROM), Read-Only Memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk.

[0100] In summary, this invention achieves efficient, code-free orchestration of industrial task processes, high accuracy and flexibility in data transfer between nodes, and real-time visual feedback on the execution status of the entire process by: constructing a directed acyclic graph from capability component nodes dragged from a predefined capability library; configuring node parameters using a dynamic parameter binding method driven by visual real-time data preview; automatically generating a three-layer JSON execution script file based on dual-granularity topological sorting; and a scheduling framework execution mechanism that supports runtime delayed evaluation. This significantly reduces the threshold for configuring industrial automation tasks and improves orchestration efficiency, execution reliability, and maintenance convenience.

[0101] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A method for dynamic orchestration of industrial task flows based on graphical drag-and-drop operation, characterized by: This includes selecting capability component nodes from a predefined capability library, placing the capability component nodes on a visual interface to form a directed acyclic graph structure through drag-and-drop operations, and performing topology verification in real time. Node parameters are configured through a graphical interface, including static and dynamic parameters. Based on the directed acyclic graph structure, the two-granularity topological sorting results, and the parameter binding relationship, a three-layer JSON format execution script file is automatically generated. The execution script file is submitted to the scheduling framework, and the tasks are executed in a dual-granularity topology sort. The runtime of the string addressing expression is supported, the latency is calculated, and the execution status is fed back to the visualization interface in real time. The static parameters are the basic parameters for implementing the functionality of the capability components and are used to implement the functions of the components; the configuration of the dynamic parameters adopts a dynamic binding method driven by visual real-time data preview and is written into the execution script file in the form of string addressing expressions.

2. The method for dynamic arrangement of industrial task flows based on graphical drag-and-drop operation as described in claim 1, characterized in that: The predefined capability library is a standardized capability component repository that is pre-built and independently maintained; each capability component defines functional semantics, input parameter specifications, output parameter specifications, and corresponding executable interfaces through a unified metadata template. Users drag and drop capability component nodes from the capability library to the visualization canvas to generate node instances, and establish directed connections by dragging the output port of the source node to the input port of the target node, forming a directed acyclic graph representing task dependencies.

3. The method for dynamic arrangement of industrial task flows based on graphical drag-and-drop operation as described in claim 2, characterized in that: The dynamic binding method driven by the real-time visualization data preview includes querying and displaying the complete structured output data of the upstream node's most recent successful execution as a visualization data preview when the user hovers the mouse over the upstream node. Based on the visual data preview, users can drag and drop the source data path identifier in the output data of the upstream node to the parameter configuration position of the current node. The system automatically combines the source node identifier with the source data path identifier, calls the preset expression template engine to perform string replacement and assembly, automatically generates string addressing expressions, and performs two-level real-time verification.

4. The method for dynamic arrangement of industrial task flows based on graphical drag-and-drop operation as described in claim 3, characterized in that: The string addressing expression is a string expression automatically generated by the system with a unified format and standardized syntax, used to accurately locate and obtain specific values ​​in the output data of upstream nodes during task execution.

5. The method for dynamic arrangement of industrial task flows based on graphical drag-and-drop operation as described in claim 4, characterized in that: The two-level real-time verification includes path validity verification and type compatibility verification; The first level of path validity verification includes verifying the parsability and existence of the path in the expression based on historical output data snapshots of upstream nodes. The second level of type compatibility verification includes verifying the compatibility between the actual numerical type pointed to by the path and the type declared by the input parameters of the current node, according to predefined type rules. Only when both levels of validation pass, the string addressing expression is persistently bound to the current node parameter, and the dependencies of the directed acyclic graph are updated.

6. The method for dynamic arrangement of industrial task flows based on graphical drag-and-drop operation as described in claim 5, characterized in that: The dual-granularity topological sorting result is the execution order information obtained after processing the directed acyclic graph with a topological sorting algorithm, including the execution order of coarse-grained process groups and the execution order of fine-grained actions within each process group; When generating the execution script file, the order of the process group layer objects in the JSON is organized according to the coarse-grained process group execution order, and the order of the action layer objects in the corresponding process group is organized according to the fine-grained action execution order within each process group. When there are multiple independent process groups and actions within the same process group, the execution script file contains a parallel execution identifier. The scheduling framework executes the independent parts concurrently based on the parallel execution identifier during execution.

7. The method for dynamic arrangement of industrial task flows based on graphical drag-and-drop operation as described in claim 6, characterized in that: The three-layer JSON format execution script file includes a task layer, a process group layer, and an action layer; The task layer is responsible for carrying the task's metadata and also contains all process group layer objects; The process group layer is responsible for carrying the metadata of each process, while also accommodating all action layer objects within the current process, and displaying and manipulating them in the form of a single action unit in the visual interface; The action layer is responsible for carrying out the execution details of specific actions. It corresponds to a single capability component node in the directed acyclic graph and is directly provided to the scheduling framework for calling executable interfaces.

8. A dynamic industrial task workflow arrangement system based on graphical drag-and-drop operation, based on the dynamic industrial task workflow arrangement method based on graphical drag-and-drop operation as described in any one of claims 1 to 7, characterized in that: This includes a modeling unit that selects capability component nodes from a predefined capability library, places the nodes on a visualization interface to form a directed acyclic graph structure through drag-and-drop operations, and performs topology verification in real time. The configuration unit configures node parameters through a graphical interface. The node parameters include static parameters and dynamic parameters, wherein the configuration of the dynamic parameters adopts a dynamic binding method driven by visual real-time data preview. The execution unit automatically generates a three-layer JSON format execution script file based on the directed acyclic graph structure, the dual-granularity topological sorting result, and the parameter binding relationship, wherein the dynamic parameters are written into the execution script file in the form of string addressing expressions; The scheduling unit submits the execution script file to the scheduling framework, executes tasks according to dual-granularity topology sorting, supports the runtime of the string addressing expression, calculates the latency, and feeds back the execution status to the visualization interface in real time.

9. A computer device comprising a memory and a processor, wherein the memory stores a computer program, characterized in that: When the processor executes the computer program, it implements the steps of the dynamic arrangement method for industrial task flow based on graphical drag-and-drop operation as described in any one of claims 1 to 7.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that: When the computer program is executed by the processor, it implements the steps of the dynamic arrangement method for industrial task processes based on graphical drag-and-drop operations as described in any one of claims 1 to 7.

Images