Protocol analysis method and device based on multi-agent cooperation and medium

Abstract

The invention discloses a protocol analysis method and device based on multi-agent cooperation and a medium, and belongs to the technical field of industrial internet. The method comprises the following steps: constructing and associating a distributed agent cluster and a global protocol knowledge base; preprocessing the original Internet of Things protocol based on the analysis agent to generate a protocol analysis task packet; processing the protocol analysis task packet based on the scheduling agent so as to distribute the protocol analysis task packet to the target analysis agent; performing feature extraction and protocol analysis on the analysis task packet through an analysis agent, and outputting structured analysis data; if the unknown protocol format is recognized, feature extraction is carried out on the unknown protocol format and the unknown protocol format is sent to the management agent; and processing the unknown feature vector through the management agent to determine a new protocol analysis rule of an unknown protocol format, and synchronizing the new protocol analysis rule to the global protocol knowledge base. According to the method, the technical effect of efficient dynamic analysis adaptation of the industrial Internet of Things protocol is achieved.

Description

Technical Field

[0001] This application relates to the technical field of industrial Internet, and in particular to a protocol parsing method, device, and medium based on multi-agent collaboration. Background Art

[0002] In the field of industrial Internet of Things, the interconnection and interoperability of devices and systems are achieved through various communication protocols. Common industrial protocols include MQTT, CoAP, Modbus, etc. The existing technology mainly adopts a centralized protocol parsing architecture, which relies on a predefined rule library to standardize device data. Such a solution matches data fields through manually configured protocol templates or extracts device status information using a fixed parsing pipeline. This mode requires the protocol structure to be completely defined in advance, and the parsing rule library needs to cover all known protocol types to work effectively.

[0003] Therefore, in the face of private or non-standard protocols constantly emerging in industrial sites in the existing technology, the static rule library cannot automatically identify unknown protocol formats. Manual intervention is required to modify the parsing code and restart the service, resulting in the interruption of the device access process. Seriously, it may affect the flexibility and real-time performance of the production system. When dealing with a large number of concurrent protocol data, the centralized architecture is prone to task blocking due to uneven distribution of computing resources. Protocol rule updates require a full replacement of the parsing engine, and poor cross-vendor device compatibility may lead to heavy adaptation work.

[0004] Therefore, how to achieve efficient dynamic parsing and adaptation of industrial Internet of Things protocols has become an urgent technical problem to be solved. Summary of the Invention

[0005] Embodiments of this application provide a protocol parsing method, device, and medium based on multi-agent collaboration to solve the following technical problem: how to achieve efficient dynamic parsing and adaptation of industrial Internet of Things protocols.

[0006] In a first aspect, an embodiment of the present application provides a protocol parsing method based on multi-agent collaboration, which is applied to industrial Internet of Things devices. The method includes: constructing and associating a distributed agent cluster and a global protocol knowledge base; wherein, the distributed agent cluster includes a parsing agent, a scheduling agent, and a management agent, and the global protocol knowledge base is used to store parsing rules of known industrial Internet of Things protocols; obtaining the original Internet of Things protocol of the industrial Internet of Things device, and preprocessing the original Internet of Things protocol based on the parsing agent to generate a protocol parsing task package; wherein, the protocol parsing task package can be recognized by the distributed agent cluster; processing the protocol parsing task package based on the scheduling agent to allocate the protocol parsing task package to a target parsing agent; performing feature extraction and protocol parsing on the parsing task package through the parsing agent, and outputting structured parsing data; wherein, the structured parsing data is a formatted format of the industrial Internet of Things device status information; if the parsing agent identifies an unknown protocol format during feature extraction and protocol parsing, then extracting the unknown protocol format, and sending the extracted unknown feature vector to the management agent; processing the unknown feature vector through the management agent to determine a new protocol parsing rule for the unknown protocol format, and synchronizing the new protocol parsing rule to the global protocol knowledge base.

[0007] In an implementation manner of the present application, constructing and associating a distributed agent cluster and a global protocol knowledge base specifically includes: deploying a lightweight parsing engine and loading a basic parsing rule set to construct multiple parsing agents; wherein, the basic parsing rule set at least includes: an MQTT protocol function code mapping table, a CoAP protocol option header parsing tree, and a Modbus register address conversion rule; deploying a load monitoring probe component to construct a scheduling agent including an agent load status table; wherein, the agent load status table is used to continuously record the CPU utilization rate, memory occupancy rate, and historical parsing accuracy of multiple parsing agents; initializing the global protocol knowledge base, and deploying a neural network incremental learning module to generate a management agent; wherein, the neural network incremental learning module includes a convolutional neural network layer and a backpropagation weight updater; associating the interfaces of the parsing agent, the scheduling agent, and the management agent to construct a distributed agent cluster, and associating the distributed agent cluster with the global protocol knowledge base.

[0008] In an implementation manner of the present application, obtaining the original Internet of Things protocol of the industrial Internet of Things device, and preprocessing the original Internet of Things protocol based on the parsing agent to generate a protocol parsing task package specifically includes: based on the parsing agent, calling a protocol feature template in the global protocol knowledge base to perform protocol type matching on the original Internet of Things protocol to generate a grouped protocol data set; performing data sharding on the grouped protocol data set through the parsing agent to generate a standardized data sharding set; performing format conversion on the standardized data sharding set through the parsing agent to generate a protocol parsing task package that can be recognized by the agent cluster.

[0009] In one implementation of the present application, the protocol parsing task package is processed based on the scheduling agent to allocate the protocol parsing task package to the target parsing agent, which specifically includes: parsing the protocol type of the protocol parsing task package through the scheduling agent; screening the parsing agents that support the protocol type based on the agent load status table to construct a candidate parsing agent set; calculating the execution load balancing scores of multiple parsing agents in the candidate parsing agent set based on the CPU utilization rate and memory occupancy of the candidate parsing agent set to generate a load score value set; and allocating the protocol parsing task package to the target parsing agent based on the load score value set and the preset historical parsing accuracy rate.

