Visual arrangement system and maintenance method for thingworx equipment access

Abstract

The invention discloses a visual arrangement system for thingWorx equipment access, and the system comprises a node control which is configured with a thingWorx associated event or service according to a thingWorx extended object template; the node toolbar is used for displaying and managing the node control; the node arrangement space and the node toolbar are adjacently arranged, the node arrangement space is used for configuring the node controls, and the node arrangement space is used for configuring the connection relations among the multiple node controls; wherein the node control is used for being moved to the node arrangement space, and the node control is configured based on a ThingWorx object template. Compared with the prior art, the technical scheme of the visual arrangement system for thingWorx equipment access provided by the invention can overcome the problem that the ThingWorx configuration operation is complex and easy to make mistakes in the prior art, and can improve the configuration efficiency of the thingWorx equipment. The invention further provides a maintenance method, and the maintenance method also has the above technical effects.

Description

Technical Field

[0001] This invention relates to the field of software development technology, and more specifically, to a visual orchestration system for accessing Thingsworx devices. Background Technology

[0002] ThingWorx Kepware Server boasts over 150 different drivers, ensuring standardized industrial connectivity between heterogeneous devices and assets, unlocking IoT scalability. ThingWorx's flexibility, ease of use, and scalability have made it the preferred choice for many developers, making it arguably the most popular development platform on the market in the IoT industry. However, existing technologies like ThingWorx suffer from complex configuration, error-prone operation, long setup times, low efficiency, high learning curve, and significant learning costs.

[0003] Therefore, how to provide a visual orchestration system for ThingWorx device access that can overcome the problems of complex and error-prone configuration operations in existing ThingWorx technologies and improve configuration development efficiency has become a technical problem that urgently needs to be solved by those skilled in the art. Summary of the Invention

[0004] To address the aforementioned technical problems, this invention provides a visual orchestration system for ThingWorx device access, which overcomes the problems of complex and error-prone ThingWorx configuration operations in the prior art, and improves configuration development efficiency. This invention also provides a maintenance method, which has the same technical effects.

[0005] The technical solution provided by this invention is as follows:

[0006] This invention provides a visual orchestration system for ThingWorx device access. The method includes: node controls, which are configured with ThingWorx associated events or services based on ThingWorx extended transaction templates; a node toolbar, which is used to display and manage the node controls; and a node orchestration space, which is adjacent to the node toolbar and used for configuring the node controls and configuring the connection relationships between multiple node controls. The node controls are moved to the node orchestration space; multiple node controls establish connection relationships; each node control includes three node attributes: start node, end node, and intermediate node, and the node controls are configured based on ThingWorx transaction templates.

[0007] Furthermore, in a preferred embodiment of the present invention, the Thingworx thing template is a special extended thing template;

[0008] The Thingworx transaction templates include: MQTTClient transaction template, KafkaThing transaction template, and DataTransform transaction template;

[0009] The MQTTClient transaction template is based on the "MQTT" template of the Thingworx transaction template, and is used to provide the "MQTTTAnyTopicConsume" event and the "MQTTPublish" service; the KafkaThing transaction template is extended from the Thingworx transaction template and is used to provide...

[0010] The "KafkaAnyTopicConsume" event and the "SendMessage" service;

[0011] The DataTransform transaction template is based on the "GenericThing" template of the Thingworx transaction template and is used to provide the "TransformEvent" and "EmitMessage" services.

[0012] Furthermore, in a preferred embodiment of the present invention, the start node is an input node, which is used to receive upstream data; the end node is an output node, which is used to output data downstream; and the intermediate node is a message conversion node and a message routing node, which is used to process messages from upstream nodes and forward them to downstream nodes.

[0013] Furthermore, in a preferred embodiment of the present invention, the node categories of the start node include: "MQTT subscription", "Kafka subscription", "HTTP listener", "file input", "read database", and "value change"; the node categories of the end node include: "MQTT publish", "Kafka write", "write database", "write file", and "HTTP response".

