Zero code platform

Abstract

The invention provides a zero code platform. The zero code platform comprises a resource manager, a main task designer and an HMI designer, when a resource manager, a main task designer and an HMI designer receive a message of disabling operators, each canvas in a canvas manager is controlled to execute the following operations: obtaining a first target operator quoting a first operator in the canvas, releasing the quotation of the first operator in the first target operator, and then, executing the first target operator in the first target operator; the first operator is deleted from the reference list corresponding to the first target operator, and then the first operator is added to the non-reference operator list corresponding to all the task operators, and the state of the first operator is forbidden; 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.

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] In traditional project development, there are often a large number of codes or modules to be written. Usually, code modules need to be quickly modified. To modify a code module, the delete or comment function must be used. It is impossible to confirm whether the commented code module is a comment description or a normal code module when it is opened later. In the zero - code platform software, there is a function to disable and activate operators. When this operator is disabled, the system will skip this operator during execution, and it can continue to operate after being enabled. Among them, disabling is a relatively commonly used function.

[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] To achieve one of the above - mentioned invention purposes, 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 a first operator, it sends a first message to the main task designer and the HMI designer; when the HMI designer receives a first instruction to disable a 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 a first target operator in the canvas process that references the first operator, remove 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 state of the first operator is disabled; wherein, the reference list corresponding to the first target operator stores at least: 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: obtain a second target operator in the window canvas that references the first operator, remove the reference to the first operator in the second target operator, then, delete the first operator from the reference list corresponding to the second target operator, and then, add the first operator to the non - referenceable operator list corresponding to all task operators and the state of the first operator is disabled; wherein, the reference list corresponding to the second target operator stores at least: all operators referenced by the second target operator.

[0006] As a further improvement of an embodiment of the present invention, a design tree, a decision tree, and an execution tree are designed; 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 an 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 state 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 corresponding node position on the execution tree based on the position and logical node.

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

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

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

[0011] As a further improvement of an embodiment of the present invention, in the canvas process and the window canvas, when the state of the 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 state of the displayed operator is disabled, the data line between the operator and any other operator is disconnected.

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

[0014] Compared with the prior art, the technical effect of the present invention is that: the 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 a first target operator in the canvas that references a first operator, 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, 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 stores at least: all operators referenced by the first target operator. This zero-code platform can implement the function of disabling operators. BRIEF DESCRIPTION OF THE DRAWINGS

[0015] Figure 1 is a schematic structural diagram of the zero-code platform in the embodiment of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0016] The present invention will be described in detail below with reference to the embodiments shown in the drawings. However, these embodiments do not limit the present invention, and structural, method, or functional transformations made by those of ordinary skill in the art based on these embodiments are all included in the protection scope of the present invention.

[0017] Spatial relative position terms such as "above", "upper", "below", "lower" used herein are for the purpose of facilitating description of the relationship of one unit or feature to another unit or feature as shown in the drawings. Spatial relative position terms may be intended to include different orientations of the device in use or operation other than the orientation shown in the figures. For example, if the device in the figure is flipped, the unit described as being "below" or "beneath" another unit or feature will be located "above" the other unit or feature. Therefore, the exemplary term "below" can encompass both the upper and lower orientations. The device may be oriented in other ways (rotated 90 degrees or other orientations), and the spatially related descriptive terms used herein can be interpreted accordingly.

[0018] Embodiment 1 of the present invention provides a zero-code platform, as Figure 1 shown, including: a resource manager, a main task designer, and an HMI designer.

[0019] Here, the Resource Manager has the following functions: (1) Centralized resource management, uniformly managing various 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 tagging, supporting classification by dimensions such as type, project, and permission for quick retrieval; (3) Version control, recording the resource change history and supporting rollback to previous versions; (4) Permission control, assigning access and editing permissions to resources based on roles. The Resource Manager generally includes the following modules: (1) Resource repository, storing all uploaded files or external service configurations; (2) Metadata management, adding attributes such as descriptions, tags, and dependencies to resources, which includes operators, etc.; (3) Search and filtering, supporting keyword search, type filtering, etc.; (4) Hardware initialization, through visual configuration, realizing the loading and initialization of hardware drivers.