[0010] In one implementation of the present application, the parsing agent extracts features and parses the protocol for the parsing task package and outputs structured parsing data, which specifically includes: parsing the fields of the parsing task package through the parsing agent to extract the key feature set of the parsing task package; where the key feature set includes the protocol version number, function code, and data length; parsing the key feature set through the lightweight parsing engine of the parsing agent to generate an intermediate parsing result set; and verifying the intermediate parsing result set through the parsing agent to generate the structured parsing data.

[0011] In one implementation of the present application, if the parsing agent identifies an unknown protocol format during feature extraction and protocol parsing, the unknown protocol format is extracted, and the extracted unknown feature vector is sent to the management agent, which specifically includes: when the key feature set does not match the parsing rules in the global protocol knowledge base, it is determined as an unknown protocol format; extracting the feature vector for the unknown protocol format to generate an unknown feature vector including the protocol header identifier, data length, and check bit; and sending the unknown feature vector to the management agent.

[0012] In one implementation of the present application, the management agent processes the unknown feature vector to determine the new protocol parsing rules for the unknown protocol format and synchronizes the new protocol parsing rules to the global protocol knowledge base, which specifically includes: receiving the unknown feature vector through the management agent; inputting the unknown feature vector into a preset convolutional neural network model for incremental learning to generate new protocol parsing rules; and writing the new protocol parsing rules into the unrecognized protocol storage area of the global protocol knowledge base.

[0013] In one implementation of the present application, after the management agent processes the unknown feature vector to determine the new protocol parsing rules for the unknown protocol format and synchronizes the new protocol parsing rules to the global protocol knowledge base, the method further includes: sending a protocol type-agent mapping relationship update instruction to the scheduling agent through the management agent to update the agent load status table; and sending a lightweight parsing engine rule update instruction to the parsing agent through the management agent.

[0014] In a second aspect, an embodiment of the present application further provides an electronic device, including a memory, a processor, and a computer program stored on the memory and executable on the processor. When the processor executes the computer program, it implements a protocol parsing method based on multi-agent collaboration as described in any one of the above implementation manners.

[0015] In a third aspect, an embodiment of the present application further provides a computer-readable storage medium, on which a computer program is stored. When the computer program is executed by a processor, it implements a protocol parsing method based on multi-agent collaboration as described in any one of the above implementation manners.

[0016] The protocol parsing method, device, and medium based on multi-agent collaboration provided by the embodiments of the present application at least include the following technical effects: By constructing a distributed agent cluster composed of parsing agents, scheduling agents, and management agents, and combining the collaborative working mechanism of the global protocol knowledge base, dynamic parsing and adaptation of a large number of industrial Internet of Things protocols are realized. The management agent incrementally learns the feature vectors of unknown protocols based on a convolutional neural network, automatically generates new protocol parsing rules, and synchronously updates them to the global knowledge base without manual code modification or service interruption. This mechanism enables the present application to have the adaptive ability to continuously expand protocol types, effectively solves the access problems of private protocols and non-standard protocols in industrial sites, and significantly improves device compatibility.

[0017] The parsing agent performs multi-stage protocol parsing through a lightweight parsing engine. The scheduling agent dynamically allocates tasks based on the real-time load status table (CPU utilization rate, memory occupancy rate) and historical parsing accuracy, and optimizes the selection of the target parsing agent using a load balancing scoring algorithm. The distributed architecture avoids single-point performance bottlenecks, and the multi-agent parallel processing mechanism improves the throughput of protocol parsing. The task allocation strategy considers the actual load status of nodes to ensure efficient resource utilization, thereby enhancing stability and response speed in high-concurrency scenarios.

[0018] The global protocol knowledge base supports centralized management and automatic synchronization of parsing rules. The management agent pushes lightweight engine update instructions to the parsing agent and synchronizes the mapping relationship between protocol types and agents to the scheduling agent. To achieve the full-automatic distribution and hot update of new protocol rules, eliminating the need for manual maintenance of the parsing engine. Through the autonomous collaboration of the agent cluster to complete protocol adaptation, it reduces the enterprise's operation and maintenance manpower investment and ensures the sustainability of the long-term operation of the industrial Internet of Things system to a certain extent. BRIEF DESCRIPTION OF THE DRAWINGS

[0019] The drawings described herein are used to provide a further understanding of the present application, and constitute a part of the present application. The illustrative embodiments of the present application and their descriptions are used to explain the present application, and do not constitute an improper limitation of the present application. In the drawings: Figure 1 It is a flowchart of a protocol parsing method based on multi-agent collaboration provided by an embodiment of the present application; Figure 2 It is a schematic diagram of the internal structure of a protocol parsing device based on multi-agent collaboration provided by an embodiment of the present application. Detailed implementation manners

[0020] To make the objectives, technical solutions and advantages of the present application clearer, the technical solutions of the present application will be clearly and completely described below in conjunction with specific embodiments of the present application and the corresponding drawings. Obviously, the described embodiments are only a part of the embodiments of the present application, rather than all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative efforts shall fall within the protection scope of the present application.

[0021] The embodiments of the present application provide a protocol parsing method, device and medium based on multi-agent collaboration to solve the following technical problems: how to achieve efficient dynamic parsing and adaptation of industrial Internet of Things protocols.

[0022] The technical solutions proposed in the embodiments of the present application will be described in detail below with reference to the drawings.

[0023] Figure 1 It is a protocol parsing flowchart based on multi-agent collaboration provided by an embodiment of the present application. As Figure 1 shown, a protocol parsing method based on multi-agent collaboration provided by an embodiment of the present application specifically includes the following steps: Step 1: Construct and associate a distributed agent cluster and a global protocol knowledge base; wherein, the distributed agent cluster includes parsing agents, scheduling agents and management agents, and the global protocol knowledge base is used to store parsing rules of known industrial Internet of Things protocols.

[0024] This step is used to create a distributed cluster composed of three types of agents (parsing agents, scheduling agents, management agents) and establish a global protocol knowledge base. The global protocol knowledge base stores parsing rules of known industrial Internet of Things protocols (such as MQTT, CoAP, Modbus) and provides a protocol parsing benchmark for the agent cluster.

[0025] Step 1.1: Deploy a lightweight parsing engine and load a basic parsing rule set to construct multiple parsing agents; wherein, the basic parsing rule set at least includes: an MQTT protocol function code mapping table, a CoAP protocol option header parsing tree, and a Modbus register address conversion rule.