[0014] Furthermore, in a preferred embodiment of the present invention, the "MQTT Subscription" node acquires and triggers the "MQTTAnyTopicConsume" event based on "MQTTClient" type transactions to complete node output; the "Kafka Write" node subscribes to and acquires events from the upstream starting node; the "Kafka Write" node uses the "SendMessage" service provided by "KafkaThing" as output based on "KafkaThing" type transactions; the intermediate node, based on "DataTransform" type transactions, subscribes to and acquires special events from upstream as input, triggers the "TransformEvent" event to complete node output.

[0015] Furthermore, in a preferred embodiment of the present invention, the node control, the node toolbar, and the node arrangement space are created based on the antv / g6 graph editing engine;

[0016] Multiple node controls establish connections in the node arrangement space;

[0017] The node control is in a configurable state. A new node control can be created by editing instructions, and the items in the new node control are also in a configurable state.

[0018] Furthermore, in a preferred embodiment of the present invention, the node toolbar is provided with a configuration table, which is used to store specific configuration information to facilitate the retrieval of configuration input.

[0019] Furthermore, in a preferred embodiment of the present invention, it further includes: a rule module; the rule module is used to maintain the transaction relationships of the ThingWorx;

[0020] The rules in the rules module include: adding rules, modifying rules, and deleting rules;

[0021] The newly added rule includes: storing a rule record in the database, and also storing the relationship data between the rule and related items;

[0022] The modification rules include deleting the original relation data and saving the new relation data;

[0023] The deletion rules include deleting the corresponding relational data.

[0024] In addition, the present invention also provides a maintenance method, including the step of: inserting rule records;

[0025] Maintain rule-related transactions; maintain records of the relationship between rules and transactions; wherein, maintaining rule-related transactions includes the following steps: maintaining MQTTClient transactions integrated with MQTT subscriptions; maintaining DataTransform transactions integrated with message transformations; maintaining KafkaThing transactions integrated with Kafka write transactions.

[0026] Furthermore, in a preferred embodiment of the present invention, maintaining the MQTTClient transaction integrated with the "MQTT subscription" includes the following steps:

[0027] Create an MQTTClient transaction integrated with "MQTT subscription";

[0028] Store the Configuration Tables for transactions, where the Configuration Tables are the Topics for the transactions to be subscribed to;

[0029] The DataTransform transaction for maintaining message transformation integration includes the following steps:

[0030] Determine if it is a new transaction; if so, create a DataTransform transaction integrated with the message transformation node.

[0031] Subscribe to the MQTTAnyTopicConsume event of the MQTTClient, maintain the message transformation script, and call the triggered transformation event in the subscription;

[0032] Store the configuration tables for transactions;

[0033] The maintenance of the KafkaThing for Kafka write transaction integration includes the following steps:

[0034] Create a KafkaThing transaction integrated with the "Kafka Write" node;

[0035] Subscribe to the DataTransform transformation event and call your own SendMessage service within the subscription;

[0036] Save the Configuration Tables of the transaction, that is, save the target topic to which it is to be sent.

[0037] This invention provides a visual orchestration system for ThingWorx device access. Compared with existing technologies, it includes: node controls configured with ThingWorx associated events or services based on ThingWorx extended transaction templates; a node toolbar for displaying and managing the node controls; and a node orchestration space adjacent to the node toolbar, used for configuring the node controls and configuring the connection relationships between multiple node controls. The node controls are moved to the node orchestration space, and multiple node controls establish connection relationships. Each node control includes three node attributes: start node, end node, and intermediate node. The node controls are configured based on ThingWorx transaction templates. This visual orchestration system for ThingWorx device access overcomes the problems of complex and error-prone ThingWorx configuration operations in existing technologies, improving configuration development efficiency. This invention also provides a maintenance method with the same technical effects. Attached Figure Description

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

[0039] Figure 1 The working principle of the implementation method in the visual orchestration system for Thingworx device access provided in the embodiments of the present invention;

[0040] Figure 2 This is a flowchart illustrating another implementation of the visual orchestration system for accessing Thingsworx devices according to an embodiment of the present invention.

