Intelligent fusion terminal multi-protocol communication method and system based on edge computing

Abstract

The application relates to the technical field of intelligent fusion terminal communication, and discloses an intelligent fusion terminal multi-protocol communication method and system based on edge computing. The method deploys a protocol adaptive engine on an edge node, collects and analyzes original data streams of a communication link in real time, dynamically identifies a current protocol type in a fuzzy matching mode, dynamically loads a corresponding protocol analysis module based on an identification result, generates an adaptation instruction set, and realizes standardized data frame encapsulation through a protocol conversion intermediate layer. Meanwhile, the system listens to a link state, triggers incremental updating of a protocol feature library, and realizes seamless protocol switching. The application improves communication compatibility and reliability, and meets the needs of high-reliability scenarios such as industrial Internet of Things.

Description

Technical Field

[0001] This invention relates to the field of intelligent converged terminal communication technology, and more specifically to a multi-protocol communication method and system for intelligent converged terminals based on edge computing. Background Technology

[0002] Traditional smart terminals rely on fixed protocol stacks in multi-protocol communication scenarios, requiring pre-configuration of protocol types and lacking dynamic adaptability. This necessitates manual intervention or communication interruption during heterogeneous networks or protocol upgrades. Existing technologies rely on static feature library matching for protocol identification, lacking the ability to extend to unknown or variant protocols. Especially in edge computing environments, where terminal resources are limited and low-latency processing is required, traditional methods struggle to meet real-time and compatibility demands. Furthermore, protocol switching necessitates re-initializing the communication channel, easily leading to data loss or service interruption, failing to meet the high-reliability requirements of industrial IoT scenarios for protocol adaptation and seamless switching. Summary of the Invention

[0003] To address the aforementioned technical shortcomings, the purpose of this invention is to provide a multi-protocol communication method and system for intelligent converged terminals based on edge computing, thereby solving the problems of poor adaptability and incompatibility in protocol switching in existing technologies.

[0004] To solve the above-mentioned technical problems, the present invention adopts the following technical solution:

[0005] In a first aspect, the present invention provides a multi-protocol communication method for intelligent fusion terminals based on edge computing, the method comprising:

[0006] The intelligent converged terminal deploys a protocol adaptive engine at the edge node to collect the raw data stream of the communication link in real time;

[0007] The dynamic protocol feature code parsing module extracts the protocol feature identifiers from the original data stream and performs fuzzy matching with the pre-stored communication protocol feature library to identify the current communication protocol type.

[0008] Based on the protocol type identification result, the corresponding protocol parsing and execution module is dynamically loaded by calling the edge node resources to generate a communication instruction set adapted to the target protocol;

[0009] The protocol conversion intermediate layer encapsulates the instruction set into standardized data frames and monitors changes in the communication link status. If a protocol switching characteristic signal is detected, the incremental update mechanism of the protocol characteristic library is triggered, the new protocol execution module is loaded, and the communication channel is switched.

[0010] Preferably, in one possible implementation of the first aspect, the fuzzy matching process includes:

[0011] The dynamic protocol signature parsing module extracts features from the collected raw data stream in real time, generating feature identifiers that include protocol header format, control field sequence, and data packet length distribution.

[0012] The feature identifier is compared with a pre-stored communication protocol feature library to perform multi-dimensional similarity calculation. The multi-dimensional similarity calculation is based on a preset matching threshold range. A sliding window mechanism is used to traverse the protocol templates in the feature library to identify the maximum similarity value between the feature identifier and the template.

[0013] When the similarity value exceeds the dynamic threshold, it is determined that the protocol type is successfully matched; otherwise, the dynamic expansion mechanism of the feature library is triggered to introduce a backup protocol template for secondary matching.

[0014] Preferably, in one possible implementation of the first aspect, the multi-dimensional similarity calculation employs a weighted Euclidean distance algorithm, wherein the weight factor is dynamically adjusted according to the priority of the feature identifier, and the priority is determined by the stability index of the feature in historical communication.