[0026] Lightweight parsing engine: a protocol parsing core module with low resource occupancy that can quickly process binary protocol data streams.

[0027] The basic parsing rule set is a predefined protocol parsing template, including: MQTT protocol function code mapping table: Maps MQTT message types (such as CONNECT / PUBLISH) to corresponding control instructions.

[0028] CoAP protocol option header parsing tree: Parses the option header fields (such as URI path, content format) of the CoAP protocol in a tree structure.

[0029] Modbus register address conversion rule: Converts Modbus register addresses (such as 40001) to actual data points (such as motor speed).

[0030] Deploy a parsing engine instance at the server node, load the above rule set, and generate multiple parsing agents that can work in parallel.

[0031] In a specific example, Factory A needs to connect 10 devices B (using the Modbus protocol) and 5 devices C (using the MQTT protocol). The system administrator deploys a lightweight parsing engine on 3 nodes of the server cluster and loads the Modbus register address conversion rule (for example, register 40001 corresponds to "motor speed") and the MQTT function code mapping table (for example, PUBLISH message corresponds to "data reporting"). Each node generates 2 parsing agent instances, a total of 6 parsing agents, forming an initial parsing capability pool.

[0032] Step 1.2: Deploy a load monitoring probe component to build a scheduling agent including an agent load status table; among them, the agent load status table is used to continuously record the CPU utilization rate, memory occupancy rate, and historical parsing accuracy rate of multiple parsing agents.

[0033] Load monitoring probe component: A lightweight monitoring program embedded in the parsing agent to collect performance metrics in real time.

[0034] Agent load status table: A database table structure that records the following metrics: CPU utilization rate: The real-time CPU occupancy percentage of the parsing agent process.

[0035] Memory occupancy rate: The peak memory usage of the parsing agent process.

[0036] Historical parsing accuracy rate: The statistical value of the correct rate of a certain number of past protocol parsing tasks, and this certain number is usually set to more than 50 times.

[0037] Deploy a scheduling agent on the scheduling server, integrate the load monitoring probe component and create an agent load status table, and continuously receive the performance data of the parsing agent.

[0038] Continuing with the example in Step 1.1, the scheduling agent is deployed on an independent node. The load monitoring probe component embeds 6 parsing agents, which collect CPU and memory data every 5 seconds (for example, the CPU utilization of Agent 1 is 45% and the memory occupancy is 120MB). The historical parsing accuracy is verified and calculated through a check code (for example, setting a certain number of times to 100 times, the recent 100 parsing accuracies of Agent 2 are 98%, and for Agent 1, if the number of times is less than 100, it is calculated according to the actual number of times, and the parsing accuracy is 95%). The scheduling agent writes this data into the agent load status table to form the basis for decision-making.

[0039] Step 1.3: Initialize the global protocol knowledge base and deploy a neural network incremental learning module to generate a management agent; among them, the neural network incremental learning module includes a convolutional neural network layer and a backpropagation weight updater.

[0040] Initialize the global protocol knowledge base and preset the parsing rules of known industrial Internet of Things protocols, deploy a management agent on the management node, and bind the neural network incremental learning module.

[0041] Global protocol knowledge base: A distributed database (such as a Redis cluster) that stores a protocol rule set.

[0042] The neural network incremental learning module contains two core components: Convolutional neural network layer: Extract the spatial features of protocol data (such as byte distribution patterns).

[0043] Backpropagation weight updater: Dynamically adjust the network weights according to the prediction error to adapt to new protocol features.

[0044] Continuing with the example in Step 1.2, when the global protocol knowledge base of Factory A is initialized, it stores the parsing rules of MQTT, CoAP, and Modbus. The management agent is deployed on a dedicated node, and its neural network incremental learning module is pre-trained with industrial protocol features (such as the fixed header length of Modbus data frames). When an unknown protocol is encountered subsequently, the convolutional layer will automatically extract its byte distribution features (such as the frequent occurrence of 0x10 - 0x20), and the backpropagation weight updater will adjust the weights according to the prediction results.

[0045] Step 1.4: Associate the interfaces of the parsing agent, scheduling agent, and management agent to build a distributed agent cluster, and associate the distributed agent cluster with the global protocol knowledge base.

[0046] Interface association: Connect the communication interfaces of the three types of agents through an interface (such as RESTAPI) and a message queue (such as Kafka).

[0047] Bidirectional data synchronization channel: The distributed agent cluster can query the protocol rules in the global protocol knowledge base in real time (such as parsing the Modbus rules requested by the agent), and the global protocol knowledge base receives the rule updates from the management agent (such as adding the LoRaWAN protocol parsing rules).

[0048] Configure the API gateway and message middleware to establish the communication link between agents and the data channel between the cluster and the knowledge base.

[0049] Continuing with the example in step 1.3, in the system of Factory A: The parsing agent sends a task request to the scheduling agent through the message queue. The scheduling agent queries the protocol support list in the knowledge base through the interface. The management agent updates the newly learned protocol rules (such as the private protocol of device D) to the global protocol knowledge base through message broadcasting. The parsing agent subscribes to the update notification of the global protocol knowledge base to load the new rules in real time.

[0050] Step 2: Obtain the original IoT protocol of the industrial IoT device, and preprocess the original IoT protocol based on the parsing agent to generate a protocol parsing task package; among them, the protocol parsing task package can be recognized by the distributed agent cluster.

[0051] This step is used to implement the standardized preprocessing of the original protocol data, convert the binary protocol stream generated by the IoT device into a unified format task package that can be processed by the distributed agent cluster, and provide a standardized input for subsequent parsing.

[0052] Step 2.1: Based on the parsing agent, call the protocol feature template in the global protocol knowledge base to perform protocol type matching on the original IoT protocol to generate a grouped protocol data set.

[0053] Protocol feature template: A set of protocol recognition rules stored in the global protocol knowledge base; The protocol feature template includes: Header feature code: The byte sequence of the protocol start flag (such as 0x0001 for Modbus).

[0054] Length field position: The byte offset indicating the data length.