[0020] Here, the Main Task Designer has the following functions: (1) Visual process orchestration, constructing business processes by dragging and dropping nodes (such as conditional branches, loops, operator calls); (2) Logic configuration, setting node parameters, data mapping, and exception handling rules; (3) Debugging tools, providing functions such as step-by-step execution, variable monitoring, and debugging logs to verify the correctness of the process; (4) Multi-task scheduling, supporting scheduled tasks and event triggers (such as triggering an 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 pushing, image processing, motion control, data collection); (2) Data flow engine, defining data transfer between nodes (such as the output of the previous node being the input of the next node); (3) Trigger configuration, setting process startup conditions (such as Webhook, timer, trigger); (4) Logging and monitoring, recording task execution history and performance metrics.

[0021] Here, the Human-Machine Interface Designer has the following functions: (1) Visual interface construction, designing interactive interfaces by dragging and dropping components (buttons, charts, tables); (2) Data binding, dynamically associating UI components with backend data sources (databases, APIs); (3) Responsive layout, adapting to different device screens (PC, tablet, mobile phone); (4) Interaction events, defining response logics for operations such as clicks and swipes (such as pop-ups, page jumps). The Human-Machine Interface Designer generally includes the following core modules: (1) Component library, basic components (input boxes, dropdown menus) and industry-specific components (such as industrial dashboards); (2) Style editor, adjusting colors, fonts, and animation effects, 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 this reference list stores this reference relationship.

[0023] 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; where the first message is used to disable the first operator.

[0024] 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, remove 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; where the reference list corresponding to the first target operator stores at least: all operators referenced by the first target operator.

[0025] In a zero-code platform, a task operator is a core concept, which refers to the smallest executable unit that encapsulates specific functions or logic. It is similar to a "function" or "module" in programming, but is presented in a visual, drag-and-drop manner, and 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, sending emails, calling APIs, etc.), and users build a complete business process by combining multiple operators; (2) Zero-code operation, operators are configured through a graphical interface (such as filling out forms, dragging and connecting lines), without programming knowledge. For example: when configuring a "send email" operator, only the recipient, subject, and body template need to be entered; (3) Input and output, the input is the data passed by the previous step received by the operator (such as form data, variables, API responses, etc.), and the 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: obtain a second target operator in the window canvas that references the first operator, remove the reference to the first operator in the second target operator, then delete the first operator from the reference list corresponding to the second 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 second target operator stores at least: all operators referenced by the second target operator.

[0028] The zero-code platform has an efficient and systematic mechanism for handling the disabling of operators or components / controls in different designers. The corresponding disabling processing procedures in the resource manager, main task designer, and HMI designer are introduced separately below.

[0029] Resource manager operator disabling processing: When an operator in the resource manager is disabled, a series of operations will be triggered. First, the system will notify the upper layer and call the operator status change event. After the resource manager, main task designer, and HMI designer receive this event, they will distribute it to their respective processes, namely the resource management process, each canvas process of the main task designer, and each window canvas of the HMI designer.

[0030] Each canvas will then notify the information to each affected operator. The affected operator will remove the reference to the disabled operator and at the same time remove the operator from its own reference list. In the main task designer, when the operator performs a refresh operation, the canvas process will synchronously refresh the data connection lines, such as performing disconnection operations, but the logical connection lines will remain unchanged. Through the reference manager, the system can directly locate and notify the affected operators, avoiding the inefficiency of the traditional method of notifying all operators without discrimination and then having the operators judge whether to refresh the configuration by themselves, greatly improving the execution efficiency.

[0031] After that, the system will record the position and logical node of the operator in the design tree into the decision tree, and at the same time remove the operator node from the execution tree. And the system will refresh the referenceable operator list of the task operator to ensure that the operator can be updated to the latest referenceable operator list in real time.