[0015] The sliding window mechanism, combined with time series analysis, segments the data stream and applies an adaptive matching strategy within each window, including downsampling of low-frequency protocols and feature enhancement of high-frequency protocols.

[0016] When a match fails, the dynamic expansion mechanism calls the cached resources of the edge node to load the new protocol template.

[0017] Preferably, in one possible implementation of the first aspect, the process of generating the communication instruction set includes:

[0018] Based on the protocol type identification results, computing resources are dynamically allocated through the resource scheduler of the edge node, and the corresponding protocol parsing and execution module is loaded.

[0019] The protocol parsing and execution module performs structured parsing of the original data stream and extracts key instruction fields according to the syntax rules and semantic constraints of the target protocol;

[0020] When generating communication instruction sets, a rule engine is used to map the parsed fields to standard opcode sequences. At the same time, a protocol version compatibility layer is introduced to adapt and convert older protocols.

[0021] Preferably, in one possible implementation of the first aspect, the resource scheduler adopts an elastic allocation strategy based on load prediction, wherein the prediction model is trained using historical communication data and dynamically adjusts the CPU and memory resources of the edge nodes according to the protocol complexity.

[0022] The rule engine incorporates context-aware technology, integrates environmental variable factors, including link latency and device status, into the instruction mapping process, and automatically injects fault-tolerant instructions when generating instruction sets.

[0023] The protocol version compatibility layer is implemented through the protocol abstraction layer, which converts the private fields of the old protocol into an intermediate representation format and then encapsulates them into standard opcodes to avoid instruction conflicts caused by protocol fragmentation.

[0024] Preferably, in one possible implementation of the first aspect, the fault-tolerant instruction generation employs a reinforcement learning model, which is trained based on real-time link quality feedback to dynamically generate retransmission mechanisms and timeout control instructions.

[0025] The protocol abstraction layer introduces a metadata annotation mechanism to attach a protocol version identifier and dependency relationship to each opcode.

[0026] Preferably, in one possible implementation of the first aspect, the incremental update mechanism of the protocol feature library includes:

[0027] The protocol conversion intermediate layer continuously monitors changes in the communication link status. When a protocol switching characteristic signal is detected, an incremental update mechanism is triggered to extract the feature identifier of the new protocol, compare it with the feature library, and identify the newly added feature set.

[0028] Based on the comparison results, the protocol templates of the feature library are updated incrementally. The update process includes template merging and conflict resolution.

[0029] Simultaneously, new protocol execution modules are dynamically loaded, and communication channels are switched using hot-swapping technology.

[0030] Preferably, in one possible implementation of the first aspect, the difference comparison employs a difference vector-based algorithm, where the vector is composed of the hash values ​​of feature identifiers, and the comparison process is performed within a secure sandbox on the edge node to prevent malicious protocol injection.

[0031] The conflict resolution application priority strategy retains historical protocol templates as backups, and new templates are managed through a version control tree, supporting rollback operations.

[0032] The hot-plug technology is combined with a lightweight containerized architecture, which reserves cache resources when loading new modules and uses dual-channel buffering technology for module switching.

[0033] Preferably, in one possible implementation of the first aspect, the dual-channel buffering technology adopts a circular queue design, with the old channel and the new channel running in parallel, and queue management based on a flow shaping algorithm to smoothly switch data streams;

[0034] The containerized architecture optimizes module loading time and reduces startup latency through pre-compiled binaries;

[0035] Meanwhile, the incremental update mechanism integrates an online learning module, using feedback data during the switching process to train the template weights of the feature library, thereby improving the accuracy of protocol detection.

[0036] In a second aspect, the present invention provides a multi-protocol communication system for intelligent converged terminals based on edge computing, the system being used to implement the multi-protocol communication method for intelligent converged terminals based on edge computing in the first aspect, comprising:

[0037] The data acquisition module, with the intelligent fusion terminal deploying a protocol adaptive engine at the edge node, collects the raw data stream of the communication link in real time;