[0041] Figure 3 This is a schematic diagram of a rule editing window provided in an embodiment of the present invention;

[0042] Figure 4 This is a schematic diagram of a rule node editing window provided in an embodiment of the present invention;

[0043] Figure 5 This is a schematic diagram of the data flow nodes involved in the embodiments of the present invention;

[0044] Figure 6 This is a schematic diagram illustrating the rule maintenance process according to an embodiment of the present invention;

[0045] Figure 7 This is a schematic diagram of an MQTTClient transaction for maintaining an integrated "MQTT subscription" node, as described in an embodiment of the present invention.

[0046] Figure 8 This is a schematic diagram of the DataTransform transaction integrated by the maintenance message transformation node according to an embodiment of the present invention;

[0047] Figure 9 This is a schematic diagram of the KafkaThing that maintains the integration of Kafka write node transactions according to an embodiment of the present invention. Detailed Implementation

[0048] To enable those skilled in the art to better understand the technical solutions of this invention, the technical solutions of the embodiments of this invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of this invention, and not all of them. Based on the embodiments of this invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this invention.

[0049] It should be noted that when a component is referred to as "fixed to" or "set on" another component, it can be directly on or indirectly set on the other component; when a component is referred to as "connected to" another component, it can be directly connected to or indirectly connected to the other component.

[0050] It should be understood that the terms "length", "width", "upper", "lower", "front", "rear", "first", "second", "vertical", "horizontal", "top", "bottom", "inner", "outer", etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings. They are only for the convenience of describing the present invention and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation. Therefore, they should not be construed as limitations on the present invention.

[0051] Furthermore, the terms "first" and "second" are used for descriptive purposes only and should not be construed as indicating or implying relative importance or implicitly specifying the number of indicated technical features. Thus, a feature defined as "first" or "second" may explicitly or implicitly include one or more of that feature. In the description of this invention, "a plurality of" or "several" means two or more, unless otherwise explicitly specified.

[0052] It should be noted that the structures, proportions, sizes, etc., shown in the accompanying drawings of this specification are only for the purpose of assisting those skilled in the art in understanding and reading the content disclosed in the specification, and are not intended to limit the conditions under which the present invention can be implemented. Therefore, they have no substantial technical significance. Any modifications to the structure, changes in the proportions, or adjustments to the size, without affecting the effects and objectives that the present invention can produce, should still fall within the scope of the technical content disclosed in the present invention.

[0053] like Figures 1 to 9 As shown in the embodiment of the present invention, a visual orchestration system for ThingWorx device access is provided. The method includes: node controls, which are configured with ThingWorx associated events or services according to ThingWorx extended transaction templates; a node toolbar, which is used to display and manage the node controls; and a node orchestration space, which is set adjacent to the node toolbar and is used for configuring the node controls and configuring the connection relationships between multiple node controls. The node controls are moved to the node orchestration space; multiple node controls establish connection relationships; the node controls include three node attributes: start node, end node, and intermediate node, and the node controls are configured based on ThingWorx transaction templates.

[0054] This invention provides a visual orchestration system for ThingWorx device access. The method includes: node controls configured with ThingWorx associated events or services based on ThingWorx extended transaction templates; a node toolbar for displaying and managing the node controls; and a node orchestration space adjacent to the node toolbar, used for configuring the node controls and configuring connections between multiple node controls. Node controls are moved to the node orchestration space, and multiple node controls establish connections. Each node control includes three node attributes: start node, end node, and intermediate node. The node controls are configured based on ThingWorx transaction templates. This visual orchestration system for ThingWorx device access overcomes the problems of complex and error-prone ThingWorx configuration operations in existing technologies, improving configuration development efficiency. This invention also provides a maintenance method with the same technical effects.

[0055] Specifically, in the embodiments of the present invention, the Thingworx transaction template is a special extended transaction template;

[0056] The Thingworx transaction templates include: MQTTClient transaction template, KafkaThing transaction template, and DataTransform transaction template;