[0055] Checksum rule: The position and calculation method of checksum algorithms such as CRC / MD5.

[0056] The parsing agent reads the protocol feature template and scans the feature area of the original protocol data for matching.

[0057] In a specific example, the sensor C in Factory A continuously sends a binary data stream: [0x01 0x03 0x00 0x0A...]. The parsing agent calls the protocol feature template in the global protocol knowledge base: Match the header feature code: 0x01 corresponds to the Modbus function code "Read Holding Registers". Verify the length field: The 3rd - 4th bytes 0x000A indicate that the subsequent 10 bytes are valid data. Verify the checksum: The last 2 bytes conform to the Modbus CRC16 rule. After successful matching, mark this data stream as a "Modbus - 03 instruction" packet and generate a packet protocol data set.

[0058] Step 2.2: Use the parsing agent to fragment the packet protocol data set to generate a standardized data fragment set.

[0059] Data fragmentation: Cut the complete protocol data stream into processing units of a fixed size.

[0060] Fragmentation rules: Fixed - byte fragmentation: Each fragment contains a fixed number of bytes of data, for example, each fragment is 1024 bytes.

[0061] Protocol - unit fragmentation: Cut according to the complete protocol instruction (e.g., Modbus uses a 6 - byte instruction header as a unit).

[0062] The parsing agent selects a fragmentation strategy according to the protocol type to ensure that single - piece data can be parsed independently.

[0063] Following the example in Step 2.1, the parsing agent uses protocol - unit fragmentation for the Modbus data of sensor C: Identify the instruction unit: 0x010x030x000x0A0x000x02 is a complete read instruction (6 - byte header and 4 - byte data).

[0064] Cut the data stream: Split [0x010x03...] into multiple independent instruction units.

[0065] Generate a fragment set: Each fragment contains the complete byte sequence of a single instruction.

[0066] For the CoAP long message (1500 bytes) sent by device D, use fixed 1024 - byte fragmentation to ensure that each single piece does not exceed the processing limit.

[0067] Step 2.3: Use the parsing agent to perform format conversion on the standardized data fragment set to generate a protocol parsing task packet that can be recognized by the intelligent agent cluster.

[0068] Format conversion: Unify the storage structure and meta - information of the fragmented data.

[0069] Format conversion rules: Byte - order standardization: Unify to Big - Endian.

[0070] Metadata encapsulation: Add header information such as protocol type, shard sequence number, timestamp, etc.

[0071] Padding alignment: If the number of bytes is less than a certain value, fill with bytes for alignment. For example, if a shard is less than 128 bytes, fill it with 0x00 until it is aligned.

[0072] The parsing agent performs format conversion and then encapsulates it into a task packet object.

[0073] Continuing with the example in step 2.2, in the system of Factory A: Byte order conversion: Convert the little-endian data (0x0A00) sent by Device E to big-endian (0x000A).

[0074] Add meta information: Add header information to each shard.

[0075] The format is as follows: [Protocol type: Modbus][Shard ID: 0003][Timestamp: 2025-05-15 14:05:32][Data: 0x01 0x03...].

[0076] Padding alignment: Pad the 98-byte shard with 30 bytes of 0x00.

[0077] Finally, a standardized protocol parsing task packet is generated and sent to the scheduling agent through the message queue.

[0078] Step 3: Based on the scheduling agent, process the protocol parsing task packet to allocate the protocol parsing task packet to the target parsing agent.

[0079] This step realizes the intelligent scheduling of protocol parsing tasks. According to the protocol type and the load status of the agent, the optimal parsing agent is dynamically selected to execute the task to ensure system load balancing and efficient parsing.

[0080] Step 3.1: Parse the protocol type of the protocol parsing task packet through the scheduling agent.

[0081] Protocol type parsing: Extract the protocol identifier from the task packet header information.

[0082] The identifier types are: Numeric encoding: Such as 01 - Modbus, 02 - CoAP, 03 - MQTT; Feature hash value: The MD5 digest value of the protocol header bytes.

[0083] The scheduling agent reads the metadata header of the task packet and decodes the protocol type identifier.

[0084] In a specific example, the scheduling agent of Factory A receives a task packet, and the task packet is: Parse the packet header: [Protocol type: 0x4D42][Fragment ID: 0057][...]; Decoding type: 0x4D42 corresponds to the "Modbus-RTU" protocol registered in the knowledge base; Marking attribute: Identified as an industrial control protocol and requires high-priority processing.

[0085] Step 3.2. Filter the parsing agents that support the protocol type based on the agent load status table to construct a candidate parsing agent set.

[0086] Agent load status table: A database table that is updated in real time. For example: Agent ID; CPU utilization rate; Memory occupancy rate; Supported protocol list; Historical accuracy rate.

[0087] Parsing agent 01; 45%; 120MB; 01,03; 98.7%.

[0088] Filtering rules: Protocol support matching: The supported protocol list contains the current protocol type.

[0089] Health status check: Manually set thresholds, for example, CPU < 80% and memory < threshold (such as 500MB).

[0090] Schedule the agent to query the load status table and filter the agents that meet the conditions.

[0091] Continue with the example in Step 3.1: Query the load table: Currently, 8 parsing agents are online.

[0092] Protocol matching: Filter the agents that support the protocol containing 0x4D42 (Modbus-RTU) (parsing agents 02 / 05 / 07).

[0093] Health check: Exclude parsing agent 07 with CPU > 80% (currently 85%).

[0094] Final candidate set: Parsing agent 02 (CPU 62% / Memory 180MB), Parsing agent 05 (CPU 57% / Memory 210MB).

[0095] Step 3.3. Calculate the execution load balance scores of multiple parsing agents in the candidate parsing agent set based on the CPU utilization rate and memory occupancy of the candidate parsing agent set to generate a set of load score values.

[0096] The load scoring formula is: Score = α × (1 - CPU utilization rate) + β × (1 - memory occupancy rate / memory threshold).

[0097] Among them, α + β = 1 (in this application, it is default that α = 0.6 and β = 0.4).

[0098] It can be understood that the dynamic weight adjustment can be performed on α and β to adapt to the system state. For example: When the overall system load > 70%, increase the CPU weight (α = 0.8); When the memory fragmentation rate > 30%, increase the memory weight (β = 0.7).

