An agent-based internet of things edge protocol automatic development access system and method

Abstract

The application discloses an Agent-based Internet of Things edge protocol automatic development access system and method, which comprises an Agent-based Internet of Things edge protocol automatic development access system and an Agent-based Internet of Things edge protocol automatic development access method adopting the system. The system comprises an edge access framework, an implementation interaction module, an environment module and an edge protocol Agent core engine. The edge protocol Agent core engine is embedded with a large language model or accesses a cloud large language model service and has multi-round planning and execution capability. The edge protocol Agent core engine comprises a requirement analysis and data collection unit, a protocol development and code generation unit, an automatic test and deployment unit and a point arrangement and summary reporting unit. The method comprises the steps of data collection, automatic edge protocol plug-in writing, automatic communication test, structured device point table generation and file return. The application can reduce manual dependence, reduce personnel communication difficulty and reduce implementation threshold.

Description

Technical Field

[0001] This invention relates to the field of IoT device access technology, and in particular to an agent-based automated development and access system and method for IoT edge protocols. Background Technology

[0002] In the Internet of Things (IoT) field, edge device access is a crucial step in achieving data acquisition and interoperability. Traditional IoT edge acquisition and device access processes are typically based on existing edge access frameworks. The general process involves: first, developers manually writing corresponding edge access protocol plugin code based on various protocol documents provided by hardware manufacturers; then, developers and field implementation personnel jointly debug the device side; finally, field implementation personnel manually compile a data acquisition point mapping table and test whether the relevant functions and point data are collected and usable.

[0003] The existing technology has the following drawbacks and shortcomings: 1. From reading the protocol documents, writing code, debugging to compiling the point table, the entire process requires a lot of manual intervention from R&D and implementation personnel, which is inefficient. 2. R&D personnel and on-site implementation personnel are often not in the same working environment. The configuration of the on-site environment and the feedback of debugging results require repeated communication, which prolongs the equipment access cycle. 3. The development of protocol plugins requires the participation of R&D personnel with professional software development skills, which has a high threshold. However, in actual IoT implementation sites, there are often only implementation personnel and no R&D personnel, which leads to limited project delivery. 4. Manually writing protocol plugins and compiling point tables can easily lead to errors in point mapping or protocol parsing due to human negligence. Summary of the Invention

[0004] To address the aforementioned shortcomings of existing technologies, this invention provides an agent-based automated development and access system and method for IoT edge protocols, which can reduce reliance on manual labor, lower communication barriers, and reduce implementation thresholds.

[0005] In order to achieve the objectives of this invention, the following technologies are proposed: An agent-based automated development and access system for IoT edge protocols includes: An edge access framework for loading and running generated edge protocol plugins; The implementation interaction module is used to provide an interactive interface to implementers, enabling the system to receive equipment data and environmental parameters; An environment module is used to configure a test environment according to environment parameters, and the test environment is used to connect with the edge access framework. The core engine of the edge protocol agent is equipped with a large language model and includes a requirements analysis and data collection unit, a protocol development and code generation unit, an automated testing and deployment unit, and a site collection and reporting unit. The requirements analysis and data collection unit is connected to the implementation interaction module and is used to analyze the completeness of device data. The protocol development and code generation unit is used to automatically write edge protocol plugins. The automated testing and deployment unit is used to call the test environment provided by the environment module to test the edge protocol plugins. The site collection and reporting unit is used to generate a structured device point table and a task completion report.

[0006] An agent-based automated development and access method for IoT edge protocols, employing the aforementioned agent-based automated development and access system for IoT edge protocols, includes the following steps: S100: When the implementer starts the edge protocol agent core engine through the implementation interaction module, the requirements analysis and data collection unit receives the device data and then performs integrity verification and intent understanding on the device data; S300: Based on the interface standard of the device data and edge access framework, the protocol development and code generation unit automatically writes and generates the code of the edge protocol plugin through the large language model, and then encapsulates the code into the edge protocol plugin; S400: The environment module receives the environment parameters configured by the implementer and configures the test environment. The automated testing and deployment unit automatically deploys the edge protocol plugin into the edge access framework, then connects the edge access framework to the test environment, performs communication tests on the edge protocol plugin, and determines whether the communication test is successful. If it is, then execute S600; otherwise, execute S500. S500: The automated testing and deployment unit outputs exception logs. The contents of the exception logs are analyzed using a large language model. Then, the code of the edge protocol plugin is automatically corrected until the communication test is successful. Then, S600 is executed. S600: Based on the data packets returned after a successful communication test, the point organization and summary reporting unit automatically maps and extracts equipment data points to generate a structured equipment point table; S700: The point organization and summary reporting unit generates a task completion report for the entire process of S300~S600. The task completion report and the structured equipment point list are returned to the implementers in the form of files through the implementation interaction module, and the equipment access process is notified to be completed.

