Zero-code platform

Abstract

The present invention provides a zero-code platform, comprising: a resource manager, a main task designer, and an HMI designer. Upon receiving a message to disable an operator, the resource manager, the main task designer, and the HMI designer control each canvas in the canvas manager to perform the following operations: obtaining a first target operator in the canvas that references a first operator, removing the reference to the first operator in the first target operator, deleting the first operator from a reference list corresponding to the first target operator, and then adding the first operator to a list of non-referenceable operators corresponding to all task operators, with the first operator in a disabled state; wherein the reference list corresponding to the first target operator stores at least all operators referenced by the first target operator. The zero-code platform can implement the function of disabling an operator.

Description

Technical Field

[0001] The present invention relates to the field of zero-code technology, and in particular to a zero-code platform. Background Art

[0002] Traditional project development often involves writing large amounts of code or modules, often requiring quick modifications. Modifying code modules requires deleting or commenting. Later, when a commented code module is opened, it's difficult to confirm whether it's a comment or a normal code module. The Zero Code platform software provides the ability to disable and activate operators. Disabling an operator bypasses it, allowing execution to continue. Disabling is a commonly used feature.

[0003] Therefore, in the zero-code platform, how to implement the function of disabling operators has become an urgent problem to be solved. Summary of the Invention

[0004] The purpose of the present invention is to provide a zero-code platform.

[0005] In order to achieve one of the above-mentioned objects of the invention, an embodiment of the present invention provides a zero-code platform, a resource manager, a main task designer and an HMI designer; when the resource manager receives a first instruction to disable a first operator, it sends a first message to the resource manager, the main task designer and the HMI designer; when the main task designer receives a first instruction to disable the first operator, it sends a first message to the main task designer and the HMI designer; when the HMI designer receives the first instruction to disable the first operator, it sends a first message to the HMI designer, the main task designer and the resource manager; wherein, the first message is used to disable the first operator; when the resource manager and the main task designer receive the first message, they control each canvas process to perform the following operations: obtain the first target operator that references the first operator in the canvas process, and release it in the first target operator. A reference to a first operator, then deleting the first operator from a reference list corresponding to a first target operator, then adding the first operator to a non-referenceable operator list corresponding to all task operators and setting the state of the first operator to disabled; wherein the reference list corresponding to the first target operator at least stores: all operators referenced by the first target operator; upon receiving the first message, the HMI designer controls each window canvas of the HMI designer to perform the following operations: obtaining a second target operator in the window canvas that references the first operator, releasing the reference to the first operator in the second target operator, then deleting the first operator from a reference list corresponding to the second target operator, then adding the first operator to a non-referenceable operator list corresponding to all task operators and setting the state of the first operator to disabled; wherein the reference list corresponding to the second target operator at least stores: all operators referenced by the second target operator.

[0006] As a further improvement of one embodiment of the present invention, a design tree, a decision tree and an execution tree; when the resource manager, the main task designer and the HMI designer receive the first message, they all perform the following third operation: obtain the position and logical node of the first operator on the design tree, add the position and logical node to the decision tree, and remove the logical node of the first operator from the execution tree.

[0007] As a further improvement of one embodiment of the present invention, when the resource manager receives the second instruction to enable the third operator, it sends a second message to the resource manager, the main task designer and the HMI designer; when the main task designer receives the second instruction to enable the third operator, it sends a second message to the main task designer and the HMI designer; when the HMI designer receives the second instruction to enable the third operator, it sends a second message to the HMI designer, the main task designer and the resource manager; wherein the second message is used to enable the third operator; when the resource manager, the main task designer and the HMI designer receive the second message, they all perform the following operations: set the status of the third operator in the decision tree to start, obtain the position and logical node of the third operator on the design tree from the decision tree, and restore the third operator to the node position corresponding to the execution tree based on the position and logical node.

[0008] As a further improvement of an embodiment of the present invention, upon receiving the second message, the resource manager, main task designer and HMI designer set the status of the third operator in the referenceable operator list of all task operators to enabled.

[0009] As a further improvement of an embodiment of the present invention, when the zero-code platform is in debug mode, disabled operators are not executed.

[0010] As a further improvement of an embodiment of the present invention, a log module for recording logs does not record disabled operators.

[0011] As a further improvement of an embodiment of the present invention, in the canvas process and the window canvas, when the status of a displayed operator is disabled, a disable identifier is added at the position where the operator is located.

[0012] As a further improvement of an embodiment of the present invention, when the status of the displayed operator is disabled, the data line between the operator and any other operator is disconnected.

[0013] As a further improvement of one embodiment of the present invention, the main task designer is a hierarchical structure and can reference all operators in the resource manager; the HMI designer is a hierarchical structure and can reference all operators of the resource manager and the main task designer, but cannot reference operators in the HMI designer.