[0038] The protocol identification module extracts protocol feature identifiers from the raw data stream through the dynamic protocol feature code parsing module, performs fuzzy matching with the pre-stored communication protocol feature library, and identifies the current communication protocol type.

[0039] The instruction generation module, based on the protocol type identification result, calls the edge node resources to dynamically load the corresponding protocol parsing and execution module, and generates a communication instruction set adapted to the target protocol;

[0040] The protocol conversion module encapsulates the instruction set into standardized data frames through the protocol conversion intermediate layer. At the same time, it monitors changes in the communication link status. If a protocol switching characteristic signal is detected, it triggers the incremental update mechanism of the protocol characteristic library, loads the new protocol execution module, and switches the communication channel.

[0041] The beneficial effects of this invention are as follows: By deploying a protocol adaptive engine at edge nodes, this invention achieves dynamic identification and seamless switching of multiple protocols, improving communication compatibility. It employs fuzzy matching and incremental update mechanisms to reduce reliance on static feature libraries and enhance the scalability for unknown protocols.

[0042] The resource scheduler dynamically allocates computing resources based on load prediction to optimize the performance of edge nodes. Meanwhile, the rule engine incorporates context-aware technology to generate fault-tolerant instructions to cope with network jitter and improve communication reliability.

[0043] Version control and hot-swappable technology of the protocol feature library enable zero-packet-loss switching, meeting the real-time and stability requirements of industrial scenarios, reducing operation and maintenance costs and improving system flexibility. Attached Figure Description

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

[0045] Figure 1 This application provides a flowchart of a multi-protocol communication method for intelligent fusion terminals based on edge computing.

[0046] Figure 2 This application provides a structural diagram of a multi-protocol communication system for intelligent converged terminals based on edge computing.

[0047] Explanation of reference numerals in the attached diagram: 1-Data acquisition module, 2-Protocol identification module, 3-Command generation module, 4-Protocol conversion module. Detailed Implementation

[0048] The technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the present invention, and not all embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of the present invention.

[0049] Example 1: As Figure 1 As shown, this invention provides a multi-protocol communication method for intelligent fusion terminals based on edge computing, including:

[0050] The intelligent converged terminal deploys a protocol adaptive engine at the edge node to collect the raw data stream of the communication link in real time.

[0051] In this embodiment, the protocol adaptive engine is deployed on edge computing nodes using a lightweight microservice architecture and captures data from communication links through a data plane development kit. The engine accesses multi-protocol communication interfaces at the physical layer, including an RS-485 serial bus, an Ethernet MAC layer, and a wireless LoRa RF module, and manages the driver resources of these heterogeneous physical interfaces uniformly through the hardware layer. The data acquisition process employs a dual-ring buffer design: the primary buffer receives the raw bit stream at line speed and appends a timestamp; the secondary buffer performs data preprocessing, filtering out invalid noise frames using a programmable gate array, retaining only valid communication messages.

[0052] The engine ensures real-time performance through a dynamic resource partitioning mechanism, allocating dedicated CPU cores and memory channels to data acquisition tasks to avoid latency caused by operating system scheduling. The acquisition scope covers raw data across the entire protocol stack, including physical layer signal waveform characteristics, link layer MAC frame structures, and binary streams of application layer payloads, ensuring the completeness required for protocol analysis. For high-bandwidth links, the engine employs a traffic shaping module based on a token bucket algorithm to limit the impact of burst traffic on edge node resources; for low-power narrowband links, adaptive sampling rate adjustment technology is used to reduce power consumption while maintaining the integrity of protocol characteristics.

[0053] An active probing mechanism is embedded during data acquisition: low-intensity probe frames are periodically injected into the communication link to monitor changes in link response latency and bit error rate. The probe results are encapsulated into metadata tags synchronously with the raw data stream, including channel quality indicators (RSSI, signal-to-noise ratio), link load rate, and physical layer bit error statistics. Acquired data is transmitted to the protocol processing pipeline at the edge node via a secure memory channel, simultaneously triggering integrity checks. Data frame continuity is verified using the CRC-32 algorithm; if data loss or verification failure is detected, a hardware retransmission controller automatically triggers local data reacquisition.