[0007] Furthermore, before the method is executed, the edge protocol agent core engine pre-trains the large language model automatically. The automatic training steps include: A100: Input a predetermined number of existing protocol documents and their corresponding manually verified correct codes to form a sample pair set; A200: On a selected large language model, a protocol semantic graph encoder and a cross-attention adapter sublayer shared across all layers are constructed. The protocol semantic graph encoder transforms existing protocol documents into structured graph features, and the cross-attention adapter sublayer injects the structured graph features into the large language model. A300: Optimize the output θ of the large language model by injecting structured graph features into the sample pair set described in A100 until the cross-entropy loss between the protocol document and the correct code is below a preset threshold.

[0008] Furthermore, in S300, the steps for automatically writing and generating code for edge protocol plugins using a large language model include: S310: Input device information into the protocol semantic graph encoder and parse it to form a structured graph; S320: A large language model that automatically writes and trains by inputting structured graphs through a cross-attention adapter sublayer; S330: The complete code for the large language model generation edge protocol plugin.

[0009] Furthermore, the steps described in S500 for analyzing the content of the exception log using a large language model and then automatically correcting the code of the edge protocol plugin include: S510: The large language model compares the byte sequence that the edge protocol plugin should send when the communication test is successful with the byte sequence that the edge protocol plugin actually sent recorded in the error log to obtain the difference bytes and determine the error type through the error code; S520: Input the difference bytes and error type into the large language model. The large language model locates the line of code in the edge protocol plugin that involves the error type and reverse-engineers the correct code block based on the difference bytes in that line of code. S530: Replace the correct code block in the code of the edge protocol plugin.

[0010] Furthermore, before the method is executed, the edge protocol agent core engine pre-trains the large language model to generate a point table. The steps of the point table generation training include: B100: Input a predetermined number of data packets from successful communication tests and their corresponding manually verified correct points to form a training set; B200: Insert a LoRA adapter into the large language model; B300: Optimize LoRA parameters to ensure field accuracy is at least 95%; B400: Merges the optimized LoRA adapter with the large language model into an optimized model and deploys it in the core engine of the edge protocol agent.

[0011] Furthermore, the step of automatically mapping and extracting device data points to generate a structured device point table as described in S600 includes: S610: Read data packets; S620: The data packet is used as input text and sent to the optimization model described in S400; S630: Outputs a structured device point table.

[0012] The beneficial effects of this technical solution are as follows: 1. By using the edge protocol agent core engine, the traditional process of protocol development and code writing by R&D personnel is replaced. Implementation personnel can close the loop of the entire device access process on-site, which greatly reduces the dependence of on-site device access on R&D personnel and lowers the implementation threshold. 2. The original communication and collaboration model that required repeated communication between on-site implementation personnel and back-end R&D personnel has been transformed into an instant interaction model between on-site implementation personnel and the core engine of the edge protocol agent, eliminating cross-position communication barriers and significantly shortening the protocol access cycle. 3. It not only automatically generates the code for edge protocol plugins, but also performs automatic joint debugging based on the field environment. After debugging, it autonomously generates a structured equipment point table, ensuring the accuracy of point mapping and avoiding the offsets and errors that often occur when manually compiling point tables. 4. It can automatically correct code based on feedback from the on-site environment, and has the ability to iterate and optimize in a self-closed loop to ensure that the plugin is ultimately usable. Attached Figure Description

[0013] Figure 1 The diagram illustrates the structure of the agent-based automated development and access system for IoT edge protocols according to an embodiment of this application.

[0014] Figure 2 The flowchart illustrates the main steps of the agent-based automated development and access method for IoT edge protocols according to an embodiment of this application.

[0015] Figure 3 The A300 step flowchart of the agent-based automated development and access method for IoT edge protocols in this application is shown.

[0016] Figure 4 The flowchart of the B300 steps of the agent-based automated development and access method for IoT edge protocols in this application is shown. Detailed Implementation

[0017] The present application will be further described below with reference to the accompanying drawings and embodiments.