[0014] Compared with the prior art, the technical effect of the present invention is that: an embodiment of the present invention provides a zero-code platform, including: a resource manager, a main task designer and an HMI designer; when the resource manager, the main task designer and the HMI designer receive a message to disable an operator, they control each canvas in the canvas manager to perform the following operations: obtain the first target operator that references the first operator in the canvas, release the reference to the first operator in the first target operator, then delete the first operator from the reference list corresponding to the first target operator, and then add the first operator to the non-referenceable operator list corresponding to all task operators and the status of the first operator is disabled; wherein the reference list corresponding to the first target operator at least stores: all operators referenced by the first target operator. The zero-code platform can realize the function of disabling operators. BRIEF DESCRIPTION OF THE DRAWINGS

[0015] Figure 1 It is a structural diagram of the zero-code platform in an embodiment of the present invention. DETAILED DESCRIPTION

[0016] The present invention will be described in detail below with reference to the various embodiments shown in the accompanying drawings. However, these embodiments do not limit the present invention, and any structural, methodological, or functional modifications made by those skilled in the art based on these embodiments are all within the scope of protection of the present invention.

[0017] As used herein, terms indicating spatial relative positions, such as "upper," "above," "lower," and "below," are used for ease of explanation to describe the relationship of one element or feature relative to another element or feature as shown in the accompanying drawings. Spatially relative terms may be intended to encompass different orientations of the device in use or operation in addition to the orientation shown in the drawings. For example, if the device in the drawings were turned over, elements described as being "below" or "beneath" other elements or features would then be "above" the other elements or features. Thus, the exemplary term "below" encompasses both above and below. The device may be otherwise oriented (rotated 90 degrees or in other orientations) and the spatially relative descriptors used herein interpreted accordingly.

[0018] The first embodiment of the present invention provides a zero-code platform, such as Figure 1 As shown, it includes: resource manager, main task designer and HMI designer.

[0019] Here, the Resource Manager has the following functions: (1) Centralized resource management, unified management of all types of resources required by the platform (such as images, videos, documents, API interfaces, database connections, device drivers, operating system components, etc.); (2) Classification and labeling, supporting classification by type, project, permission, etc., to facilitate quick retrieval; (3) Version control, recording resource change history and supporting rollback to old versions; (4) Permission control, assigning resource access and editing permissions based on roles. The Resource Manager generally includes the following modules: (1) Resource library, storing all uploaded files or external service configurations; (2) Metadata management, adding descriptions, tags, dependencies and other attributes to resources, which include operators, etc.; (3) Search and filtering, supporting keyword search, type filtering, etc.; (4) Hardware initialization, realizing the loading and initialization of hardware drivers through visual configuration.

[0020] Here, the Main Task Designer has the following functions: (1) Visual process orchestration, building business processes by dragging and dropping nodes (such as conditional branches, loops, and operator calls); (2) Logic configuration, setting node parameters, data mapping, and exception handling rules; (3) Debugging tools, providing single-step execution, variable monitoring, debug logs, and other functions to verify process correctness; (4) Multi-task scheduling, supporting scheduled tasks and event triggering (such as triggering the approval process after a form is submitted). The Main Task Designer generally includes the following modules: (1) Node library, pre-setting common operations (database CRUD, HTTP requests, message push, image processing, motion control, data acquisition); (2) Data flow engine, defining data transfer between nodes (such as the output of the previous node as the input of the next node); (3) Trigger configuration, setting process startup conditions (such as webhooks, timers, triggers); (4) Logging and monitoring, recording task execution history and performance indicators.

[0021] Here, the HMI designer (Human-Machine Interface Designer) has the following functions: (1) Visual interface construction, dragging components (buttons, charts, tables) to design interactive interfaces; (2) Data binding, dynamically linking UI components with back-end data sources (databases, APIs); (3) Responsive layout, adapting to different device screens (PCs, tablets, mobile phones); (4) Interaction events, defining the response logic for clicks, slides, and other operations (such as pop-ups and page jumps). HMI designers generally include the following core modules: (1) Component library, basic components (input boxes, drop-down menus) and industry-specific components (such as industrial dashboards); (2) Style editor, adjusting colors, fonts, animation effects, and supporting CSS customization; (3) Multi-terminal publishing, generating desktop, web, iOS / Android app, or embedded terminal interfaces, etc.

[0022] The reference list stores at least the following information: all operators; for any operator, it may reference other operators, so the reference list stores the reference relationship.

[0023] When the resource manager receives the first instruction to disable the first operator, the resource manager sends a first message to the resource manager, the main task designer and the HMI designer; when the main task designer receives the first instruction to disable the first operator, the main task designer sends a first message to the main task designer and the HMI designer; when the HMI designer receives the first instruction to disable the first operator, the HMI designer sends a first message to the HMI designer, the main task designer and the resource manager; wherein the first message is used to disable the first operator.

[0024] When receiving the first message, the resource manager and the main task designer control each canvas process to perform the following operations: obtain the first target operator that references the first operator in the canvas process, release the reference to the first operator in the first target operator, and then delete the first operator from the reference list corresponding to the first target operator. Then, add the first operator to the non-referenceable operator list corresponding to all task operators and the status of the first operator is disabled; wherein, the reference list corresponding to the first target operator at least stores: all operators referenced by the first target operator.

[0025] In the zero-code platform, a Task Operator is a core concept, representing the smallest executable unit that encapsulates specific functionality or logic. It's similar to a "function" or "module" in programming, but presented in a visual, drag-and-drop format. Users can combine and call these operators to complete complex tasks without writing code.