[0054] The engine supports hot-swappable interface expansion. When a new communication interface is detected, the corresponding driver is automatically loaded and the data acquisition pipeline is reconstructed without interrupting the existing communication session. The raw data stream generated during the acquisition process is temporarily stored in the non-volatile memory of the edge node in time-series form. The communication context of the most recent 5 seconds is retained for real-time protocol analysis. Time-out data is automatically transferred to the compressed buffer, and the LZ4 lossless compression algorithm is used to reduce storage overhead.

[0055] The dynamic protocol feature code parsing module extracts the protocol feature identifiers from the original data stream and performs fuzzy matching with the pre-stored communication protocol feature library to identify the current communication protocol type.

[0056] In this embodiment, the dynamic protocol signature parsing module achieves real-time feature extraction through a three-layer pipeline architecture: First, at the physical layer, a hardware-accelerated bitstream analysis unit identifies the protocol header format of the raw data stream, capturing structured features including start flags and address field lengths; second, at the data link layer, a state machine engine is deployed to track the dynamic changes in control field sequences, extracting key control features such as function code sequences in Modbus and arbitration mechanisms in the CAN protocol; finally, at the application layer, statistical distribution analysis of data packet payloads is performed, calculating frequency distribution histograms of data packets of different lengths to form multi-dimensional feature vectors. The feature identifier consists of 128-bit feature vectors in the above three dimensions, compressed into a 32-bit fixed-length feature code using a hash digest algorithm.

[0057] During the fuzzy matching phase, the matching engine of the edge nodes employs a sliding window mechanism to process the real-time data stream. The window size is dynamically adjusted, and feature identifiers are aligned to the time series within each window. First, a pre-stored communication protocol feature library is called, and feature similarity is calculated using a weighted Euclidean distance algorithm. The weighting factors are dynamically configured based on historical communication stability: protocol header format features account for 0.6, control field sequence features account for 0.3, and packet length distribution accounts for 0.1. The matching threshold is set in a dynamic range of 0.85-0.92. When a high-frequency protocol is detected, the threshold is automatically increased to 0.92; for low-frequency protocols, a downsampling strategy is initiated to reduce computational load. During the sliding window traversal, when the similarity between a feature identifier and a protocol template exceeds the dynamic threshold, the matching result is immediately output, and the current protocol type is locked.

[0058] When all protocol templates fail to match, the system triggers a dynamic expansion mechanism for the feature library: it calls the secure container resources of the edge nodes to load new protocol templates from the pre-trained protocol knowledge graph. The new templates are constructed using an incremental learning model, based on a protocol abstract syntax tree. A difference comparison algorithm extracts new feature sets from the feature identifiers, generating supplementary feature vectors which are then merged into the local feature library. A secondary matching process is simultaneously initiated, using a double-buffering strategy to maintain real-time data processing and ensure protocol recognition latency is less than 50ms. Every 24 hours, the system automatically performs weight optimization training on the feature library, adjusting the dimensional weights of the template feature vectors based on historical protocol switching data to improve robustness in complex industrial environments. The feature library update process employs a version control mechanism, generating timestamped templates with each change and supporting version rollback operations in abnormal situations.

[0059] Based on the protocol type identification result, the corresponding protocol parsing and execution module is dynamically loaded by calling the edge node resources to generate a communication instruction set adapted to the target protocol.

[0060] In this embodiment, the resource scheduler first initiates a dynamic resource allocation process based on the protocol type identification result: A sliding window-based load prediction algorithm is used to construct a protocol complexity evaluation model by analyzing the CPU / memory consumption patterns of various protocols in historical communication data. When the target protocol is identified as MQTT, the scheduler dynamically allocates computing resources from the resource pool of the edge node, including 1.2 dedicated CPU cores, a 256MB isolated memory region, and a dedicated hardware acceleration channel, ensuring the resource guarantee required for protocol parsing.