[0018] like Figure 1The system shown is an automated development and access system for IoT edge protocols based on agents, including an edge access framework, an implementation interaction module, an environment module, and an edge protocol agent (intelligent agent) core engine.

[0019] The edge access framework is used to load and run generated edge protocol plugins. The edge access framework is pre-configured with standardized edge device access specifications to realize the data acquisition, communication and control functions of the underlying devices.

[0020] The implementation interaction module provides implementation personnel with an interactive interface to interact with the edge protocol agent core engine, enabling the system to receive device data and environmental parameters.

[0021] The environment module is used to configure the test environment according to the environment parameters. The test environment is used to connect with the edge access framework. The environment module provides the edge protocol agent core engine with the ability to simulate or real field network and hardware environment interfaces, enabling it to perform online or offline debugging after development.

[0022] The Edge Protocol Agent core engine embeds a large language model or connects to a cloud-based large language model service, possessing multi-round planning and execution capabilities. The Edge Protocol Agent core engine includes a requirements analysis and data collection unit, a protocol development and code generation unit, an automated testing and deployment unit, and a site organization and reporting unit.

[0023] The requirements analysis and data collection unit is connected to the implementation interaction module to analyze the completeness of equipment data. If data is missing, the Agent will proactively instruct and guide the implementation personnel to provide the missing data.

[0024] The protocol development and code generation unit is used to automatically write edge protocol plugins based on the obtained complete device protocol documents and the standard interface specifications of the edge access framework.

[0025] The automated testing and deployment unit is used to call the testing environment provided by the environment module, automatically load edge protocol plugins, and perform device-side debugging and functional testing verification.

[0026] The point organization and summary reporting unit is used to generate a structured equipment point table and a task completion report. After the test is passed, it automatically parses and extracts the data measurement points of successful interactions, generates a structured equipment point table, and finally summarizes the closed-loop results of protocol development, testing and point organization, generates a task completion report and feeds it back to the implementation personnel to complete the equipment access.

[0027] like Figures 2-4 As shown, an agent-based automated development and access method for IoT edge protocols using the above system is implemented according to the following steps: S100: After the implementer starts the edge protocol agent core engine through the implementation interaction module, the requirements analysis and data collection unit receives the equipment data, which includes equipment protocol documents and field environment parameters. Then, the unit performs integrity verification and intent understanding on the equipment data to determine whether the equipment data is incomplete or unclear. If so, the unit returns a supplementary modification instruction to the implementer through the implementation interaction module and then executes S200. If not, the unit executes S300.

[0028] S200: The requirements analysis and data collection unit receives the operation of the implementer to supplement or modify the equipment data, and performs integrity verification and intent understanding on the equipment data again. It determines whether the equipment data is complete and clearly described within the predetermined time or the predetermined number of receptions. If yes, it executes S300. If no, it returns an error result to the implementer and terminates the equipment access.

[0029] Prior to S300, the edge protocol agent core engine pre-trained a large language model automatically. The automatic training steps included: A100: Input a predetermined number of existing protocol documents and their corresponding manually verified correct codes to form a sample pair set, the number of which is at least 10,000 pairs.

[0030] A200: On a selected large language model, a protocol semantic graph encoder and a cross-attention adapter sublayer shared across all layers are constructed. The protocol semantic graph encoder transforms existing protocol documents into structured graph features, and the cross-attention adapter sublayer injects the structured graph features into the large language model.

[0031] A300: Optimize the output θ of the large language model by injecting structured graph features into the sample pair set described in A100 until the cross-entropy loss between the protocol document and the correct code is below a preset threshold.

[0032] like Figure 3 As shown, the optimization process described in A300 includes: A310: Divide the sample pairs in the sample pair set into batches, each batch including 16 to 32 sample pairs, set the batch number i, and initialize i=1; A320: In the i-th batch of sample pairs, the large language model generates code based on the protocol document and calculates the cross-entropy loss with the correct code, expressed as: ; Where: ℒ represents the cross-entropy loss; T represents the total number of tokens (lexical units) after the correct code is segmented; t represents the token index after the correct code is segmented; P θGiven an output θ, and a token sequence x1,…,x1 after the protocol document has been segmented. M And given the prefix of the correct code, the token sequence y1,…,y is obtained after word segmentation. t−1 At that time, the large language model predicts the next token to be y. t The probability; M is the number of tokens after the protocol document is segmented; A330: Performs automatic differentiation calculations using PyTorch or TensorFlow to derive the gradient ∇ of ℒ with respect to θ. θ ℒ; A340: Uses an optimizer provided by PyTorch or TensorFlow as the gradient descent optimizer, along -∇ θ ℒ Direction update output θ; A350: Determine if the cross-entropy loss has decreased below the preset threshold. If yes, then A300 ends and the automatic training is completed. If no, then set i=i+1 and return to A320.