[0026] Key features of task operators: (1) Modular functionality: Each operator represents an independent function (e.g., data query, conditional judgment, email sending, API call, etc.). Users can build complete business processes by combining multiple operators. (2) Zero-code operation: Operators are configured through a graphical interface (e.g., filling out a form, dragging and dropping connections), requiring no programming knowledge. For example, to configure a "Send Email" operator, you only need to enter the recipient, subject, and body template. (3) Input and output: Input is the data passed by the operator in the previous step (e.g., form data, variables, API response, etc.), and output is the processed result passed to the subsequent operator (e.g., filtered data, generated files, etc.).

[0027] When the HMI designer receives the first message, it controls each window canvas of the HMI designer to perform the following operations: obtaining a second target operator that references the first operator in the window canvas, releasing the reference to the first operator in the second target operator, and then deleting the first operator from a reference list corresponding to the second target operator; and then adding the first operator to a list of non-referenceable operators corresponding to all task operators, with the status of the first operator being disabled; wherein the reference list corresponding to the second target operator at least stores: all operators referenced by the second target operator.

[0028] The zero-code platform has an efficient and systematic mechanism for disabling operators or components / controls in different designers. The following describes the corresponding disabling processing processes in the resource manager, main task designer, and HMI designer.

[0029] When an operator in the resource manager is disabled, a series of actions are triggered. First, the system notifies the upper layer and invokes the operator state change event. Upon receiving this event, the resource manager, main task designer, and HMI designer distribute it to their respective processes: the resource management process, each canvas process in the main task designer, and each window canvas in the HMI designer.

[0030] Each canvas then notifies each affected operator of the information. The affected operator removes its reference to the disabled operator and removes it from its own reference list. In the main task designer, when an operator performs a refresh operation, the canvas process will synchronously refresh the data connection, such as disconnecting the connection, but the logical connection will remain unchanged. Through the reference manager, the system can directly locate and notify the affected operators, avoiding the inefficient traditional method of indiscriminately notifying all operators and then letting the operators decide whether to refresh the configuration, greatly improving execution efficiency.

[0031] Afterwards, the system records the operator's position and logical node in the design tree in the decision tree and removes the operator node from the execution tree. Furthermore, the system refreshes the task operator's reference list to ensure that the operator is updated to the latest reference list in real time.

[0032] When an operator in the main task designer is disabled, the upper layer is notified and the operator state change event is called. After receiving the event, the main task designer and HMI designer will distribute it to each canvas process of the main task designer and each window canvas of the HMI designer.

[0033] Each canvas then notifies the affected operators, which remove references to the disabled operator and remove it from their reference lists. When the main task designer operator is refreshed, the canvas process also refreshes the data connections, while the logical connections remain unchanged.

[0034] Similar to disabling a resource manager operator, the system records the operator's position and logic node on the design tree in the decision tree, removes the operator node from the execution tree, and refreshes the reference list of the task operator.

[0035] HMI designer components / controls can be disabled at design time and at runtime.

[0036] Design Time: During design time, if a component / control becomes disabled, the upper layer is notified and an operator state change event is invoked, notifying the resource manager and the main task designer. Upon receiving the event, the main task designer and HMI designer distribute it to their respective canvas processes, which then notify the affected operators. The affected operators remove their references to the component / control and are removed from their reference lists. However, the control can still be used normally for operations such as event binding, data source configuration, and reference setting.

[0037] Runtime: When a component / control is disabled during runtime, it will not perform any operations on the control and will not respond to mouse or keyboard events.

[0038] Similarly, the system will record the position and logic node of the operator on the design tree in the decision tree, remove the operator node from the execution tree, and refresh the reference list of the task operator.

[0039] Through such a mechanism, the zero-code platform can efficiently handle the disabling of operators or components / controls in different designers, ensuring the stable operation of the system and real-time updating of data.

[0040] This embodiment also includes: a design tree, a decision tree and an execution tree; when the resource manager, the main task designer and the HMI designer receive the first message, they all perform the following third operation: obtain the position and logical node of the first operator on the design tree, add the position and logical node to the decision tree, and remove the logical node of the first operator from the execution tree.

[0041] The zero-code platform is equipped with three important design tools: the resource manager, the main task designer, and the HMI (Human Machine Interface) designer. In this platform, the operator disabling and enabling scheme is sophisticated, and the designers interact with each other: (1) Disabling or enabling the resource manager operator will affect the operator of the main task designer and the components in the HMI designer; (2) Disabling or enabling the operator of the main task designer will affect the components in the HMI designer; (3) Disabling or enabling the control of the HMI designer will affect the operator of the resource manager and the operator of the main task designer.

[0042] There are also three task trees in the platform, each with different functions:

[0043] Design Tree: This logically organizes the platform's task tree into the Explorer task tree, the Main Task Designer tree, and the HMI Designer task tree. Each tree covers all operators or components within the corresponding designer. In the design tree, operators at the front of the tree are visible to operators or controls at the back, while operators at the back of the tree are not visible to those at the front.