[0061] After resource allocation is complete, the protocol parsing and execution module is deployed to the resource partition via a hot-loading mechanism: Utilizing containerized encapsulation technology, the image pre-loads the target protocol's syntax rule library and semantic constraint templates. This embodiment uses the OPCUA protocol as an example. After loading, the parsing module initializes a three-stage processing pipeline: the first stage extracts node description fields from the data stream using deep packet inspection; the second stage applies a semantic constraint engine to verify the compliance of the data structure; and the third stage performs structured extraction of execution instruction fields, converting read and write instructions in the binary stream into time-stamped <opcode, data address, value range> triples. A real-time verification mechanism is embedded in the processing: a lightweight sandbox environment is created at the edge node to simulate the target device's behavior, injecting the parsed instruction set and monitoring response latency and functional correctness. If an instruction timeout or logical conflict is detected, the rule engine is triggered to roll back and reconstruct the instruction sequence.

[0062] The instruction set generation phase incorporates multiple optimization strategies: The rule engine first maps structured fields to standard opcodes. This mapping process incorporates context-aware technology, automatically injecting fault-tolerant instructions into the opcode sequence by monitoring real-time link latency and device status registers. Simultaneously, version compatibility issues are handled through a protocol abstraction layer: for example, when an older Modbus RTU protocol (v1.3) is identified, the abstraction layer converts its 32-bit floating-point encoding to IEEE 754 intermediate format, then encapsulates it into the standard opcode 0x57, and appends a <protocol version=v1.3, dependency library=float_converter_v2> identifier chain to the opcode metadata area. To reduce communication overhead, space optimization is performed after instruction set generation, employing opcode multiplexing compression algorithms and field simplification techniques to reduce the size of a typical Modbus instruction set. Furthermore, a prefetch caching mechanism preloads the compressed instruction set into the shared memory area of ​​edge nodes, ensuring that instructions can be invoked immediately during protocol switching.

[0063] Dynamic resource adjustment is implemented throughout the entire instruction set generation lifecycle: When the protocol parsing and execution module detects a sudden surge in traffic, it sends a resource expansion request to the resource scheduler in real time. Based on a preset elastic scaling strategy, the scheduler allocates additional computing units from the backup resource pool within 20ms, while the instruction compression algorithm simultaneously switches to a low-complexity mode to maintain the processing throughput of edge nodes within the preset SLA range. When the protocol version is updated, the system dynamically updates the mapping template of the rule engine through a hot-patching mechanism, a process that does not interrupt ongoing communication sessions.

[0064] The protocol conversion intermediate layer encapsulates the instruction set into standardized data frames and monitors changes in the communication link status. If a protocol switching characteristic signal is detected, the incremental update mechanism of the protocol characteristic library is triggered, the new protocol execution module is loaded, and the communication channel is switched.

[0065] In this embodiment, the protocol conversion intermediate layer adopts a layered architecture to achieve the dual functions of instruction set encapsulation and protocol monitoring. The standardized data frame encapsulation process first performs instruction translation through the protocol abstraction engine: the generated communication instruction set is injected into the intermediate representation layer (IR layer). The IR layer adds a protocol version identifier and dependency chain to each opcode based on a unified metadata annotation specification. The translation process applies an instruction compression algorithm to optimize transmission efficiency, compresses high-frequency opcodes through Huffman coding, and uses field simplification technology to remove default value parameters, reducing the size of a typical instruction set. The compressed instruction stream is encapsulated into standardized data frames by the frame assembler. The frame structure includes a fixed-format frame header, payload area, and extended metadata area. The encapsulation process embeds real-time integrity verification, which is performed by a hardware-accelerated CRC calculation unit. Abnormal frames automatically trigger a local retransmission mechanism.