[0099] The scheduling agent calculates the scores of each agent in the candidate set in real time.

[0100] Continuing with the example in step 3.2, the scheduling agent of Factory A calculates: The threshold is set as: memory threshold = 500MB, α = 0.6, β = 0.4.

[0101] Parsing agent 02 score: 0.6×(1 - 0.62) + 0.4×(1 - 180 / 500) = 0.6×0.38 + 0.4×0.64 = 0.228 + 0.256 = 0.484.

[0102] Parsing agent 05 score: 0.6×(1 - 0.57) + 0.4×(1 - 210 / 500) = 0.6×0.43 + 0.4×0.58 = 0.258 + 0.232 = 0.490.

[0103] Generate the score set: parsing agent 02 = 0.484, parsing agent 05 = 0.490.

[0104] Step 3.4: Based on the load score value set and the preset historical parsing accuracy rate, allocate the protocol parsing task package to the target parsing agent.

[0105] The allocation rule is set manually. For example: Select the agent with a score ≥ 0.4 (to avoid overloaded nodes), select the one with the highest historical accuracy rate among the qualified agents, and select the one with a higher score when the accuracy rate difference < 1%.

[0106] Push the task package to the target parsing agent through the task queue.

[0107] Continuing with the example in step 3.3, in the system of Factory A: Qualified check: both parsing agent 02 (0.484) and parsing agent 05 (0.490) are ≥ 0.4; Accuracy rate comparison: the historical accuracy rate of parsing agent 02 = 98.2%, and the historical accuracy rate of parsing agent 05 = 97.8%.

[0108] Decision: Select parsing agent 02 with a higher accuracy rate.

[0109] Task Assignment: Push the task package to the exclusive queue of the parsing agent 02.

[0110] Step 4: Use the parsing agent to perform feature extraction and protocol parsing on the parsing task package, and output structured parsing data; among them, the structured parsing data is the formatted format of the industrial Internet of Things device status information.

[0111] This step is used to achieve accurate parsing of protocol data, convert the standardized task package into structured device status data, and provide directly usable information for the industrial Internet of Things platform.

[0112] Step 4.1: Use the parsing agent to perform field parsing on the parsing task package to extract the key feature set of the parsing task package; among them, the key feature set includes the protocol version number, function code, and data length.

[0113] Field Parsing: Decompose the hierarchical structure of the parsing task package according to the protocol specification.

[0114] The key feature set includes the following information: Protocol Version Number: Identifies the version of the protocol specification (such as ModbusTCPv1.0); Function Code: Defines the operation type (such as 03 - Read Register, 06 - Write Single Register); Data Length: The number of bytes of the payload; The parsing agent locates the position of the feature field according to the protocol structure template.

[0115] In a specific example, the parsing agent of Factory A processes the task package of Device E: Locate the field position: Bytes 0 - 1: Protocol version number (0x0100 → v1.0); Byte 2: Function code (0x03 → Read Holding Register); Bytes 3 - 4: Data length (0x0008 → 8 bytes).

[0116] Step 4.2: Use the lightweight parsing engine of the parsing agent to perform protocol parsing on the key feature set to generate an intermediate parsing result set.

[0117] Lightweight Parsing Engine: Embedded parsing core; The lightweight parsing engine includes: Rule Matcher: Invoke the corresponding parsing template according to the function code; Data Converter: Conversion logic from raw bytes to physical values.

[0118] The intermediate parsing result set includes: Original data segment: Unprocessed binary payload; Conversion marker: Identifies complex fields that require collaborative processing.

[0119] Example of continuing with Step 4.1: Rule matching: Function code 03 triggers the "Read Holding Register" template.

[0120] Data conversion: Address resolution: Bytes 5 - 6 (0x0001 → register 40001); Value conversion: Bytes 7 - 8 (0x1388 → 5000 revolutions per minute).

[0121] Step 4.3: Verify the intermediate parsing result set through the parsing agent to generate structured parsing data.

[0122] The verification mechanism includes: Checksum verification: For example, recalculate CRC / MD5 and compare with the packet trailer check bit.

[0123] Range verification: Check if the data is within a reasonable range (e.g., rotational speed 0 - 8000 rpm).

[0124] Structured parsing data: Converted to the standard JSON format in this application, including: device ID, timestamp, status parameter key - value pairs.

[0125] Example of continuing with Step 4.2 in the system of Factory A: Checksum verification: Recalculate CRC16 = 0x4B29, match the packet trailer 0x4B29, then the result is passed. Range verification: 5000 rpm is within the reasonable range of the motor 0 - 8000 rpm, then the result is passed.

[0126] Generate structured data.

[0127] Step 5: If the parsing agent identifies an unknown protocol format during feature extraction and protocol parsing, extract the unknown protocol format and send the extracted unknown feature vector to the management agent.

[0128] This step is used to achieve automatic identification and feature extraction of unknown protocols, providing a data basis for dynamic learning of protocol rules, and solving the protocol adaptation problem for new device access in industrial scenarios.

[0129] Step 5.1: When the key feature set does not match the parsing rules in the global protocol knowledge base, it is determined as an unknown protocol format.

[0130] Matching judgment mechanism: The extracted key features (version number / function code / data length) are compared with the parsing rules of the global protocol knowledge base item by item, and all core features must be fully matched.

[0131] There are many failure scenarios, some of which are briefly described below: The version number is not registered (e.g. v2.5 is not in the v1.0-2.0 range); The function code has no corresponding operation (e.g. 0x89 is undefined); The data length is abnormal (for example, the actual length is greater than the declared length).

[0132] In a specific example, factory A connects to a new device G: First, extract the feature set of the new device G: Version number: v2.5; Function code: 0x89; Data length: 120.

[0133] By matching the above feature set with the parsing rules in the global protocol knowledge base, we find that: Version v3.2 is not registered (maximum support v2.3); Function code 0x89 has no corresponding operation; The data length 120 exceeds the threshold 100.

[0134] Judgment result: unknown protocol format (all three features failed to match).

[0135] Step 5.2: Extract feature vectors from unknown protocol formats to generate unknown feature vectors containing protocol header identifiers, data lengths, and check bits.