[0057] The MQTTClient transaction template is based on the "MQTT" template of the Thingworx transaction template, and is used to provide the "MQTTTAnyTopicConsume" event and the "MQTTPublish" service; the KafkaThing transaction template is extended from the Thingworx transaction template and is used to provide...

[0058] The "KafkaAnyTopicConsume" event and the "SendMessage" service;

[0059] The DataTransform transaction template is based on the "GenericThing" template of the Thingworx transaction template and is used to provide the "TransformEvent" and "EmitMessage" services.

[0060] More specifically, in this embodiment of the invention, the start node is an input node, which is used to receive upstream data; the end node is an output node, which is used to output data downstream; and the intermediate node is a message conversion node and a message routing node, which is used to process messages from upstream nodes and forward them to downstream nodes.

[0061] More specifically, in this embodiment of the invention, the node categories of the start node include: "MQTT subscription", "Kafka subscription", "HTTP listener", "file input", "read database", and "value change"; the node categories of the end node include: "MQTT publish", "Kafka write", "write database", "write file", and "HTTP response".

[0062] More specifically, in this embodiment of the invention, the "MQTT subscription" node obtains and based on

[0063] The "MQTTClient" type transaction triggers the "MQTTAnyTopicConsume" event to complete node output; the "kafka write" node subscribes to and obtains events from the upstream starting node; the "kafka write" node is based on the "KafkaThing" type transaction and uses the "SendMessage" service provided by "KafkaThing" as output; the intermediate node is based on the "DataTransform" type transaction, and subscribes to and obtains special events from upstream as input, triggering the "TransformEvent" event to complete node output.

[0064] More specifically, in this embodiment of the invention, the node control, the node toolbar, and the node arrangement space are created based on the antv / g6 graph editing engine;

[0065] Multiple node controls establish connections in the node arrangement space;

[0066] The node control is in a configurable state. A new node control can be created by editing instructions, and the items in the new node control are also in a configurable state.

[0067] More specifically, in this embodiment of the invention, the node toolbar is provided with a configuration table, which is used to store specific configuration information to facilitate the retrieval of configuration input.

[0068] More specifically, in this embodiment of the invention, it further includes: a rule module; the rule module is used to maintain the transaction relationships of the ThingWorx;

[0069] The rules in the rules module include: adding rules, modifying rules, and deleting rules;

[0070] The newly added rule includes: storing a rule record in the database, and also storing the relationship data between the rule and related items;

[0071] The modification rules include deleting the original relation data and saving the new relation data;

[0072] The deletion rules include deleting the corresponding relational data.

[0073] In addition, the present invention also provides a maintenance method, including the step of: inserting rule records;

[0074] Maintain rule-related transactions; maintain records of the relationship between rules and transactions; wherein, maintaining rule-related transactions includes the following steps: maintaining MQTTClient transactions integrated with MQTT subscriptions; maintaining DataTransform transactions integrated with message transformations; maintaining KafkaThing transactions integrated with Kafka write transactions.

[0075] More specifically, in this embodiment of the invention, maintaining the MQTTClient transaction for the "MQTT subscription" integration includes the following steps:

[0076] Create an MQTTClient transaction integrated with "MQTT subscription";

[0077] Store the Configuration Tables for transactions, where the Configuration Tables are the Topics for the transactions to be subscribed to;

[0078] The DataTransform transaction for maintaining message transformation integration includes the following steps:

[0079] Determine if it is a new transaction; if so, create a DataTransform transaction integrated with the message transformation node.

[0080] Subscribe to the MQTTAnyTopicConsume event of the MQTTClient, maintain the message transformation script, and call the triggered transformation event in the subscription;

[0081] Store the configuration tables for transactions;

[0082] The maintenance of the KafkaThing for Kafka write transaction integration includes the following steps:

[0083] Create a KafkaThing transaction integrated with the "Kafka Write" node;

[0084] Subscribe to the DataTransform transformation event and call your own SendMessage service within the subscription;

[0085] Save the Configuration Tables of the transaction, that is, save the target topic to which it is to be sent.

[0086] More specifically, in the embodiments of the present invention,