[0044] The decision tree is primarily responsible for storing disabled operators within the platform, determining whether an operator should be disabled or enabled, and ultimately determining whether the operator will be executed. The decision tree also manages operator status and state transitions. Once an operator's status changes, the platform scheduler is notified to adjust the logic within the execution tree and add or remove operators. This design is extremely convenient during program debugging, allowing operators to be disabled or enabled at any time, effectively improving debugging efficiency.

[0045] The execution tree only stores the operators that are enabled within each designer, and the execution logic for these operators is preserved in the correct order. Disabled operators do not appear in the execution tree, improving task execution efficiency during normal program execution. The overall concept of operator disabling / enabling revolves around these three designers and the task tree. Their collaborative work allows for flexible adjustments during program debugging while ensuring high efficiency during normal program operation.

[0046] In this embodiment, when the resource manager receives the second instruction to enable the third operator, it sends a second message to the resource manager, the main task designer, and the HMI designer; when the main task designer receives the second instruction to enable the third operator, it sends a second message to the main task designer and the HMI designer; when the HMI designer receives the second instruction to enable the third operator, it sends a second message to the HMI designer, the main task designer, and the resource manager; wherein the second message is used to enable the third operator.

[0047] When receiving the second message, the resource manager, the main task designer, and the HMI designer all perform the following operations: setting the state of the third operator in the decision tree to start, obtaining the position and logical node of the third operator on the design tree from the decision tree, and restoring the third operator to the node position corresponding to the execution tree based on the position and logical node.

[0048] In this embodiment, upon receiving the second message, the resource manager, the main task designer, and the HMI designer set the status of the third operator in the referenceable operator list of all task operators to enabled.

[0049] In this embodiment, when the zero-code platform is in debug mode, the disabled operators are not executed.

[0050] This embodiment further includes: a log module for recording logs, and the log module does not record disabled operators.

[0051] In this embodiment, in the canvas process and the window canvas, when the status of a displayed operator is disabled, a disabled identifier is added to the position of the operator.

[0052] In this embodiment, when the status of a displayed operator is disabled, the data line between the operator and any other operator is disconnected.

[0053] Optionally, the resource manager is a linear linked list, and the internal operator structure and reference relationship do not have a hierarchical structure.

[0054] In this embodiment, the main task designer is a hierarchical structure and can reference all operators in the resource manager; the HMI designer is a hierarchical structure and can reference all operators of the resource manager and the main task designer, but cannot reference operators in the HMI designer.

[0055] In the zero-code platform, the main task designer and resource manager have different features and interaction methods. At the same time, the reference configuration of operators also has its own specific rules, which are introduced in detail below.

[0056] The main task designer uses a tabbed mode, allowing users to create multiple processes. The resource manager, on the other hand, only has one tab. In fact, the resource manager interface can be regarded as a special process, namely the resource process.

[0057] Operators in the zero-code platform contain an object of type IToolReferenceSet. Both the resource manager and the main task designer must implement this interface. This interface provides the following functions: obtaining operator details by globally unique identifier (GUID); checking whether an operator exists in the current process; and obtaining a reference list for an operator.

[0058] This interface property is defined within the operator. When creating an operator, if the IToolReferenceSet property is assigned to the current process object, all operator objects in the current process will be added to the newly created operator's reference list. Operators can also filter the list of operators available for reference by configuring the reference type and filtering conditions.

[0059] Specifically, both the resource manager and the main task designer's processes implement the IToolReferenceSet interface. Operators internally define objects of the IToolReferenceSet interface type. When creating an operator, if it's in the resource manager, the operator's own process's IToolReferenceSet object is assigned to it. If it's in the main task's process, the operator first obtains the resource manager's operator object list and embeds it as a resource object in the current process's reference list. The operator's own process's operator reference list is then assigned to the newly created operator's IToolReferenceSet property object. This allows operators to configure references at creation time.

[0060] In addition, in the zero-code development platform, how the three parts of the resource manager, main task designer and HMI designer interact and are managed is also an important issue that needs to be explored.

[0061] In the zero-code platform, the resource manager plays a key role in configuring platform resources. It is responsible for creating various resource operator objects, including global variables, initializing operation control boards, and initializing log objects. These created resource operator objects are then passed to the main task designer and HMI designer. By referencing these resource objects, the main task designer and HMI designer construct control flows, manage controls, and implement their respective functions.

[0062] The resource manager's internal management mechanism uses a linear list structure, which doesn't require hierarchical processing; a single-layer structure is sufficient. The List collection is ideally suited for managing this single-layer structure because it is inherently single-layer. Whenever a resource operator object is created, the resource manager adds it to the List collection object used to manage the operator.

[0063] When the resource manager completes the operator addition operation, the Added event will be triggered. This event will notify the main framework resource manager that the resource operator task has changed, and mark the current project as unsaved. Next, the process manager in the main task designer will play a role. The process manager will obtain a list of all resource operator objects in the resource manager and add this list to itself at one time. After that, the process manager will traverse all process objects and configure complete resource objects for each process. In this process, it will first clear the original resource object list in the main task designer process, and then assign the resource list Set passed by the resource manager through the event to the resource list of the main task designer. In addition, a ListGet property is defined inside the resource manager. With the help of this property, all resource operator objects in the resource manager can be easily obtained.