[0136] Example of feature vector structure extraction: Feature type; Extraction method; Example; Header identification; take the first 16 bytes of hash value; SHA256 ("0x100xA3...") converted to hash value "f8d2..."; Data length; Statistical payload bytes; 120 bytes; Check bit; locate and extract the check segment; the last 4 bytes 0x3B29C1D0; Byte distribution; calculate the frequency of 0x00-0xFF; [0x10: 12%, 0x20: 8%...].

[0137] Continue with the example from step 5.1: Header identification extraction: The first 16 bytes are intercepted as 0x100xA30x02...0xF1, and the SHA256 hash is generated: "d4e5f6...".

[0138] Data length verification: Declared length: 120 bytes; Actual payload: 118 bytes (including 2-byte padding).

[0139] Check bit extraction: Locate the last 4 bytes of the packet: 0x3B 0x29 0xC1 0xD0; Byte distribution analysis: Count the occurrence frequency of each byte; Generate a distribution matrix: {0x10: 15, 0x20: 9,...}; Generate an unknown feature vector: d4 e5 f6...; 118; 0x3B 29 C1 D0; [15, 9,....].

[0140] Step 5.3: Send the unknown feature vector to the management agent.

[0141] The sending method can be set according to the actual situation. In this application, the message queue transmission method is adopted, for example, sending through Kafka / RabbitMQ.

[0142] It should be noted that this application sets a priority mark when sending the location feature vector, and the priority mark is determined according to the device type.

[0143] Step 6: Process the unknown feature vector through the management agent to determine the new protocol parsing rules for the unknown protocol format, and synchronize the new protocol parsing rules to the global protocol knowledge base.

[0144] This step is used to implement the intelligent learning and rule generation of unknown protocols, analyze protocol features through neural networks, dynamically expand the parsing ability of the system, and solve the problem of private protocol adaptation in industrial scenarios.

[0145] Step 6.1: Receive the unknown feature vector through the management agent.

[0146] Corresponding to Step 5.3. First, the management agent continuously listens, checks data integrity (CRC check) and source credibility, and processes according to the device criticality classification (high / medium / low); after receiving, unpack and store in the buffer to be processed.

[0147] Step 6.2: Input the unknown feature vector into a preset convolutional neural network model for incremental learning to generate new protocol parsing rules.

[0148] Input the received unknown feature vector into a preset convolutional neural network model, and generate new protocol parsing rules through incremental learning.

[0149] The convolutional neural network model is pre-trained on a known protocol dataset and supports dynamic updates to adapt to new feature vectors. The incremental learning process is achieved through model fine-tuning, avoiding full retraining.

[0150] The convolutional neural network model refers to a pre-built deep learning model deployed in the computing unit of the management agent. Its structure includes convolutional layers, pooling layers, and fully connected layers, and is used to learn protocol patterns from feature vectors. The model is initialized based on training with historical protocol data, and the parameters are stored in the local storage module.

[0151] Incremental learning refers to a learning method where the model performs small-scale fine-tuning by receiving new feature vectors, rather than retraining the entire model. Specifically, the model adjusts the weight parameters according to the input feature vectors to minimize the error rate. The learning process uses an online optimization algorithm (such as stochastic gradient descent) to update the model in real-time, generating new protocol parsing rules. The output form of the rules includes text rule files or binary logic descriptions.

[0152] After inputting the feature vectors, the convolutional neural network analyzes the vector patterns to match known patterns or identify new features, and outputs the corresponding rules.

[0153] In a specific example, the system of Factory A detects an unknown format that is not recognized by the existing protocol knowledge base. The feature vectors are extracted. The management agent receives the feature vectors through the REST API interface. The incremental learning module uses a pre-set convolutional neural network model that is pre-trained based on historical HTTP and MQTT protocol data. After inputting the feature vectors, the model learns new features by fine-tuning the layer weights: the feature vectors show a high-frequency short message sequence, and the model infers that it corresponds to the real-time streaming protocol format, generating new protocol parsing rules to handle the chunked transfer field.

[0154] Step 6.3: Write the new protocol parsing rules to the unrecognized protocol storage area of the global protocol knowledge base.

[0155] The management agent writes the generated new protocol parsing rules to the designated area of the global protocol knowledge base, namely the unrecognized protocol storage area. The write operation is executed through the database interface to ensure the secure storage of the rules and their availability for synchronization.

[0156] The management agent calls the storage API of the global protocol knowledge base to write the rules in a transactional manner. The transactional manner refers to an atomic operation mechanism that ensures the write is either complete or rolled back. The API is defined as a database standard command set (such as SQL INSERT or NoSQL put), supporting rule format conversion (such as from a text file to a database record).

[0157] The unrecognized protocol storage area is a dedicated partition in the global protocol knowledge base for temporarily storing newly recognized rules, which will be migrated to the main library after subsequent verification.

[0158] This application also includes the following methods: A1. Send a protocol type agent mapping relationship update instruction from the management agent to the scheduling agent to update the agent load status table.

[0159] In a specific example, the Factory A system newly added the vibration sensor protocol N. The management agent detected that this protocol was added to the global protocol knowledge base. After querying the load status table, it was found that the CPU occupancy rate of agent 09 was only 35%, while the load of the original sensor protocol processing agent 03 had reached 80%. The management agent generated an update instruction "Bind protocol N to agent 09, with high priority" and sent it to the scheduling agent through the message queue. After receiving the instruction, the scheduling agent updated the mapping relationship index, automatically directed the traffic of protocol N to agent 09, and at the same time appended "protocol C" to the "bound protocol" field of agent 09.

[0160] A2. Send a lightweight parsing engine rule update instruction from the management agent to the parsing agent.

[0161] In a specific example, the Factory A system needs to process the newly added emergency broadcast protocol Z. The management agent extracts the protocol rules (including the message header flag 0x0101) from the global protocol knowledge base, compiles them into a 32-byte binary fragment recognizable by the lightweight engine, adds the version number "V1.2" and the check code 0x3A5B, and sends them to the parsing agent at node B through a dedicated data channel. After passing the verification, the parsing agent inserts the rule fragment into the head of the in-memory rule chain. When the first protocol Z data packet (header flag 0x0101) arrives, it recognizes and disassembles the broadcast content field.