[0087] It should be further noted that the technical solution involved in the embodiments of the present invention is based on the ThingWorx IoT platform and uses the antv / g6 node orchestration engine to access device data for interactive pages, making device access simple and efficient.

[0088] ThingWorx Kepware Server boasts over 150 different drivers, ensuring standardized industrial connectivity between heterogeneous devices and assets, unlocking IoT scalability, and allowing developers to confidently implement connections. Therefore, ThingWorx's flexibility, ease of use, and scalability have made it the preferred choice for many developers, making it the most popular development platform on the market in the IoT industry. Node-Red enables rapid implementation of logical functions through drag-and-drop functionality, eliminating the need for writing code.

[0089] In existing technologies, ThingWorx configuration is complex, error-prone, time-consuming, inefficient, and has a high learning curve. Node-Red is simple to use and has a low learning curve, but its access protocols are not rich enough to meet the diverse access requirements of devices from different manufacturers in a manufacturing plant. The technical solution involved in this invention provides a ThingWorx-based visual orchestration method and apparatus for device access. More specifically, it first extends and develops some special ThingWorx transaction templates, and then orchestrates events, subscriptions, and services of transactions created based on these templates. These orchestration operations use antv / g6 as the visual rule orchestration engine. The solution involved in this invention mainly includes four modules: 1. ThingWorx transaction template extension development; 2. Transaction process node encapsulation; 3. Visual rule management; 4. Maintenance of the relationship between rules and ThingWorx transactions.

[0090] The module is described as follows:

[0091] Module: ThingWorx Special Extended Transaction Template Description

[0092] MQTTClient Transaction Template: The MQTTClient template inherits from the built-in "MQTT" template in ThingWorx and provides the "MQTTAnyTopicConsume" event and the "MQTTPublish" service.

[0093] KafkaThing Transaction Template: KafkaThing is an extended ThingWorxk transaction template that provides the "KafkaAnyTopicConsume" event and the "SendMessage" service.

[0094] DataTransform Transaction Template: DataTransform is a transaction template that inherits from the "GenericThing" template built into ThingWorx, and provides the "TransformEvent" and "EmitMessage" services.

[0095] The solution involved in this invention utilizes the antv / g6 visualization engine to encapsulate each type of object into an arrangement node in the left toolbar. These nodes are mainly divided into three categories: start nodes, end nodes, and intermediate nodes.

[0096] Start node: Contains nodes such as "MQTT subscription", "Kafka subscription", "HTTP listener", "file input", "database read", and "value change". The start node is generally an input node; input data comes from its reception of some type of data, such as subscribing to MQTT messages, consuming Kafka messages, listening for HTTP requests, watching file modifications, and periodically scanning database tables.

[0097] End-of-line nodes: These include "MQTT publish", "Kafka write", "database write", "file write", "HTTP response", etc. End-of-line nodes typically have output functionality, meaning they forward / write data to message queues, persistent databases, local files, or specific API interfaces.

[0098] Intermediate nodes: message conversion nodes, etc.

[0099] In the optional implementation, the following three types of nodes will be used:

[0100] "MQTT Subscription" node: This is an input node that integrates "MQTTClient" type transactions and uses...

[0101] The "MQTTClient" provides MQTT subscription messages as input, triggering the "MQTTAnyTopicConsume" event as the output of the process. If other nodes use the output of this type of node as their own input, by default, other nodes will automatically subscribe to the "MQTTAnyTopicConsume" event when saving the rules.

[0102] Kafka write nodes:

[0103] This is an output node that integrates "KafkaThing" type transactions. It uses events from subscribing to other transaction types as input and uses the "SendMessage" service provided by "KafkaThing" as output. Therefore, other nodes must have special events, such as the "MQTTAnyTopicConsume" event from "MQTT subscription".

[0104] Message transition node:

[0105] This type of node is an intermediate node, requiring the use of a "DataTransform" type transaction to implement node message transformation. It subscribes to special events of other nodes as its input and triggers them.

[0106] "TransformEvent" is its output.