[0064] The resource manager's use of event notification has great advantages. For example, the process built by the main task designer includes the "read image" and "template matching" links. If you want to obtain the template coordinate information with an index of 2 in the "template matching", that is, to perform an "array extraction" operation, you need to reference an index object. At this time, define an index variable with a default value of 2 in the "global variables" of the resource manager. After creating this "global variable" in the resource manager, the resource manager will notify all processes, including the operator objects therein, through the Added event, informing them that the resources have changed. In this way, when the "array extraction" operator is opened, the index in the "global variable" can be directly referenced, thereby automatically updating the reference resource list and realizing accurate acquisition and use of data.

[0065] The main task designer manages reference relationships using a hierarchical structure, with an internal tree structure. For example, a process contains two operators, "Read Image" and "Conditional Branch." "Conditional Branch" has multiple levels of child nodes, where logical relationships can be written. However, "Read Image" does not have multiple levels of nodes.

[0066] When an operator is created, it is added to the end of the process tree by default. At this point, the current process (including resource objects) is assigned to the newly created operator's IToolReferenceSet property. The operator then obtains a list of resource references and a list of references to its own process. Within the operator, you can define the data types and filter conditions that can be referenced to filter the list of available references.

[0067] Suppose a process already has "Read Image" and "Conditional Branch." The "Conditional Branch" has two child nodes: "True" and "False." Under the "True" branch is "Expression Analysis 1," and under the "False" branch is "Expression Analysis 2." Then, "Expression Analysis 1" and "Expression Analysis 2" can both reference the output of "Read Image," but they cannot reference each other. This is because the zero-code development platform's reference rules stipulate that lower-level operators can reference higher-level operators, and child node branches cannot reference nodes at the same level; they can only reference nodes at the parent node or above.

[0068] If you create a new "Delay Tool" operator, it will be placed at the end of the current tree structure by default, and its reference list will be the list of operators at the same level and above. If you move the "Delay Tool" before the "Conditional Branch", the process will notify the refresh of the entire sequence list and update the reference relationship after receiving the move command. If the internal logic changes, the operator will also be notified to refresh the reference list.

[0069] When an operator with child node branches is disabled, for example, if a "conditional branch" is set to disabled, when the program runs to the "conditional branch", it will not traverse all child nodes under this node, nor will it execute the child node branch structure under the "conditional branch". Instead, it will directly skip the "conditional branch" and execute subsequent operators.

[0070] When you open the HMI Designer, it automatically retrieves the resource list from the Resource Manager and the reference list for all processes in the Main Task Designer. The internally defined reference list in the HMI Designer is equal to the resource manager's reference list plus the process reference list in the Main Task Designer.

[0071] When creating an operator control, the obtained HMI designer list is assigned to the operator's IToolReferenceSet property. The HMI control also belongs to the operator structure, and its internal structure is consistent with that of the resource operator and process operator.

[0072] In summary, the above content explains how operators configure reference relationships, including how to filter reference conditions, and the mutual reference relationship structure between the resource manager, main task designer, and HMI designer.

[0073] In the zero-code platform, the disabling and enabling operations of operators are handled in a specific way, and the reference relationships between components within the platform also have unique characteristics.

[0074] Let's first look at the reference relationship characteristics of the zero-code platform. The resource manager uses a linear linked list structure. Its internal operator structure and reference relationship are not hierarchical and can only be referenced within its own process. The main task designer is a hierarchical structure. It can not only reference all operators in the resource manager, but also reference operators within its own structure. Its internal operator structure and reference relationship are also hierarchical. The HMI designer is also a hierarchical structure. It can reference all operators in the resource manager and the main task designer, but cannot reference the operator controls of the HMI designer itself. The HMI designer can implement control operations such as data refresh and enablement of other controls through control references.

[0075] To better understand the reference relationship between components, assume that A represents the resource manager, B represents the main task designer, and C represents the HMI designer. The reference relationship between them is as follows:

[0076] C (HMI Designer) references B (Main Task Designer) and A (Resource Manager), which enables C to control itself and all controls in the HMI. At the same time, C can also control B and A with the help of the Event Manager.

[0077] B (the main task designer) references A (the resource manager). This allows B to control the operators in its own process and also control the objects and operators in A through reference. Furthermore, all operator processes in B can reference the operator structure in A.

[0078] A (resource manager) can only reference itself, and its reference relationship presents a linear structure, similar to a single-layer tree, with the lower referencing the upper relationship.

[0079] Specifically, the reference relationship of Resource Manager A is a linear, single-layer tree structure. The reference relationship of the Master Task Designer is a multi-layer tree structure. It can only reference the nodes at the same level above the current node, as well as the nodes at the same level above the parent node, which also covers all operators in the single layer of the Resource Manager. The HMI Designer can reference multiple tree hierarchies, including all processes in Master Task Designer B (and therefore all operators therein) and all operators in the single layer of Resource Manager A. By referencing Resource Manager A or Master Task Designer B, it is possible to control all form controls in the CHMI Designer, thus forming an interconnected reference relationship between A, B, and C.