[0033] In this embodiment, the preset threshold value ranges from 0.5 to 0.9, preferably 0.7.

[0034] S300: Based on the interface standard of the device data and edge access framework, the protocol development and code generation unit automatically writes and generates the code for the edge protocol plugin through the large language model, and then encapsulates the code into the edge protocol plugin.

[0035] The specific steps for writing and generating the S300 include: S310: Input the device protocol document from the device data into the protocol semantic graph encoder, parse it to form a structured graph. The structured graph nodes include data fields, frame headers, lengths, checksums, and function codes, and the edges include offsets, dependencies, and conditional relationships. S320: A large language model that automatically writes and trains by inputting structured graphs through a cross-attention adapter sublayer; S330: The complete code for the large language model generation edge protocol plugin.

[0036] S400: The environment module receives the environment parameters configured by the implementer and configures the test environment. The automated testing and deployment unit automatically deploys the edge protocol plugin in the edge access framework, then connects the edge access framework to the test environment and performs communication testing of the edge protocol plugin. The content of the communication test is to verify whether the data transmission and reception of the edge protocol plugin is normal and to determine whether the communication test is successful. If yes, then execute S600; if no, then execute S500.

[0037] S500: The automated testing and deployment unit outputs exception logs. The contents of the exception logs are analyzed using a large language model, and then the code of the edge protocol plugin is automatically corrected until the communication test is successful. Then, S600 is executed.

[0038] The S500 analysis and automatic correction steps specifically include: S510: The large language model compares the byte sequence that the edge protocol plugin should send when the communication test is successful with the byte sequence that the edge protocol plugin actually sent recorded in the error log to obtain the difference bytes. The error type is determined by the error code. The actual possible error types include frame header mismatch, length field error, check failure, and register address offset. S520: Input the difference bytes and error type into the large language model. The large language model locates the line of code in the edge protocol plugin that involves the error type and reverse-engineers the correct code block based on the difference bytes in that line of code. S530: Replace the correct code block in the code of the edge protocol plugin.

[0039] Before S600 execution, the edge protocol agent core engine pre-trains the large language model to generate a point table. The steps of the point table generation training include: B100: Input a predetermined number of data packets from successful communication tests and their corresponding manually verified correct point tables to form a training set, the number of which is at least 5000 sets.

[0040] B200: Insert a LoRA (Low-Rank Adaptation) adapter into the large language model.

[0041] B300: Optimizes LoRA parameters to ensure field accuracy is at least 95%.

[0042] like Figure 4 As shown, B300 includes: B310: Randomly generate n sets of LoRA parameters, where n is an even integer between 20 and 50; B320: Load the current n groups of LoRA parameters one by one into the large language model with LoRA adapter, generate a structured device point table from the data packets in the training set, compare it with the corresponding correct point table in the training set, calculate the field accuracy as the fitness of the LoRA parameter, determine whether there is a LoRA parameter with a field accuracy of 95%, if so, use the LoRA parameter group with the first field accuracy of at least 95% in the current n groups as the parameter used by the LoRA adapter, and terminate B300 immediately; otherwise, execute B330. B330: Sort by fitness from high to low, retain the LoRA parameters of the first half of the groups with the highest fitness, and randomly select 1 to 3 groups from the retained LoRA parameters to perform parameter weighted average or element-wise random swap to generate new LoRA parameters to fill the number of LoRA parameter groups to n. B340: Add Gaussian noise to each group of LoRA parameters after completion. The standard deviation of the Gaussian noise gradually decreases with the number of times B330 is executed. B350: Return to B320.

[0043] B400: Merges the optimized LoRA adapter with the large language model into an optimized model and deploys it in the core engine of the edge protocol agent.

[0044] S600: Based on the data packets returned after a successful communication test, the point organization and summary reporting unit automatically maps and extracts equipment data points to generate a structured equipment point table required for implementation and delivery.

[0045] Specifically, the steps in S600 for automatically mapping and extracting equipment data points to generate a structured equipment point table include: S610: Read data packets; S620: The data packet is used as input text and sent to the optimization model described in S400; S630: Outputs a structured equipment point table, which includes fields such as name, address, data type, coefficient, and unit for each equipment point.