[0032] Main task designer operator disabling processing: When an operator in the main task designer is disabled, it will also notify the upper layer and call the operator status change event. After the main task designer and HMI designer receive the event, they 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, and the affected operators remove the reference to the disabled operator and remove it from the reference list. When the main task designer operator is refreshed, the canvas process synchronously refreshes the data connection, and the logical connection remains unchanged.

[0034] Similar to the disabling of the resource manager operator, the system records the position and logical node of the operator in the design tree in the decision tree, removes the operator node from the execution tree, and simultaneously refreshes the reference list of the task operators.

[0035] The disabling of HMI designer components / controls is divided into two cases: design time and runtime.

[0036] Design time: When in design time, the disabling of a component / control notifies the upper layer and calls the operator status change event, notifying the resource management and the main task designer. After receiving the event, the main task designer and the HMI designer distribute it to their respective canvas processes, and then the canvas notifies the affected operators. The affected operators remove the reference to the component / control and remove it from the reference list. However, at this time, the control can still perform operations such as event binding, data source setting, and reference setting normally.

[0037] Runtime: When in runtime, after a component / control is disabled, no operations of the control will be executed, and it will not respond to mouse or keyboard events.

[0038] Similarly, the system records the position and logical node of the operator in the design tree in the decision tree, removes the operator node from the execution tree, and simultaneously refreshes the reference list of the task operators.