[0107] It should be noted that a type of thing can be integrated with more than one type of node. For example, in this embodiment, KafkaThing is integrated with two type nodes, "Kafka Subscription" and "Kafka Write". Furthermore, this invention is not limited to the encapsulated nodes described above.

[0108] Module: Visual Rule Management

[0109] This invention provides a visual interface for creating antv / g6web, integrating a node toolbar for "ThingWorx" things, a canvas for arranging process nodes, and an operation interface for connecting ThingWorx things. It allows users to select things of the current node type and create things of the same node type, while also providing important final configuration input ports in configurationtables.

[0110] Module: Rules and ThingWorx Transaction Relationship Maintenance

[0111] When a new rule is added, not only is a rule record saved in the database, but also the relationship data between the rule and related entities is saved.

[0112] Modify the rules, delete the existing relationship data, and save the new relationship data.

[0113] The deletion rule deletes the corresponding relational data.

[0114] It should be noted that the relationship here is not only related to a thing, but also to a certain event of that thing, such as a subscription or service.

[0115] Visual orchestration principles:

[0116] Here's a simple application scenario: a device reports messages via MQTT, and the messages eventually flow to the Kafka message middleware for use by other systems. However, the MQTT message format doesn't conform to the Kafka message format. We'll now use a simple implementation example to illustrate the principles of orchestration.

[0117] The entire data flow requires three encapsulated transaction nodes to work together: 1) "MQTT subscription" node, 2) message conversion node, and 3) Kafka write node.

[0118] In this implementation plan, the rule maintenance process is as follows:

[0119] Insert rule record

[0120] Maintaining the rules and related entities, specifically, this step includes three main steps:

[0121] 1) Maintain MQTTClient transactions integrated with the "MQTT subscription" node;

[0122] 2) Maintain the DataTransform transactions integrated by the message transformation node;

[0123] 3) Maintain the KafkaThing that integrates Kafka write node transactions.

[0124] Maintaining records of rules and relationships:

[0125] Once the rules are maintained, the transactions on the "ThingWorx" platform are simultaneously created (or modified). The transactions associated with the rules then begin to drive the entire process based on transaction events and subscriptions. The working principle of this implementation method is as follows:

[0126] 1. When the MQTTClient subscribes to the target message, it triggers the MQTTTAnyTopicConsume event.

[0127] 2. When DataTransform subscribes to the MQTTAnyTopicConsume event, it executes the message transformation script within the subscription, triggering the TransformEvent event.

[0128] 3. The KafkaThing subscribes to the TransformEvent and calls the SendMessage service within the subscription to send a message in the desired format to the Kafka topic.

[0129] Furthermore, MQTT reports data in multiple formats and across multiple destinations. As one possible implementation, MQTT connects multiple message transformation nodes, and each message transformation node connects to multiple write nodes. Another possible implementation is... Figure 2 As shown.

[0130] The above describes the rule orchestration principle through two optional implementation schemes. During implementation, users can combine nodes in various ways to achieve the desired orchestration process based on event conditions.

[0131] In summary, the technical solution involved in this invention integrates ThingWorx, offering diverse access protocols. It features a visual interface, making device access simple and efficient. Users drag and drop target nodes from the toolbar, then select items or configure settings via pop-up windows. Flow nodes are then navigated by dragging lines. This simplifies operation and significantly improves work efficiency compared to existing technologies.

[0132] The above description of the disclosed embodiments enables those skilled in the art to make or use the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the invention. Therefore, the invention is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.

Claims

1. A visual orchestration system for accessing Thingsworx devices, characterized in that, include: A node control, which is configured with ThingWorx associated events or services based on the ThingWorx extended transaction template; A node toolbar, used to display and manage the node controls; A node arrangement space is provided, which is adjacent to the node toolbar. The node arrangement space is used to configure the node controls and to configure the connection relationships between multiple node controls. The node control is used to be moved to the node arrangement space; Multiple node controls establish a connection relationship; The node control includes: a start node, an end node, and intermediate nodes; The node control is configured based on the Thingworx transaction template.