[0080] The efficient operation of the zero-code platform depends on the coordinated cooperation of the resource manager, the main task designer, and the HMI designer. Among them, the operator disabling and enabling mechanism and the unique reference relationship between each designer are the key logic of the platform operation.

[0081] Let's first look at the structure and reference relationship characteristics of each designer. The resource manager uses a linear linked list structure, and its internal operators can only reference elements within its own process. There is no hierarchical reference relationship, presenting a single-layer tree-like "bottom-reference-up" mode. The main task designer is constructed as a hierarchical structure, like a multi-layer tree. It can not only reference all operators of the resource manager, but also call operators within its own structure. However, the reference rules are limited to only referencing nodes at the same level above the current node, and nodes at the same level above the parent node. The HMI designer also has a hierarchical architecture. It can integrate all operators of the resource manager and the main task designer, but cannot reference its own internal operator controls. In the HMI designer, control operations such as data refresh and enablement of other controls can be achieved through control references.

[0082] To more intuitively understand the relationship between the three, assume that A represents the resource manager, B represents the main task designer, and C represents the HMI designer. C (HMI designer) depends on B (main task designer) and A (resource manager), which gives it the ability to control itself and all HMI controls. It can also reversely regulate B and A through the event manager. B (main task designer) references A (resource manager), allowing it to manage operators in its own process and manipulate objects and operators in A through reference. All processes in B can call A's operator structure. A (resource manager), on the other hand, can only reference A within its own scope, maintaining linear independence.

[0083] This relationship allows users to flexibly control all controls in C by referencing either A or B, thereby forming a tightly linked and mutually supportive interactive network between the resource manager, the main task designer, and the HMI designer. Based on this reference relationship, the disabling and enabling operations of operators in the platform also have corresponding processing logic, ensuring the correct flow of data and functions between components.

[0084] In order to more clearly demonstrate the interaction logic between the various components of the zero-code platform, an actual case is used to illustrate: there are "Button 1" and "Text Box 1" in the HMI designer, the resource manager defines "Global Variables", and the main task designer contains "Modify Variables".

[0085] "Button 1" is bound to "Modify Variable" through an event, meaning that clicking "Button 1" triggers the "Modify Variable" operation. "Modify Variable" references "Global Variable," meaning the value of the "Global Variable" can be modified through "Modify Variable." Whether "Text Box 1" is disabled depends on the reference to the "Global Variable." When the HMI switches to the Run state, clicking "Button 1" will disable "Text Box 1." This demonstrates how the HMI designer on the zero-code platform controls its own controls and the main task designer process (including its operators) by configuring reference relationships.

[0086] When disabling operators: If "Button 1" is disabled, it cannot be clicked, and naturally, the value of the "Global Variable" cannot be modified through "Modify Variable". If "Global Variable" is disabled, upon receiving the disable instruction, the canvas will first obtain the disabled operator and then notify "Modify Variable" through an event. At this time, "Text Box 1" will mark the "Modify Variable" operator as unconfigured, remove the reference relationship between "Modify Variable" and "Global Variable", set "Modify Variable" to unconfigured, and add it to the unconfigured list. At the same time, the reference association between the text box control and "Global Variable" will be severed.

[0087] The Zero-Code Platform consists of the Resource Manager, the Main Task Designer, and the HMI Designer. All three designers have the ability to disable and enable operators. The following describes how to disable operators in the Resource Manager and the Main Task Designer, respectively.

[0088] In the Resource Manager of the Zero-Code platform, to disable an operator, you can use the right-click menu or shortcut keys. After disabling, the system will obtain all references to the disabled operator, which may come from the Resource Manager itself, the main task designer, and the HMI designer.

[0089] The system will notify all other operators that reference the disabled operator through an event refresh. At this point, the referenced operators will receive a notification that the referenced operator has been annotated. The relevant logic will remain, but the data lines will be disconnected. The system will then promptly configure new references and reconnect the new data lines. At the same time, the flags of all referenced operators will be set to the unconfigured state, and these operators will be placed in the unconfigured list.

[0090] For example, if a "global variable" exists in Explorer A, and "Modify Variable" in the main task designer B references this "global variable," then when the "global variable" is disabled, upon receiving the disable instruction, the program will notify all operators referencing the "global variable," instructing them to disconnect their data connections and references to the disabled "global variable." Furthermore, the disabled operator can no longer be executed through debugging, and its related log information, such as data refresh and operator status processing, will no longer be displayed.

[0091] To disable operators in the Main Task Designer, you can also disable operators in the Main Task Designer using the right-click menu or shortcut keys. After the disable operation is executed, the system will obtain a list of references to the disabled operator in its own process and the HMI Designer.

[0092] Subsequently, the system uses an event refresh to inform all referenced operators that the operators they reference have been annotated. Although the process logic relationships of the main task designer itself will continue to be retained, the data relationships and reference relationships will be removed, and the data lines will be disconnected. At the same time, the status of the disabled operators will be promptly set to unconfigured and placed in the unconfigured list. Through this unconfigured list, users can clearly see the disabled operators and a list of other operators affected by the disablement, which greatly improves debugging efficiency.