[0066] The communication link status monitoring mechanism is implemented through a distributed probe network, with probes deployed at the physical layer driver interface and various layers of the protocol stack. The monitoring strategy employs multimodal signal fusion analysis: real-time capture of signal characteristic changes at the physical layer, monitoring of handshake timeout events at the link layer, and detection of abnormal data packet patterns at the application layer. Protocol switching characteristic signal identification is based on a dynamic threshold model: when the physical layer bit error rate exceeds a certain threshold for three consecutive samples... When the application layer handshake response delay exceeds 200% of the historical baseline, or when a specific abnormal packet sequence occurs, it is determined to be a protocol switching characteristic signal. The detection result is pushed to the incremental update controller in real time via the event bus, and the time delay for triggering the update process is controlled within 5ms.

[0067] After the incremental update mechanism of the protocol feature library is activated, the difference comparison operation is first performed within the security sandbox of the edge node. The security sandbox constructs a trusted execution environment through a memory isolation mechanism to prevent malicious protocol injection. The difference comparison algorithm adopts a fast matching model based on hash vectors: the feature identifier of the new protocol (e.g., a 128-bit feature vector) is divided into 16 8-bit hash segments, which are compared in parallel with the hash vectors of the protocol templates in the feature library. The comparison process calculates the Hamming distance and generates a difference vector. When the difference vector is non-zero, the feature extraction stage begins. The extraction of the new feature set uses a syntax tree difference algorithm to parse the protocol syntax tree from the original data stream, compare the tree structure with the feature library template, and identify the new syntax nodes and their associated fields. The extracted new feature set is normalized to form an incremental feature vector.

[0068] The feature library update process employs a version control tree management mechanism, automatically creating a snapshot of the current template before each update. New protocol templates are injected into the feature library via pre-compiled binary loading technology, with conflict detection performed before loading: comparing the similarity between the new template and existing templates (a conflict is identified when the weighted Euclidean distance is greater than 0.8). Conflict resolution uses a three-level priority strategy: templates signed by device manufacturers have the highest priority (P0 level), followed by templates with a historical usage frequency greater than 20% (P1 level), and finally, new detection templates (P2 level). When a new template conflicts with a P0 level template, the old template is automatically retained, and the new template is marked as "pending verification." In non-conflict scenarios, templates are directly merged, with a feature vector weighted fusion algorithm applied during the merging process. Each update generates a new version with a timestamp, while the three most recent historical versions are retained in non-volatile memory, supporting second-level rollback operations in abnormal situations.

[0069] The loading of the new protocol execution module is implemented based on a lightweight containerized architecture. The container image is pre-installed in the read-only memory of the edge node, and the binary file is directly mounted during loading using memory mapping technology, avoiding disk I / O latency. The module startup process is optimized using pre-compiled entry point technology: the addresses of key functions are pre-written into registers, reducing the module initialization time to less than 8ms. Hot-swap switching uses dual-channel buffering technology: a circular queue buffer is deployed in the protocol stack driver layer, allowing the old protocol channel and the new protocol channel to run in parallel. During the switching transition, a traffic shaping algorithm is used to smoothly migrate the data flow: within the first 50ms, the traffic of the old protocol channel is reduced from 100% to 20% using a linear decay strategy, while the traffic of the new protocol channel is increased from 20% to 100%, with a dual-write mechanism to ensure zero data loss during this period. Queue management uses a timestamp alignment module to solve timing misalignment problems, ensuring the continuity of application layer data. Feedback data generated throughout the switching process is input into the online learning module in real time, which uses a stochastic gradient descent algorithm to dynamically adjust the feature library template weights.

[0070] The above mechanism achieves end-to-end protection through a resource monitoring agent: reserving resources during incremental updates. The system allocates CPU buffer resources and automatically triggers memory compression when container memory usage exceeds a threshold; the circular queue of the dual-channel buffer dynamically expands. The final protocol switching process meets the real-time adaptive requirements of high-reliability systems in industrial scenarios. After protocol switching is complete, the system automatically initiates health monitoring, continuously tracking key indicators such as the bit error rate and throughput of the new protocol channel to provide data for the next protocol adaptation.