2. The visual orchestration system for Thingworx device access according to claim 1, characterized in that, The Thingworx transaction template is a special extended transaction template; The Thingworx transaction templates include: MQTTClient transaction template, KafkaThing transaction template, and DataTransform transaction template; The MQTTClient transaction template is based on the "MQTT" template of the Thingworx transaction template. Used to provide the "MQTTAnyTopicConsume" event and the "MQTTPublish" service; The KafkaThing transaction template is an extension of the Thingworx transaction template, used to provide the "KafkaAnyTopicConsume" event and the "SendMessage" service; The DataTransform transaction template is based on the "GenericThing" template of the Thingworx transaction template and is used to provide the "TransformEvent" and "EmitMessage" services.

3. The visual orchestration system for Thingworx device access according to claim 2, characterized in that, The start node is an input node used to receive upstream data; the end node is an output node used to output data downstream; the intermediate node is a message conversion node and a message routing node used to process messages from upstream nodes and forward them to downstream nodes.

4. The visual orchestration system for Thingworx device access according to claim 3, characterized in that, The node categories for the start node include: "MQTT subscription", "Kafka subscription", "HTTP listener", "file input", "read database", and "value change"; the node categories for the end node include: "MQTT publish", "Kafka write", "write database", "write file", and "HTTP response".

5. The visual orchestration system for Thingworx device access according to claim 4, characterized in that, The "MQTT subscription" node acquires and triggers transactions based on the "MQTTClient" type. The "MQTTAnyTopicConsume" event completes the node output; The "Kafka write" node subscribes to and obtains events from the upstream starting node; The "kafka write" node is based on the "KafkaThing" type transaction and uses the "SendMessage" service provided by "KafkaThing" as the output; The intermediate node is based on the "DataTransform" type of transaction. The intermediate node subscribes to and obtains special events from upstream as input, and triggers the "TransformEvent" event to complete the node output.

6. The visual orchestration system for Thingworx device access according to claim 5, characterized in that, The node control, the node toolbar, and the node arrangement space are created based on the antv / g6 graph editing engine; Multiple node controls establish connections in the node arrangement space; The node control is in a configurable state. A new node control can be created by editing commands, and the items in the new node control are also in a configurable state.

7. The visual orchestration system for Thingworx device access according to claim 6, characterized in that, The node toolbar has a configuration table, which is used to store specific configuration information for calling configuration input.

8. The visual orchestration system for Thingworx device access according to claim 6, characterized in that, Also includes: Rules module; The rules module is used to maintain the relationships between the things in ThingWorx; The rules in the rules module include: adding rules, modifying rules, and deleting rules; The newly added rule includes: storing a rule record in the database while also storing the relationship data between the rule and related transactions; The modification rules include: deleting the original relation data and saving the new relation data; The deletion rules include: deleting the corresponding relational data.

9. A maintenance method, based on the visual orchestration system for Thingworx device access as described in any one of claims 1 to 8, characterized in that, Including the following steps: Insert rule record; Maintain rules related to things; Maintain records of rules and relationships between things; The maintenance rule associated with the transaction includes the following steps: Maintain MQTTClient transactions for MQTT subscription integration; Maintain the DataTransform transaction for message transformation integration; Maintain the KafkaThing for Kafka write transactions.

10. The maintenance method according to claim 9, characterized in that, The maintenance of the MQTT Client transaction for MQTT subscription integration includes the following steps: Create an MQTTClient transaction for MQTT subscription integration; Store the Configuration Tables for transactions, where the Configuration Tables are the Topics for the transactions to be subscribed to; The DataTransform transaction for maintaining message transformation integration includes the following steps: Determine if it is a new transaction; if so, create a DataTransform transaction integrated with the message transformation node. Subscribe to the MQTTAnyTopicConsume event of the MQTTClient, maintain the message transformation script, and call the triggered Transform Event in the subscription; Store configuration tables for transactions; The maintenance of the KafkaThing for Kafka write transaction integration includes the following steps: Create a KafkaThing transaction integrated with the "Kafka Write" node; Subscribe to the DataTransform's Transform Event, call the SendMessage service within the subscription; save the transaction's Configuration Tables.

Images