[0093] In the zero-code platform, the disabling mechanism for controls and operators is closely linked. If "Button 1" and "Button 2" are both within the same parent container control, once the parent container control is disabled, "Button 1" and "Button 2" will also become unusable.

[0094] For example, if the "Read Image" operator is disabled, the system will immediately obtain a list of all operators under "Read Image" that reference it, as the "Template Matching" operator in its own process references the output of "Read Image." Subsequently, the system will refresh these referenced operators through event notifications. At this point, the reference relationship between "Template Matching" and "Read Image" will be severed, the data line will be disconnected, and the "Template Matching" operator will be set to the unconfigured state.

[0095] During process execution, the system monitors operator status in real time. If a process contains the "Read Image" operator, the system continuously checks to see if it is disabled or unconfigured. If this condition is met, the "Read Image" operation is terminated.

[0096] In the HMI Designer, if you bind the mouse click event of the "Button 1" control to the "Read Image" operator through the Event Manager, the binding operation will complete even if "Read Image" is disabled. However, when the HMI switches to the Running state and the user clicks "Button 1" to trigger the "Read Image" operator, the Zero Code Platform will receive the instruction and recheck whether "Read Image" is disabled or unconfigured. If the conditions are met, the "Read Image" operation will be terminated; otherwise, the relevant operations will be performed normally.

[0097] In the HMI Designer of the Zero-Code platform, disabling operator controls is handled as follows: To disable an operator control in the HMI Designer, use the right-click menu or shortcut keys. After disabling, the system retrieves the disabled operator and sets it to an unavailable state. At this point, the control cannot be triggered by mouse clicks or other methods.

[0098] The HMI Designer has two modes: design time and runtime. During design time, if you disable "Button 1," no noticeable change will occur. Operations in the Event Manager will still work normally, such as binding task operators in the Resource Manager or the Main Task Designer, and configuring operator tasks and reference relationships. However, during runtime, if "Button 1" is disabled, it becomes completely unusable, and all events and data configurations bound to it will not take effect.

[0099] For example, if a Table control is disabled at runtime and the main task designer uses the "Configure Table Data" operator to configure its data, the Table control will not receive and display the results of the "Configure Table Data" operation. Even if the Table control already has ten rows of data, the eleventh row of data passed to it will not be displayed if it is disabled.

[0100] Furthermore, enabling an operator task and creating the initial operator task are two different situations. Enabling an operator restores a disabled operator or control to its original state. Newly created operators automatically configure their logical relationships when they are generated. Disabling an operator retains its pre-disabling logical relationships. Newly created operators are automatically connected to the last operator in the current TreeView.

[0101] In the zero-code platform, to enable the operator of the resource manager, you can use the right-click menu or shortcut keys. The resource manager adopts a linear single-layer structure. When the operator is enabled, the system will perform the following operations:

[0102] The system retrieves all operator nodes under the enabled operator in the current process. It also retrieves information about all processes in the main task designer and a list of all form and control operators in the HMI designer. The system then iterates through this list of operators, notifying each one to refresh its ToolReferenceSet reference list. ToolReferenceSet is a property of every operator that provides access to the operator's reference list. When an operator is enabled, you can refresh its reference list by setting this property.

[0103] For example, when "Global Variables" is switched from disabled to enabled, the "Modify Variables" operator in the main task designer cannot query the "Global Variables" operator in its reference list when the "Global Variables" is disabled, because the reference relationship has been refreshed when the "Global Variables" is disabled. After "Global Variables" is enabled, by setting the ToolReferenceSet property of the "Modify Variables" operator, its reference list can be restored, and the "Global Variables" can then be queried or referenced through the reference dependency list.

[0104] After enabling an operator, the resource manager notifies the operator list below the currently enabled operator in its own process, the operator list of all processes in the main task designer, and the operator task list of all form controls in the HMI designer to perform a unified refresh operation.

[0105] In the zero-code platform, you can enable the main task designer operator through the right-click menu or shortcut keys. After the enable operation is executed, the system will perform a series of processing:

[0106] The system retrieves all peer operator nodes within the process containing the currently enabled operator, including all child nodes. It also retrieves the control list for all windows in the HMI designer, as well as all peer nodes and child nodes under the enabled operator, including operator information for all child windows and controls in the HMI designer. The system then notifies you to refresh the ToolReferenceSet reference list for each operator. ToolReferenceSet is a property of every operator that allows you to retrieve the operator's reference list. When an operator is enabled, setting this property refreshes the operator's reference list.

[0107] For example, suppose the "Read Image" operator is restored from a disabled state to an enabled state. The "Template Matching" operator originally referenced "Read Image." While "Read Image" was disabled, the reference relationship between "Template Matching" and "Read Image" was broken. Even if "Read Image" is re-enabled, this reference relationship is not automatically restored. At this point, the system notifies operators below and at the same level as the "Read Image" operator through an event, instructing them to refresh their ToolReferenceSet reference lists. It also notifies all form controls in the HMI designer to refresh their references to their control operators.

[0108] In addition, after enabling the operator, the main task designer will uniformly refresh the operator list below and at the same level as the currently enabled operator in its own process, as well as the operator task list of all form controls in the HMI designer, to ensure the consistency of related references and data in the entire system.