[0046] S700: The point organization and summary reporting unit generates a task completion report for the entire process of S300~S600. The task completion report and the structured equipment point list are returned to the implementers in the form of files through the implementation interaction module, and the equipment access process is notified to be completed.

[0047] In summary, this invention realizes end-to-end fully automated development and testing of IoT edge protocol plugins based on the edge protocol agent core engine: the agent is introduced into a fixed edge access framework to realize an autonomous closed loop from collecting documents, generating code, deploying and testing, organizing point tables, and summarizing and reporting. At the same time, the system can proactively analyze the currently missing conditions and instruct the implementers to provide relevant information or on-site environment cooperation to achieve human-machine collaborative interaction; The structured equipment point table is no longer a static document that is independent of the code. Instead, it is dynamically extracted and finally confirmed to generate a reliable point table after the protocol is generated and tested in the field environment.

[0048] The above are only some of the embodiments listed in this application and are not intended to limit this application.

Claims

1. An agent-based automated development and access system for IoT edge protocols, characterized in that, include: An edge access framework for loading and running generated edge protocol plugins; The implementation interaction module is used to provide an interactive interface to implementers, enabling the system to receive equipment data and environmental parameters; An environment module is used to configure a test environment according to environment parameters, and the test environment is used to connect with the edge access framework. The core engine of the edge protocol agent is equipped with a large language model and includes a requirements analysis and data collection unit, a protocol development and code generation unit, an automated testing and deployment unit, and a site collection and reporting unit. The requirements analysis and data collection unit is connected to the implementation interaction module and is used to analyze the completeness of device data. The protocol development and code generation unit is used to automatically write edge protocol plugins. The automated testing and deployment unit is used to call the test environment provided by the environment module to test the edge protocol plugins. The site collection and reporting unit is used to generate a structured device point table and a task completion report.

2. A method for automated development and access of IoT edge protocols based on agents, characterized in that, The system according to claim 1 includes the following steps: S100: When the implementer starts the edge protocol agent core engine through the implementation interaction module, the requirements analysis and data collection unit receives the device data and then performs integrity verification and intent understanding on the device data; S300: Based on the interface standard of the device data and edge access framework, the protocol development and code generation unit automatically writes and generates the code of the edge protocol plugin through the large language model, and then encapsulates the code into the edge protocol plugin; S400: The environment module receives the environment parameters configured by the implementer and configures the test environment. The automated testing and deployment unit automatically deploys the edge protocol plugin into the edge access framework, then connects the edge access framework to the test environment, performs communication tests on the edge protocol plugin, and determines whether the communication test is successful. If it is, then execute S600; otherwise, execute S500. S5 00: The automated testing and deployment unit outputs exception logs. The content of the exception logs is analyzed using a large language model. Then, the code of the edge protocol plugin is automatically corrected until the communication test is successful, and then S600 is executed. S600: Based on the data packets returned after a successful communication test, the point organization and summary reporting unit automatically maps and extracts equipment data points to generate a structured equipment point table; S700: The point organization and summary reporting unit generates a task completion report for the entire process of S300~S600. The task completion report and the structured equipment point list are returned to the implementers in the form of files through the implementation interaction module, and the equipment access process is notified to be completed.

3. The agent-based automated development and access method for IoT edge protocols according to claim 2, characterized in that, Before the method is executed, the edge protocol agent core engine pre-trains the large language model automatically. The automatic training steps include: A100: Input a predetermined number of existing protocol documents and their corresponding manually verified correct codes to form a sample pair set; A200: On a selected large language model, a protocol semantic graph encoder and a cross-attention adapter sublayer shared across all layers are constructed. The protocol semantic graph encoder transforms existing protocol documents into structured graph features, and the cross-attention adapter sublayer injects the structured graph features into the large language model. A300: Optimize the output θ of the large language model by injecting structured graph features into the sample pair set described in A100 until the cross-entropy loss between the protocol document and the correct code is below a preset threshold.