[0071] Example 2: Figure 2 As shown, the present invention provides a multi-protocol communication system for intelligent converged terminals based on edge computing, comprising:

[0072] Data acquisition module 1: The intelligent fusion terminal deploys a protocol adaptive engine at the edge node to collect the raw data stream of the communication link in real time.

[0073] Protocol identification module 2 extracts protocol feature identifiers from the original data stream through the dynamic protocol feature code parsing module, performs fuzzy matching with the pre-stored communication protocol feature library, and identifies the current communication protocol type.

[0074] The instruction generation module 3, based on the protocol type identification result, calls the edge node resources to dynamically load the corresponding protocol parsing and execution module, and generates a communication instruction set adapted to the target protocol.

[0075] Protocol conversion module 4 encapsulates the instruction set into standardized data frames through the protocol conversion intermediate layer. At the same time, it monitors changes in the communication link status. If a protocol switching characteristic signal is detected, it triggers the incremental update mechanism of the protocol characteristic library, loads the new protocol execution module, and switches the communication channel.

[0076] Obviously, those skilled in the art can make various modifications and variations to this invention without departing from its spirit and scope. Therefore, if these modifications and variations fall within the scope of the claims of this invention and their equivalents, this invention also intends to include these modifications and variations.

Claims

1. A multi-protocol communication method for intelligent fusion terminals based on edge computing, characterized in that, The method includes: The intelligent converged terminal deploys a protocol adaptive engine at the edge node to collect the raw data stream of the communication link in real time; The dynamic protocol feature code parsing module extracts the protocol feature identifiers from the original data stream and performs fuzzy matching with the pre-stored communication protocol feature library to identify the current communication protocol type. The fuzzy matching process includes: The dynamic protocol signature parsing module extracts features from the collected raw data stream in real time, generating feature identifiers that include protocol header format, control field sequence, and data packet length distribution. The feature identifier is compared with a pre-stored communication protocol feature library to perform multi-dimensional similarity calculation. The multi-dimensional similarity calculation is based on a preset matching threshold range. A sliding window mechanism is used to traverse the protocol templates in the feature library to identify the maximum similarity value between the feature identifier and the template. When the similarity value exceeds the dynamic threshold, it is determined that the protocol type is successfully matched; otherwise, the dynamic expansion mechanism of the feature library is triggered to introduce a backup protocol template for secondary matching. Based on the protocol type identification result, the corresponding protocol parsing and execution module is dynamically loaded by calling the edge node resources to generate a communication instruction set adapted to the target protocol; The process of generating the communication instruction set includes: Based on the protocol type identification results, computing resources are dynamically allocated through the resource scheduler of the edge node, and the corresponding protocol parsing and execution module is loaded. The protocol parsing and execution module performs structured parsing of the original data stream and extracts key instruction fields according to the syntax rules and semantic constraints of the target protocol; When generating communication instruction sets, a rule engine is used to map the parsed fields to standard opcode sequences, and a protocol version compatibility layer is introduced to adapt and convert older protocols. The protocol conversion intermediate layer encapsulates the instruction set into standardized data frames and monitors changes in the communication link status. If a protocol switching characteristic signal is detected, the incremental update mechanism of the protocol characteristic library is triggered, the new protocol execution module is loaded, and the communication channel is switched.

2. The multi-protocol communication method for intelligent fusion terminals based on edge computing as described in claim 1, characterized in that, The multi-dimensional similarity calculation adopts the weighted Euclidean distance algorithm, wherein the weight factor is dynamically adjusted according to the priority of the feature identifier, and the priority is determined by the stability index of the feature in historical communication. The sliding window mechanism, combined with time series analysis, segments the data stream and applies an adaptive matching strategy within each window, including downsampling of low-frequency protocols and feature enhancement of high-frequency protocols. When a match fails, the dynamic expansion mechanism calls the cached resources of the edge node to load the new protocol template.