[0109] In the HMI Designer of the Zero-Code Platform, enabling control operators requires manual activation. Once enabled, the previously disabled control becomes available again, the event manager's ability to trigger processes or operators becomes effective again, and operations such as operator data refresh and table content update return to normal.

[0110] At the data flow level, when an operator is disabled, the system automatically identifies the data gap and provides feedback on the disabled operator and any other operators affected by it. For example, if operator A references operator B, when operator A is disabled, the reference relationship between it and operator B is deleted, and the data line is disconnected. At the same time, operator B is set to a non-executable and unconfigured state, and the entire program is marked as inoperable. Operator B is also added to the unconfigured list and displayed.

[0111] After an operator is disabled, you can query the reference relationships to obtain a list of referenced operators. After determining the referenced list, the system disconnects the data and clears the reference relationships, but leaves the logical relationships intact. It also sets the referenced operators to an unconfigured state and notifies the affected operators to perform a refresh.

[0112] When the operator is enabled, you only need to set the ToolReferenceSet property of the operator to restore the operator's reference list and restore the related functions to normal operation.

[0113] It should be understood that although this specification is described in terms of implementation methods, not every implementation method contains only one independent technical solution. This narrative method of the specification is only for the sake of clarity. Those skilled in the art should regard the specification as a whole. The technical solutions in each implementation method can also be appropriately combined to form other implementation methods that can be understood by those skilled in the art.

[0114] The series of detailed descriptions listed above are only specific descriptions of feasible implementation methods of the present invention. They are not intended to limit the scope of protection of the present invention. Any equivalent implementation methods or changes that do not deviate from the technical spirit of the present invention should be included in the scope of protection of the present invention.

Claims

1. A zero-code platform, characterized in that: include: Resource Manager, Master Task Designer and HMI Designer; When the resource manager receives the first instruction to disable the first operator, it sends a first message to the resource manager, the main task designer, and the HMI designer; when the main task designer receives the first instruction to disable the first operator, it sends a first message to the main task designer and the HMI designer; when the HMI designer receives the first instruction to disable the first operator, it sends a first message to the HMI designer, the main task designer, and the resource manager; wherein the first message is used to disable the first operator; Upon receiving the first message, the resource manager and the main task designer control each canvas process to perform the following operations: obtain a first target operator that references the first operator in the canvas process, dereference the first operator in the first target operator, then delete the first operator from a reference list corresponding to the first target operator, and then add the first operator to a list of non-referenceable operators corresponding to all task operators with the first operator in a disabled state; wherein the reference list corresponding to the first target operator at least stores: all operators referenced by the first target operator; When the HMI designer receives the first message, it controls each window canvas of the HMI designer to perform the following operations: obtaining a second target operator that references the first operator in the window canvas, releasing the reference to the first operator in the second target operator, and then deleting the first operator from a reference list corresponding to the second target operator; and then adding the first operator to a list of non-referenceable operators corresponding to all task operators, with the status of the first operator being disabled; wherein the reference list corresponding to the second target operator at least stores: all operators referenced by the second target operator.

2. The zero-code platform according to claim 1, characterized in that: Also includes: Design trees, decision trees, and execution trees; When receiving the first message, the resource manager, the main task designer and the HMI designer all perform the following third operation: obtaining the position and logical node of the first operator on the design tree, adding the position and logical node to the decision tree, and removing the logical node of the first operator from the execution tree.

3. The zero-code platform according to claim 2, characterized in that: When the resource manager receives the second instruction to enable the third operator, it sends a second message to the resource manager, the main task designer, and the HMI designer; when the main task designer receives the second instruction to enable the third operator, it sends a second message to the main task designer and the HMI designer; when the HMI designer receives the second instruction to enable the third operator, it sends a second message to the HMI designer, the main task designer, and the resource manager; wherein the second message is used to enable the third operator; When receiving the second message, the resource manager, the main task designer, and the HMI designer all perform the following operations: setting the state of the third operator in the decision tree to start, obtaining the position and logical node of the third operator on the design tree from the decision tree, and restoring the third operator to the node position corresponding to the execution tree based on the position and logical node.

4. The zero-code platform according to claim 3, characterized in that: When receiving the second message, the resource manager, the main task designer and the HMI designer set the state of the third operator in the referenceable operator list of all task operators to be enabled.

5. The zero-code platform according to claim 3, characterized in that: When the zero-code platform is in debug mode, disabled operators are not executed.

6. The zero-code platform according to claim 3, characterized in that: Also includes: A logging module for recording logs. The logging module does not record disabled operators.

7. The zero-code platform according to claim 3, characterized in that: In the canvas process and window canvas, when the status of the displayed operator is disabled, a disabled identifier is added to the position of the operator.

8. The zero-code platform according to claim 3, characterized in that: When the status of the displayed operator is disabled, the data line between the operator and any other operator is disconnected.

9. The zero-code platform according to claim 3, characterized in that: The main task designer is a hierarchical structure and can reference all operators in the resource manager; The HMI designer has a hierarchical structure and can reference all operators of the resource manager and the main task designer, but cannot reference operators in the HMI designer.

Images