[0162] The above are the method embodiments proposed in this application. Based on the same inventive concept, the embodiments of this application also provide a protocol parsing device based on multi-agent collaboration, and its structure is as Figure 2 shown.

[0163] Figure 2 FIG. is a schematic internal structure diagram of a protocol parsing device based on multi-agent collaboration provided by an embodiment of this application. As Figure 2 shown, the device includes: At least one processor 201; And a memory 202 communicatively connected to the at least one processor; Wherein, the memory 202 stores instructions executable by the at least one processor. The instructions are executed by the at least one processor 201 so that the at least one processor 201 can: Build and associate a distributed agent cluster and a global protocol knowledge base; wherein, the distributed agent cluster includes a parsing agent, a scheduling agent, and a management agent, and the global protocol knowledge base is used to store parsing rules for known industrial Internet of Things protocols; obtain the original Internet of Things protocol of the industrial Internet of Things device, and preprocess the original Internet of Things protocol based on the parsing agent to generate a protocol parsing task package; wherein, the protocol parsing task package can be recognized by the distributed agent cluster; process the protocol parsing task package based on the scheduling agent to allocate the protocol parsing task package to the target parsing agent; perform feature extraction and protocol parsing on the parsing task package through the parsing agent, and output structured parsing data; wherein, the structured parsing data is a formatted format of the industrial Internet of Things device status information; if the parsing agent recognizes an unknown protocol format during feature extraction and protocol parsing, then extract the unknown protocol format, and send the extracted unknown feature vector to the management agent; process the unknown feature vector through the management agent to determine a new protocol parsing rule for the unknown protocol format, and synchronize the new protocol parsing rule to the global protocol knowledge base.

[0164] Some embodiments of the present application provide a corresponding Figure 1 non-volatile computer storage medium for protocol parsing based on multi-agent collaboration, storing computer-executable instructions, and the computer-executable instructions are set as: Build and associate a distributed agent cluster and a global protocol knowledge base; wherein, the distributed agent cluster includes a parsing agent, a scheduling agent, and a management agent, and the global protocol knowledge base is used to store parsing rules for known industrial Internet of Things protocols; obtain the original Internet of Things protocol of the industrial Internet of Things device, and preprocess the original Internet of Things protocol based on the parsing agent to generate a protocol parsing task package; wherein, the protocol parsing task package can be recognized by the distributed agent cluster; process the protocol parsing task package based on the scheduling agent to allocate the protocol parsing task package to the target parsing agent; perform feature extraction and protocol parsing on the parsing task package through the parsing agent, and output structured parsing data; wherein, the structured parsing data is a formatted format of the industrial Internet of Things device status information; if the parsing agent recognizes an unknown protocol format during feature extraction and protocol parsing, then extract the unknown protocol format, and send the extracted unknown feature vector to the management agent; process the unknown feature vector through the management agent to determine a new protocol parsing rule for the unknown protocol format, and synchronize the new protocol parsing rule to the global protocol knowledge base.

[0165] Each embodiment in this application is described in a progressive manner. For the same or similar parts among the embodiments, reference can be made to each other. Each embodiment focuses on the differences from other embodiments. In particular, for the embodiments of the Internet of Things devices and media, since they are basically similar to the method embodiments, the description is relatively simple, and for the relevant parts, reference can be made to the partial description of the method embodiments.

[0166] The systems and media provided by the embodiments of this application correspond one-to-one with the methods. Therefore, the systems and media also have beneficial technical effects similar to those of their corresponding methods. Since the beneficial technical effects of the methods have been described in detail above, the beneficial technical effects of the systems and media will not be elaborated here.

[0167] Those skilled in the art should understand that the embodiments of this application can be provided as methods, systems, or computer program products. Therefore, this application can take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware aspects. Moreover, this application can take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk memories, CD-ROMs, optical memories, etc.) containing computer-usable program code.

[0168] This application is described with reference to the flowcharts and / or block diagrams of methods, devices (systems), and computer program products according to the embodiments of this application. It should be understood that each flow and / or block in the flowchart and / or block diagram, as well as the combination of flows and / or blocks in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing devices to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing devices generate a device for implementing the functions specified in Figure 1 one or more of the flows Figure 1 or a combination of one or more blocks.

[0169] These computer program instructions can also be stored in a computer-readable memory that can direct a computer or other programmable data processing device to work in a specific manner, so that the instructions stored in the computer-readable memory generate a manufactured article including an instruction device, and the instruction device implements the functions specified in Figure 1 one or more of the flows Figure 1 or a combination of one or more blocks.

[0170] These computer program instructions can also be loaded onto a computer or other programmable data processing device, so that a series of operation steps are executed on the computer or other programmable device to generate a computer-implemented process. Thus, the instructions executed on the computer or other programmable device provide steps for implementing the functions specified in one process Figure 1 one process or multiple processes and / or blocks Figure 1 steps of the functions specified in one block or multiple blocks.

[0171] In a typical configuration, a computing device includes one or more processors (CPUs), an input / output interface, a network interface, and a memory.

[0172] The memory may include non-permanent memory in the computer-readable medium, in the form of random access memory (RAM) and / or non-volatile memory, such as read-only memory (ROM) or flash memory (flashRAM). The memory is an example of a computer-readable medium.

[0173] Computer-readable media includes permanent and non-permanent, removable and non-removable media, and information storage can be implemented by any method or technology. The information can be computer-readable instructions, data structures, program modules, or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technologies, compact disc read-only memory (CD-ROM), digital versatile disc (DVD) or other optical storage, magnetic cassette tapes, magnetic disk storage or other magnetic storage devices, or any other non-transmission media that can be used to store information accessible by a computing device. As defined herein, computer-readable media does not include transitory computer-readable media, such as modulated data signals and carrier waves.

[0174] It should also be noted that the term "comprising", "including" or any other variation thereof is intended to cover non-exclusive inclusion, so that a process, method, commodity or device including a series of elements not only includes those elements, but also includes other elements not explicitly listed, or also includes elements inherent to such process, method, commodity or device. Without further limitation, an element defined by the statement "including a..." does not exclude the existence of another identical element in the process, method, commodity or device including the element.