3. The multi-protocol communication method for intelligent fusion terminals based on edge computing as described in claim 1, characterized in that, The resource scheduler adopts an elastic allocation strategy based on load prediction. The prediction model is trained using historical communication data and dynamically adjusts the CPU and memory resources of edge nodes according to protocol complexity. The rule engine incorporates context-aware technology, integrates environmental variable factors, including link latency and device status, into the instruction mapping process, and automatically injects fault-tolerant instructions when generating instruction sets. The protocol version compatibility layer is implemented through the protocol abstraction layer, which converts the private fields of the old protocol into an intermediate representation format and then encapsulates them into standard opcodes to avoid instruction conflicts caused by protocol fragmentation.

4. The multi-protocol communication method for intelligent fusion terminals based on edge computing as described in claim 3, characterized in that, The fault-tolerant instruction generation adopts a reinforcement learning model, which is trained based on real-time link quality feedback and dynamically generates retransmission mechanisms and timeout control instructions. The protocol abstraction layer introduces a metadata annotation mechanism to attach a protocol version identifier and dependency relationship to each opcode.

5. The multi-protocol communication method for intelligent fusion terminals based on edge computing as described in claim 1, characterized in that, The incremental update mechanism of the protocol feature library includes: The protocol conversion intermediate layer continuously monitors changes in the communication link status. When a protocol switching characteristic signal is detected, an incremental update mechanism is triggered to extract the feature identifier of the new protocol, compare it with the feature library, and identify the newly added feature set. Based on the comparison results, the protocol templates of the feature library are updated incrementally. The update process includes template merging and conflict resolution. Simultaneously, new protocol execution modules are dynamically loaded, and communication channels are switched using hot-swapping technology.

6. The multi-protocol communication method for intelligent fusion terminals based on edge computing as described in claim 5, characterized in that, The difference comparison uses a difference vector-based algorithm, where the vector is composed of the hash value of the feature identifier. The comparison process is performed within the security sandbox of the edge node to prevent malicious protocol injection. The conflict resolution application priority strategy retains historical protocol templates as backups, and new templates are managed through a version control tree, supporting rollback operations. The hot-plug technology is combined with a lightweight containerized architecture, which reserves cache resources when loading new modules and uses dual-channel buffering technology for module switching.

7. The multi-protocol communication method for intelligent fusion terminals based on edge computing as described in claim 6, characterized in that, The dual-channel buffering technology adopts a circular queue design, with the old channel and the new channel running in parallel. Queue management is based on a flow shaping algorithm to smoothly switch data streams. The containerized architecture optimizes module loading time and reduces startup latency through pre-compiled binaries; Meanwhile, the incremental update mechanism integrates an online learning module, using feedback data during the switching process to train the template weights of the feature library, thereby improving the accuracy of protocol detection.

8. A multi-protocol communication system for intelligent converged terminals based on edge computing, characterized in that, The system is used to implement the edge computing-based intelligent fusion terminal multi-protocol communication method as described in any one of claims 1 to 7, including: The data acquisition module, with the intelligent fusion terminal deploying a protocol adaptive engine at the edge node, collects the raw data stream of the communication link in real time; The protocol identification module extracts protocol feature identifiers from the raw data stream through the dynamic protocol feature code parsing module, performs fuzzy matching with the pre-stored communication protocol feature library, and identifies the current communication protocol type. The instruction generation module, based on the protocol type identification result, calls the edge node resources to dynamically load the corresponding protocol parsing and execution module, and generates a communication instruction set adapted to the target protocol; The protocol conversion module encapsulates the instruction set into standardized data frames through the protocol conversion intermediate layer. At the same time, it monitors changes in the communication link status. If a protocol switching characteristic signal is detected, it triggers the incremental update mechanism of the protocol characteristic library, loads the new protocol execution module, and switches the communication channel.

Images