4. The agent-based automated development and access method for IoT edge protocols according to claim 3, characterized in that, The optimization process described in A300 includes: A310: Divide the sample pairs in the sample pair set into batches, each batch including 16 to 32 sample pairs, set the batch number i, and initialize i=1; A320: In the i-th batch of sample pairs, the large language model generates code based on the protocol document and calculates the cross-entropy loss with the correct code, expressed as: ； Where: ℒ represents the cross-entropy loss; T represents the total number of tokens after the correct code is segmented; t represents the token index after the correct code is segmented; P θ Given an output θ, and a token sequence x1,…,x1 after the protocol document has been segmented. M And given the prefix of the correct code, the token sequence y1,…,y is obtained after word segmentation. t−1 At that time, the large language model predicts the next token to be y. t The probability; M is the number of tokens after the protocol document is segmented; A330: Performs automatic differentiation calculation to obtain the gradient ∇ of ℒ with respect to θ. θ ℒ; A340: Employs a gradient descent optimizer, along -∇ θ ℒ Direction update output θ; A350: Determine if the cross-entropy loss has decreased below the preset threshold. If yes, then A300 ends and the automatic training is completed. If no, then set i=i+1 and return to A320.

5. The agent-based automated development and access method for IoT edge protocols according to claim 3, characterized in that, In S300, the steps for automatically writing and generating code for edge protocol plugins using a large language model include: S310: Input device information into the protocol semantic graph encoder and parse it to form a structured graph; S320: A large language model that automatically writes and trains by inputting structured graphs through a cross-attention adapter sublayer; S330: The complete code for the large language model generation edge protocol plugin.

6. The agent-based automated development and access method for IoT edge protocols according to claim 2, characterized in that, The steps described in S500 for analyzing the content of exception logs using a large language model and then automatically correcting the code of the edge protocol plugin include: S510: The large language model compares the byte sequence that the edge protocol plugin should send when the communication test is successful with the byte sequence that the edge protocol plugin actually sent recorded in the error log to obtain the difference bytes and determine the error type through the error code; S520: Input the difference bytes and error type into the large language model. The large language model locates the line of code in the edge protocol plugin that involves the error type and reverse-engineers the correct code block based on the difference bytes in that line of code. S530: Replace the correct code block in the code of the edge protocol plugin.

7. The agent-based automated development and access method for IoT edge protocols according to claim 2, characterized in that, Before the method is executed, the edge protocol agent core engine pre-trains the large language model to generate a point table. The steps of the point table generation training include: B100: Input a predetermined number of data packets from successful communication tests and their corresponding manually verified correct points to form a training set; B200: Insert a LoRA adapter into the large language model; B300: Optimize LoRA parameters to ensure field accuracy is at least 95%; B400: Merges the optimized LoRA adapter with the large language model into an optimized model and deploys it in the core engine of the edge protocol agent.

8. The agent-based automated development and access method for IoT edge protocols according to claim 7, characterized in that, The B300 includes: B310: Randomly generate n sets of LoRA parameters, where n is an even integer between 20 and 50; B320: Load the current n groups of LoRA parameters one by one into the large language model with LoRA adapter, generate a structured device point table from the data packets in the training set, compare it with the corresponding correct point table in the training set, calculate the field accuracy as the fitness of the LoRA parameter, determine whether there is a LoRA parameter with a field accuracy of 95%, if so, use the LoRA parameter group with the first field accuracy of at least 95% in the current n groups as the parameter used by the LoRA adapter, and terminate B300 immediately; otherwise, execute B330. B330: Sort by fitness from high to low, retain the LoRA parameters of the first half of the groups with the highest fitness, and randomly select 1 to 3 groups from the retained LoRA parameters to perform parameter weighted average or element-wise random swap to generate new LoRA parameters to fill the number of LoRA parameter groups to n. B340: Add Gaussian noise to each LoRA parameter group after completion; B350: Return to B320.

9. The agent-based automated development and access method for IoT edge protocols according to claim 7, characterized in that, The steps of automatically mapping and extracting equipment data points to generate a structured equipment point table as described in S600 include: S610: Read data packets; S620: The data packet is used as input text and sent to the optimization model described in S400; S630: Outputs a structured device point table.

10. The agent-based automated development and access method for IoT edge protocols according to claim 2, characterized in that, After S100 is completed, it is determined whether the equipment data is incomplete or unclear. If so, a supplementary modification instruction is returned to the implementer through the implementation interaction module, and then S200 is executed. If not, S300 is executed. S200: The requirements analysis and data collection unit receives the operation of the implementer to supplement or modify the equipment data, and performs integrity verification and intent understanding on the equipment data again. It determines whether the equipment data is complete and clearly described within the predetermined time or the predetermined number of receptions. If yes, it executes S300. If no, it returns an error result to the implementer and terminates the equipment access.

Images