[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 the real-time update of data.

[0040] In this embodiment, it further 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 in 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: a resource manager, a main task designer, and an HMI (Human Machine Interface) designer. In this platform, the design of the operator disabling and enabling scheme is exquisite, and there are mutual influences among the designers: (1) The operation of disabling or enabling an operator in the resource manager will affect the operators in the main task designer and the components in the HMI designer; (2) The disabling or enabling of an operator in the main task designer will affect the components in the HMI designer; (3) The disabling or enabling of a control in the HMI designer will act on the operators in the resource manager and the main task designer.

[0042] There are also three task trees in the platform, each undertaking different functions: Design tree: Saves the platform task tree according to a specific logic, which are the resource manager task tree, the main task designer tree, and the HMI designer task tree in sequence. Each tree covers all the operators or components within the corresponding designer. In the design tree, the operators in the front are visible to the operators or controls behind, while the operator nodes behind are not visible to the nodes in the front.

[0043] Decision tree: Mainly responsible for saving the disabled operators in the platform, thereby determining whether an operator is disabled or enabled, and further judging whether the operator will be executed. The decision tree also manages the status and status switching of operators. Once the operator status changes, it will notify the platform scheduler to adjust the logic in the execution tree and perform the addition and deletion operations of operators. This design is extremely convenient during program debugging, as it can switch the disabling / enabling status of operators at any time, effectively improving the program debugging efficiency.

[0044] Execution tree: Only saves the normally enabled operators within each designer, and the execution logic of these operators is also retained in the correct order. The disabled operators do not appear in the execution tree. In this way, during the normal execution of the program, the task execution efficiency can be improved. The overall idea of operator disabling / enabling revolves around these three designers and task trees. Through their collaborative work, it not only meets the need for flexible adjustment during program debugging but also ensures the high efficiency during the normal operation of the program.

[0045] In this embodiment, when the resource manager receives a 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 a 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 a second instruction to enable the third operator, it sends a second message to the HMI designer, the main task designer, and the resource manager; where the second message is used to enable the third operator.

[0046] When the resource manager, the main task designer, and the HMI designer receive the second message, they all perform the following operations: set the state of the third operator in the decision tree to started, 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 corresponding node position in the execution tree based on the position and logical node.

[0047] In this embodiment, when the resource manager, the main task designer, and the HMI designer receive the second message, in the list of referenceable operators of all task operators, set the state of the third operator to enabled.

[0048] In this embodiment, when the zero-code platform is in the debug mode, it does not execute the disabled operators.

[0049] In this embodiment, it further includes: a log module for recording logs, and the log module does not record the disabled operators.

[0050] In this embodiment, in the canvas process and the window canvas, when the state of the displayed operator is disabled, a disable identifier is added at the position where the operator is located.

[0051] In this embodiment, when the state of the displayed operator is disabled, disconnect the data line between the operator and any other operator.

[0052] Optionally, the resource manager is a linear linked list, and there is no hierarchical structure in the internal operator structure and reference relationship.

[0053] 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 in the resource manager and the main task designer, and cannot reference the operators in the HMI designer.

[0054] In the zero-code platform, the main task designer and the resource manager have different characteristics and interaction methods, and there are also specific rules for the reference configuration of operators. The following will introduce them in detail.

[0055] The main task designer adopts a tab mode, and the user can create multiple processes. While the resource manager has only one tab, and actually the interface of the resource manager can be regarded as a special process, that is, the resource process.

[0056] Among the operators in the zero-code platform, there is an object of the IToolReferenceSet type. Both the resource manager and the main task designer need to implement this interface. This interface has the following functions: obtain the detailed information of the operator through the globally unique identifier (GUID); check whether a certain operator exists in the current process; obtain the reference list of a certain operator.

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

[0058] Specifically, the processes of the resource manager and the main task designer both implement the IToolReferenceSet interface. An object of the IToolReferenceSet interface type is defined inside the operator. When creating an operator, if it is an operator in the resource manager, the IToolReferenceSet object of its own process will be assigned to this operator; if it is an operator in the main task process, first the list of operator objects in the resource manager will be obtained and embedded as resource objects into the reference list of the current process, and then the operator reference list of its own process will be assigned to the IToolReferenceSet property object of the newly created operator. Through such operations, the reference configuration can be completed when the operator is created.

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

[0060] In the zero-code platform, the resource manager undertakes the key responsibility of configuring platform resources. It is responsible for creating various resource operator objects, such as "global variables", "initializing motion control boards", "initializing log objects", etc. These created resource operator objects will be passed to the main task designer and the HMI designer. The main task designer and the HMI designer can build control processes, manage controls and operators, and implement corresponding functions by referencing these resource objects.

[0061] Looking at the internal management mechanism of the resource manager, it uses a linear list structure. This structure does not require hierarchical processing, and a single-layer structure can meet the requirements. The List collection is exactly suitable for managing this single-layer structure because the List collection itself is single-layer. Whenever a resource operator object is created, the resource manager will add it to the List collection object used to manage operators.

[0062] When the resource manager completes the operator addition operation, it will trigger the Added event. This event notifies the main framework that the resource operator tasks in the resource manager have changed and marks the current project as an unsaved state. Next, the process manager in the main task designer will come into play. The process manager will obtain the list of all resource operator objects in the resource manager and add this list to itself all at once. 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 in the main task designer. Additionally, a ListGet property is defined inside the resource manager, and with the help of this property, it is possible to easily obtain all the resource operator objects in the resource manager.

[0063] The way the resource manager uses event notifications has great advantages. For example, in the process built by the main task designer, it includes "Read Image" and "Template Matching" links. If you want to obtain the template coordinate information with an index of 2 in "Template Matching", that is, when performing an "Array Extraction" operation, you need to reference an index object. At this time, you can 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 in them, through the Added event, informing them that the resources have changed. In this way, when opening the "Array Extraction" operator, you can directly reference the index in the "Global Variable", thereby automatically updating the reference resource list and achieving accurate acquisition and use of data.

[0064] The management of reference relationships by the main task designer. The main task designer adopts a hierarchical structure and is managed internally in a tree structure. For example, in the process, there are two operators, "Read Image" and "Conditional Branch". "Conditional Branch" has multiple levels of child nodes, and logical relationships can be written in the child nodes, while "Read Image" does not have multiple levels of nodes.

[0065] When creating an operator, by default, it will be added to the end of the process tree structure. At this time, taking the current process as a reference object (including resource objects) and assigning it to the IToolReferenceSet property of the newly created operator, this operator can obtain the resource reference list and the reference list of its own process. Inside the operator, it is possible to filter out the referenceable list by defining referenceable data types and filtering conditions.

[0066] Assume that there are already "Read Image" and "Conditional Branch" in the process. The child nodes of "Conditional Branch" are divided into two branches: "True" and "False". Under the "True" branch, there is "Expression Parsing 1", and under the "False" branch, there is "Expression Parsing 2". Then, both "Expression Parsing 1" and "Expression Parsing 2" can reference the output result of "Read Image", but they cannot reference each other. This is because the reference rule of the zero-code development platform is that the following operators can reference the above operators, and the child node branches cannot reference the same-level nodes, but can only reference the parent node and the nodes at the same level and above.

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

[0068] When an operator with child node branches is disabled, for example, when the "Conditional Branch" is set to the disabled state, when the program runs to this "Conditional Branch", it will not traverse all the child nodes under this node, nor execute the child node branch structure under the "Conditional Branch", but directly skip the "Conditional Branch" and execute the subsequent operators.

[0069] Regarding the setting of the reference relationship in the HMI Designer, when the HMI Designer is opened, it will actively obtain the resource list of the Resource Manager and the reference list of all processes in the Main Task Designer. The set of reference lists defined inside the HMI Designer is equal to the reference list of the Resource Manager plus the process reference list of the Main Task Designer.

[0070] When creating an operator control, the obtained HMI Designer list will be assigned to the IToolReferenceSet property of the operator. The HMI control also belongs to the operator structure, and its internal structure is the same as that of the resource operator and the process operator.

[0071] In summary, the above content explains how to configure the reference relationship of operators, including how to filter reference conditions, and the mutual reference relationship structure among the three parts: the Resource Manager, the Main Task Designer, and the HMI Designer.

[0072] In the zero-code platform, the disable and enable operations of operators have specific processing methods, and at the same time, the reference relationships among the components within the platform also have unique characteristics.

[0073] Let's first look at the characteristics of the reference relationships in the zero-code platform. The resource manager adopts a linear linked list structure, and there is no layering in its internal operator structure and reference relationships. It can only be referenced within its own process. The main task designer, on the other hand, has a layered structure. It can not only reference all the operators in the resource manager but also the operators within its own structure. Its internal operator structure and reference relationships are also layered. The HMI designer also has a layered structure. It can reference all the operators in the resource manager and the main task designer, but it cannot reference the operator controls of the HMI designer itself. The HMI designer can achieve control operations such as data refreshing and enabling of other controls through the way of control by reference.

[0074] To understand the reference relationships between components more clearly, assume that A represents the resource manager, B represents the main task designer, and C represents the HMI designer. The reference relationships between them are as follows: C (HMI designer) references B (main task designer) and A (resource manager), which enables C to control all the controls in itself and the HMI. At the same time, C can also control B and A with the help of the event manager.

[0075] B (main task designer) references A (resource manager). In this way, B can not only control the operators in its own process but also control the objects and operators in A through reference. And all the operator processes in B can reference the operator structure in A.

[0076] A (resource manager) can only reference itself. Its reference relationship presents a linear structure, similar to a single-layer tree, with a bottom-up reference relationship.

[0077] Specifically, the reference relationship of the A resource manager is a linear single-layer tree structure. The reference relationship of the main task designer is a multi-layer tree. It can only reference the sibling nodes above the current node and the sibling nodes above the parent node, which also includes all the operators in the single layer of the resource manager. The HMI designer can reference multiple tree-shaped layered structures, including all the processes (which also includes all the operators) in the B main task designer and all the operators in the single layer of the A resource manager. By referencing the A resource manager or the B main task designer, it is possible to control all the form controls in the C HMI designer, thus forming an interrelated reference relationship among A, B, and C.

[0078] 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 mechanism of disabling and enabling operators and the unique reference relationships between the designers are the key logics for the platform to run.

[0079] Let's first look at the structural and reference relationship characteristics of each designer. The resource manager adopts a linear linked list structure. Its internal operators can only reference elements within their own processes and there is no hierarchical reference relationship, presenting a single-layer tree-like "downward referencing upward" mode. The main task designer is constructed as a hierarchical structure, like a multi-layer tree. It can not only reference all the operators of the resource manager but also call the operators within its own structure. However, the reference rule is limited to only referencing the sibling nodes above the current node and the sibling nodes above the parent node. The HMI designer also has a hierarchical architecture. It can integrate all the operators of the resource manager and the main task designer, but it cannot reference the operator controls within itself. In the HMI designer, control operations such as data refreshing and enabling of other controls can be achieved through the way of control reference.

[0080] To understand the relationship among the three more intuitively, 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 endows it with the ability to control all the controls of itself and the HMI, and can also reverse-control B and A through the event manager; B (main task designer) references A (resource manager), can not only manage the operators in its own process but also operate on the objects and operators in A through reference, and all the processes in B can call the operator structure of A; while A (resource manager) can only reference within its own scope and remains linearly independent.

[0081] This relationship enables users to flexibly control the controls of all forms in C by referencing A or B, thus forming an interactive network that is closely linked and mutually supportive among the resource manager, the main task designer, and the HMI designer. Based on such a reference relationship, there is also a corresponding processing logic for the disabling and enabling operations of the operators in the platform to ensure the correct flow of data and functions among various components.

[0082] To more clearly show the interaction logic among the components of the zero-code platform, an actual case is used to illustrate: There are "Button 1" and "TextBox 1" in the HMI designer, the resource manager defines "global variables", and the main task designer contains "modify variable".

[0083] "Button 1" is bound to "modify variable" through an event, which means that clicking "Button 1" can trigger the operation of "modify variable"; "modify variable" references "global variables", that is, the value of "global variables" can be modified through "modify variable"; whether "TextBox 1" is disabled depends on the reference to "global variables". When the HMI switches to the running state, once "Button 1" is clicked, "TextBox 1" will become unavailable. This shows how the HMI designer of the zero-code platform can control its own controls and the processes (including the operators therein) of the main task designer by configuring reference relationships.

[0084] When it comes to operator disabling: If "Button 1" is set to disabled, it cannot be clicked, and naturally, the value of the "global variable" cannot be modified through "Modify Variable". If the "global variable" is disabled, after the canvas receives the disabling instruction, it will first obtain the disabled operator and then notify "Modify Variable" through an event. At this time, "TextBox 1" will mark the "Modify Variable" operator as unconfigured, remove the reference relationship between "Modify Variable" and the "global variable", set "Modify Variable" to the unconfigured state and add it to the unconfigured list, and at the same time cut off the reference association between the text box control and the "global variable".

[0085] The zero-code platform consists of a resource manager, a main task designer, and an HMI designer. All three designers have the function of disabling and enabling operators. The following separately introduces the processing methods of operator disabling in the resource manager and the main task designer.

[0086] Processing of operator disabling in the resource manager. In the resource manager of the zero-code platform, if you want to disable an operator, you can operate through the right-click menu or shortcut keys. After the disabling is completed, the system will obtain all the reference relationships of the disabled operator, and these references may come from the resource manager itself, the main task designer, and the HMI designer.

[0087] The system will notify all other operators that reference the disabled operator in the way of event refreshing. At this time, the referenced operator will receive a prompt, knowing that the referenced operator has been annotated, but the relevant logic will be retained, only the data line will be disconnected. After that, the system will promptly configure new reference relationships and connect new data lines. At the same time, the flag bits of all referenced operators will be set to the unconfigured state, and these operators will be uniformly placed in the unconfigured list.

[0088] For example, if there is a "global variable" in the resource manager A and the "Modify Variable" in the main task designer B references this "global variable". When the "global variable" is set to the disabled state, once the program receives the disabling instruction, it will notify all operators that reference the "global variable" to disconnect the data connection and reference relationship with the disabled "global variable". Moreover, the disabled operator cannot be executed through the debugging function, and its relevant log information, such as data refreshing, operator status processing, etc., will no longer be displayed.

[0089] Processing of operator disabling in the main task designer. To disable an operator in the main task designer, you can also use the right-click menu or shortcut keys. After the disabling operation is executed, the system will obtain the reference list of the disabled operator in its own process and the HMI designer.

[0090] Subsequently, the system notifies all referenced operators through event refreshing 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 the list of other operators affected by the disabling, which greatly improves the debugging efficiency.

[0091] In the zero-code platform, the disabling mechanisms of controls and operators are closely related. When "Button 1" and "Button 2" are within the same parent container control, once the parent container control is disabled, "Button 1" and "Button 2" will also become unusable.

[0092] Taking operator disabling as an example, if the "Read Image" operator is disabled, since the "Template Matching" operator in its own process references the output result of the "Read Image", the system will immediately obtain the list of all operators that reference it under the "Read Image". Subsequently, through event notification, the system will refresh these referenced operators. At this time, the reference relationship between "Template Matching" and "Read Image" will be cut off, the data line will be disconnected, and at the same time, the "Template Matching" operator will be set to the unconfigured state.

[0093] During the process of running, the system will detect the operator status in real time. If the running process contains the "Read Image" operator, the system will continuously check whether it is in the disabled or unconfigured state. Once this condition is met, the operation of the "Read Image" will be terminated.

[0094] In the HMI designer, if the mouse click event of the control "Button 1" is bound to the "Read Image" operator through the event manager, even if the "Read Image" is in the disabled state, the binding operation can still be completed. However, when the HMI switches to the running state and the user clicks "Button 1" to trigger the "Read Image" operator, after the zero-code platform receives the instruction, it will detect again whether the "Read Image" is disabled or unconfigured. If the condition is met, the operation of the "Read Image" will be exited; if not, the relevant operations will be executed normally.

[0095] In the HMI designer of the zero-code platform, the method of handling the disabling of operator controls is as follows: When it is necessary to disable the operator controls in the HMI designer, the right-click menu or shortcut key operations can be used. After disabling, the system will obtain the disabled operator and set it to the unavailable state. At this time, the control cannot be triggered by mouse click or other means.

[0096] The HMI designer has two modes: design time and runtime. At design time, if "Button 1" is set to the disabled state, no obvious change will be seen on the surface, and it can still be operated normally in the event manager. For example, tasks operators in the resource manager or the main task designer can be bound, and the operator tasks and reference relationships can also be configured normally. However, at runtime, if "Button 1" is in the disabled state, it will be completely unavailable, and all the events and data configurations bound to it will not take effect.

[0097] Taking the "Table" control as an example, when it is in the disabled state at runtime, and the main task designer uses the "Configure Table Data" operator to configure data for it, the "Table" control will not receive and display the result of the "Configure Table Data". Even if the "Table" control originally had ten rows of data, the newly passed eleventh row of data will not be displayed in the disabled state.

[0098] In addition, enabling operator tasks and creating initial operator tasks are two different situations. Enabling an operator is an operation on a disabled operator or control to make it available again; while a newly created operator will have its logical relationships automatically configured when it is generated. After an operator is disabled, its logical relationships before being disabled will be retained; a newly created operator will be automatically connected to the last operator position in the current TreeView tree list.

[0099] In the zero-code platform, if you want to enable the operators of the resource manager, you can do it through the right-click menu or shortcut key operations. The resource manager adopts a linear single-layer structure. When an operator is enabled, the system will perform the following operations: The system will obtain all the operator nodes below the enabled operator in the current process, and at the same time, it will also obtain the information of all processes in the main task designer, as well as the list of all form and control operators in the HMI designer. Then, the system will traverse this operator list and notify each of them to refresh the ToolReferenceSet reference list one by one. ToolReferenceSet is an attribute that each operator has, and through this attribute, the reference list that the operator can use can be obtained. When an operator is in the enabled state, the reference list of the operator can be refreshed by setting this attribute.

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

[0101] After enabling an operator, the Resource Manager will notify 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.

[0102] In the zero-code platform, the operation of enabling an operator in the main task designer can be completed through the right-click menu or shortcut keys. After the enabling operation is executed, the system will perform a series of processes: The system will obtain all sibling operator nodes below the currently enabled operator in the process where the operator is located, which includes all child nodes. At the same time, it will also obtain the control list of all forms in the HMI designer, as well as all sibling nodes and child nodes under the enabled operator, including the operator information of all child forms and controls in the HMI designer. After that, the system will notify to refresh the ToolReferenceSet reference list of each operator. ToolReferenceSet is an attribute that each operator has, and using this attribute, the reference list that can be referenced by the operator can be obtained. When the operator is in the enabled state, by setting this attribute, the reference list of the operator can be refreshed.

[0103] For example, assume that the "Read Image" operator is restored from the disabled state to the enabled state. Originally, the "Template Matching" operator references the "Read Image". During the period when the "Read Image" was disabled, the reference relationship between the "Template Matching" and the "Read Image" was disconnected. Even if the "Read Image" is restored to the enabled state, this reference relationship will not be automatically restored. At this time, the system will notify the operators of the nodes below and at the same level as the "Read Image" operator through an event to refresh their ToolReferenceSet reference lists, and at the same time notify all form controls in the HMI designer to refresh the reference of their control operators.

[0104] In addition, after enabling an 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, so as to ensure the consistency of relevant references and data in the entire system.

[0105] In the HMI designer of the zero-code platform, enabling a control operator requires a manual start method. After enabling, the originally disabled control will return to the available state, the functions of the event manager to trigger processes or operators will take effect again, and operations such as data refreshing of operators and table content updating will also return to normal.

[0106] At the data circulation level, when an operator is disabled, the system will automatically identify the data break and feedback the disabled operator and other operators affected by it. For example, if operator A references operator B, when operator A is in the disabled state, the reference relationship between it and operator B will be deleted, and the data line will also be disconnected. At the same time, operator B will be set to the non-executable and unconfigured state, and the entire program will be marked as non-runable. Operator B will also be added to the unconfigured list and displayed.

[0107] After the operator is disabled, by querying the reference relationship, a list of referenced operators can be obtained. After determining the referenced list, the system will disconnect the data connection, clear the reference relationship, but the logical relationship remains unchanged. At the same time, the referenced operator will be set to the unconfigured state, and the affected operators will be notified to perform a refresh operation.

[0108] When the operator is enabled, simply setting the ToolReferenceSet property of the operator can restore the reference list of the operator and enable the related functions to run normally.

[0109] It should be understood that although this specification is described according to the embodiments, not every embodiment only contains an independent technical solution. This narrative way of the specification is only for clarity. Those skilled in the art should regard the specification as a whole, and the technical solutions in each embodiment can also be appropriately combined to form other embodiments that can be understood by those skilled in the art.

[0110] The series of detailed descriptions listed above are only specific descriptions of the feasible embodiments of the present invention, and they are not intended to limit the protection scope of the present invention. Any equivalent embodiments or changes made without departing from the technical spirit of the present invention should be included in the protection scope of the present invention.

Claims

1. A zero-code platform, characterized in that, Including: 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 a first operator, it sends a first message to the main task designer and the HMI designer; when the HMI designer receives a first instruction to disable a 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 a first target operator in the canvas process that references the first operator, remove 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 stores at least: 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: obtain a second target operator in the window canvas that references the first operator, remove the reference to the first operator in the second target operator, then, delete the first operator from the reference list corresponding to the second 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 second target operator stores at least: all operators referenced by the second target operator.

2. The zero-code platform according to claim 1, wherein Further including: 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 in the decision tree, and remove the logical node of the first operator from the execution tree.

3. The zero-code platform according to claim 2, wherein When the resource manager receives a second instruction to enable a 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 a second instruction to enable a third operator, it sends a second message to the main task designer and the HMI designer; when the HMI designer receives a second instruction to enable a 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 corresponding node position on the execution tree based on the position and logical node.

4. The zero-code platform according to claim 3, characterized in that when the resource manager, the main task designer, and the HMI designer receive the second message, in the list of referenceable operators of all task operators, the status of the third operator is set to enabled.

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

6. The zero-code platform according to claim 3, characterized in that It further includes: a log module for recording logs, and the log module does not record the disabled operators.

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

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 is a hierarchical structure and can reference all operators in the resource manager and the main task designer, and cannot reference the operators in the HMI designer.

Images