[0175] The above are only embodiments of the present application and are not intended to limit the present application. For those skilled in the art, various changes and modifications can be made to the present application. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application shall be included within the scope of the claims of the present application.

Claims

1. A protocol parsing method based on multi-agent collaboration, characterized in that Applied to industrial Internet of Things devices, the method includes: Construct and associate a distributed agent cluster and a global protocol knowledge base; wherein, the distributed agent cluster includes a parsing agent, a scheduling agent, and a management agent, and the global protocol knowledge base is used to store parsing rules of known industrial Internet of Things protocols; Obtain the original Internet of Things protocol of the industrial Internet of Things device, and preprocess the original Internet of Things protocol based on the parsing agent to generate a protocol parsing task package; wherein, the protocol parsing task package can be recognized by the distributed agent cluster; Process the protocol parsing task package based on the scheduling agent to allocate the protocol parsing task package to a target parsing agent; Extract features and parse the protocol for the parsing task package through the parsing agent, and output structured parsing data; wherein, the structured parsing data is a formatted format of the industrial Internet of Things device status information; If the parsing agent identifies an unknown protocol format during feature extraction and protocol parsing, extract the unknown protocol format and send the extracted unknown feature vector to the management agent; Process the unknown feature vector through the management agent to determine a new protocol parsing rule for the unknown protocol format, and synchronize the new protocol parsing rule to the global protocol knowledge base.

2. The protocol parsing method based on multi-agent collaboration according to claim 1, wherein, Construct and associate a distributed agent cluster and a global protocol knowledge base, specifically including: Deploy a lightweight parsing engine and load a basic parsing rule set to construct multiple parsing agents; wherein, the basic parsing rule set at least includes: an MQTT protocol function code mapping table, a CoAP protocol option header parsing tree, and a Modbus register address conversion rule; Deploy a load monitoring probe component to construct a scheduling agent including an agent load status table; wherein, the agent load status table is used to continuously record the CPU utilization rate, memory occupancy rate, and historical parsing accuracy of multiple parsing agents; Initialize the global protocol knowledge base and deploy a neural network incremental learning module to generate a management agent; wherein, the neural network incremental learning module includes a convolutional neural network layer and a backpropagation weight updater; Associate the interfaces of the parsing agent, the scheduling agent, and the management agent to construct the distributed agent cluster, and associate the distributed agent cluster with the global protocol knowledge base.

3. The protocol parsing method based on multi-agent collaboration according to claim 1, wherein, Obtain the original Internet of Things protocol of the industrial Internet of Things device, and preprocess the original Internet of Things protocol based on the parsing agent to generate a protocol parsing task package, specifically including: Based on the parsing agent, call the protocol feature template in the global protocol knowledge base to perform protocol type matching on the original Internet of Things protocol to generate a grouped protocol data set; Perform data sharding on the grouped protocol data set through the parsing agent to generate a standardized data sharding set; Perform format conversion on the standardized data sharding set through the parsing agent to generate a protocol parsing task package that can be recognized by the agent cluster.

4. A protocol parsing method based on multi-agent collaboration according to claim 2, characterized in that, Processing the protocol parsing task package based on the scheduling agent to allocate the protocol parsing task package to a target parsing agent, specifically including: Parsing the protocol type of the protocol parsing task package by the scheduling agent; Filtering parsing agents that support the protocol type based on the agent load status table to construct a candidate parsing agent set; Calculating the execution load balance scores of multiple parsing agents in the candidate parsing agent set based on the CPU utilization rate and memory occupancy of the candidate parsing agent set to generate a load score value set; Allocating the protocol parsing task package to the target parsing agent based on the load score value set and the preset historical parsing accuracy rate.

5. The protocol parsing method based on multi-agent collaboration according to claim 1, characterized in that, Performing feature extraction and protocol parsing on the parsing task package by the parsing agent and outputting structured parsing data, specifically including: Performing field parsing on the parsing task package by the parsing agent to extract a key feature set of the parsing task package; wherein, the key feature set includes a protocol version number, a function code, and a data length; Performing protocol parsing on the key feature set by the lightweight parsing engine of the parsing agent to generate an intermediate parsing result set; Verifying the intermediate parsing result set by the parsing agent to generate structured parsing data.

6. The protocol parsing method based on multi-agent cooperation according to claim 1, characterized in that, If the parsing agent identifies an unknown protocol format during feature extraction and protocol parsing, extracting the unknown protocol format and sending the extracted unknown feature vector to the management agent, specifically including: Determining it as an unknown protocol format when the key feature set does not match the parsing rules in the global protocol knowledge base; Performing feature vector extraction on the unknown protocol format to generate an unknown feature vector including a protocol header identifier, a data length, and a check bit; Sending the unknown feature vector to the management agent.

7. A protocol parsing method based on multi-agent collaboration according to claim 4, characterized in that, Processing the unknown feature vector by the management agent to determine new protocol parsing rules for the unknown protocol format and synchronizing the new protocol parsing rules to the global protocol knowledge base, specifically including: Receiving the unknown feature vector by the management agent; Inputting the unknown feature vector into a preset convolutional neural network model for incremental learning to generate new protocol parsing rules; Writing the new protocol parsing rules into the unrecognized protocol storage area of the global protocol knowledge base.

8. A protocol parsing method based on multi-agent collaboration according to claim 7, characterized in that, After processing the unknown feature vector by the management agent to determine new protocol parsing rules for the unknown protocol format and synchronizing the new protocol parsing rules to the global protocol knowledge base, the method further includes: Sending a protocol type-agent mapping relationship update instruction to the scheduling agent by the management agent to update the agent load status table; Sending a lightweight parsing engine rule update instruction to the parsing agent by the management agent.

9. An electronic device, comprising a memory, a processor, and a computer program stored on the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements a protocol parsing method based on multi-agent collaboration according to any one of claims 1-8.

10. A computer-readable storage medium having a computer program stored thereon, characterized in that, When the computer program is executed by a processor, it implements a protocol parsing method based on multi-agent collaboration according to any one of claims 1-8.

Images