Unified management method for multi-modal entities and heterogeneous messages

Abstract

This invention discloses a unified management method for multimodal entities and heterogeneous messages, comprising: receiving raw entity messages reported by heterogeneous protocol channels; performing semantic mapping and component assembly on the raw entity messages based on a pre-configured semantic anchor dictionary to obtain candidate component state objects; for multiple candidate component state objects generated by the same entity within a preset time window, performing state conflict adjudication based on multi-dimensional adjudication priority to generate a unified entity snapshot; extracting entity business feature parameters and network link feature parameters based on the unified entity snapshot, calculating a comprehensive score for each candidate protocol channel in conjunction with the pre-acquired service instance health status, and generating a channel scheduling strategy for the entity. This invention effectively overcomes state timing conflicts under high-frequency concurrency, realizes adaptive network channel governance driven by business state, and improves the overall robustness of the system.

Description

Technical Field

[0001] This invention belongs to the field of distributed systems and Internet of Things data processing, and in particular, it is a unified management method for multimodal entities and heterogeneous messages. Background Technology

[0002] With the large-scale collaborative application of heterogeneous entities such as drones, unmanned ships, radar, and algorithm models, the system needs to access and manage a massive number of multi-source devices in real time. Building an underlying architecture that can simultaneously support multiple types of underlying communication protocols and ensure stable transmission of high-frequency streaming data and low-frequency control commands is the technological cornerstone for realizing cross-domain multimodal entity collaborative operations, automatic task orchestration, and status monitoring.

[0003] Current mainstream management solutions typically deploy independent data acquisition and service processing links for specific communication protocols. When faced with large-scale heterogeneous device access, existing systems mostly use conventional protocol conversion gateways for direct translation of data formats and rely on basic service registration and discovery mechanisms to detect network node connectivity. However, in complex, high-frequency concurrent communication scenarios, this parallel and independent link architecture struggles to effectively address data consistency issues caused by network jitter and packet latency. Furthermore, the system often fails to accurately perceive the actual freshness and validity of application-layer data, leading to a disconnect between network channel resource allocation mechanisms and actual business requirements.

[0004] In summary, existing methods still fall short in terms of system robustness and adaptive governance capabilities under complex operating conditions when dealing with multi-source, heterogeneous, high-frequency concurrent data. Therefore, there is an urgent need to investigate a method that can effectively improve data consistency across network links and the adaptability of underlying communication scheduling to meet the reliable management requirements of large-scale entities. Summary of the Invention

[0005] The purpose of this invention is to provide a unified management method for multimodal entities and heterogeneous messages, so as to solve the above-mentioned problems existing in the prior art.

[0006] The technical solution, a unified management method for multimodal entities and heterogeneous messages, includes:

[0007] Receive raw entity messages reported by heterogeneous protocol channels;

[0008] Based on a pre-configured semantic anchor dictionary, semantic mapping and component assembly are performed on the original entity message to obtain candidate component state objects;

[0009] For a predetermined number of candidate component state objects generated by the same entity within a preset time window, state conflict adjudication is performed based on multi-dimensional adjudication priority to generate a unified entity snapshot;

[0010] Based on the unified entity snapshot, entity business feature parameters and network link feature parameters are extracted. Combined with the pre-acquired service instance health status, the comprehensive score of each candidate protocol channel is calculated to generate a channel scheduling strategy for the entity.

[0011] Beneficial effects: This invention effectively overcomes state timing conflicts under high-frequency concurrency, realizes adaptive governance of network channels driven by reverse business state, and improves the overall robustness of the system. Attached Figure Description

[0012] Figure 1 This is a flowchart illustrating the steps of a unified management method for multimodal entities and heterogeneous messages provided in an embodiment of this application.

[0013] Figure 2 A flowchart illustrating the steps for obtaining a candidate component state object as provided in this application embodiment.

[0014] Figure 3 A flowchart illustrating the steps for generating a unified entity snapshot as provided in this application embodiment.

[0015] Figure 4 A flowchart illustrating the steps for generating a channel scheduling strategy for an entity, as provided in this application embodiment.

[0016] Figure 5 This is an architecture diagram of a unified management method for multimodal entities and heterogeneous messages provided in an embodiment of this application. Detailed Implementation

[0017] To enable those skilled in the art to better understand the present invention, the technical solutions of the present invention will be clearly and completely described below with reference to the accompanying drawings of the embodiments of the present invention. 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 should fall within the scope of protection of the present invention.

[0018] It should be noted that the terms "first," "second," etc., used in this invention are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of the invention described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "including" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that includes a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0019] like Figure 1 As shown, the unified management method for multimodal entities and heterogeneous messages includes the following steps:

[0020] Receive raw entity messages reported from heterogeneous protocol channels.

[0021] In this embodiment, a communication middleware access layer is deployed at the system's bottom layer to interface with heterogeneous network data streams from physical sensors or edge computing nodes. Specifically, the heterogeneous protocol channels include DDS (Data Distribution Service) and MQTT (Message Queuing Telemetry Transport) channels for high-frequency telemetry, gRPC (Remote Procedure Call) channels for strongly typed microservice calls, HTTP (Hypertext Transfer Protocol) channels for lightweight access, and local controller channels for directly reading the physical motherboard status. Raw entity messages refer to unformatted and semantically aligned underlying network data packets directly received by the aforementioned channels. For example, for an accessing drone entity, the raw entity message it sends via 5G or a radio station may be represented as a Binary Interface Definition Language (IDL) structure distributed under a DDS topic, or a Lightweight Data Exchange (JSON) format payload received by the MQTT broker. After the system's network interface card (NIC) captures these data packets, the corresponding communication proxy module performs protocol offloading to restore the original fields carrying device parameters and service characteristics.

[0022] It should be noted that the communication protocol types mentioned above are merely illustrative examples. Heterogeneous protocol channels are not limited to the specific protocols listed above, and may also include other communication protocol channels that meet heterogeneous access requirements.

[0023] Based on a pre-configured semantic anchor dictionary, semantic mapping and component assembly are performed on the original entity message to obtain candidate component state objects.

[0024] Specifically, due to differences in field naming and data types when describing the same physical state across different entities and protocols (e.g., the DDS protocol might use `position.latitude` to represent latitude, while the HTTP protocol might use `location.lat`), a semantic anchor dictionary is pre-loaded in memory to eliminate this heterogeneity. During semantic mapping, the system maps various scattered fields from the original entity message to standard semantic items according to the unified rules defined in the dictionary. Component assembly refers to writing the mapped standard semantic items into predefined functional components according to a preset structural template. Functional components typically include location, health, power, online status, and tasks. After writing, structured object instances, i.e., candidate component state objects, are generated in system memory. The candidate component state objects initially normalize heterogeneous data, but in high-frequency concurrency scenarios, they only represent local state observations of a certain channel at a certain moment and require further fusion and adjudication.

[0025] For a predetermined number of candidate component state objects generated by the same entity within a preset time window, state conflict adjudication is performed based on multi-dimensional adjudication priority to generate a unified entity snapshot.

[0026] In this embodiment, in a network environment where multiple protocols coexist, the same entity often reports its status simultaneously or alternately through multiple links. For example, when a drone is performing a mission, its location information may be sent simultaneously through a DDS multicast link and an MQTT backup link. Due to network jitter and routing differences, the server will receive multiple candidate component status objects for the same entity within a preset time window. To ensure the uniqueness and consistency of the digital twin state, the processor compares and eliminates multiple candidate component status objects according to a preset multidimensional decision priority. The multidimensional decision priority typically considers the logical version of the data, the physical generation time, the reliability of the transmission channel, and the urgency of the current business stage of the entity. The data of the winning object after decision is merged and written into a central cache or in-memory database, forming a unified entity snapshot of the entity. As the only trusted current state record in the system, the unified entity snapshot supports multi-threaded secure reading, ensuring the spatiotemporal consistency of subsequent task orchestration and status monitoring.

[0027] Based on the unified entity snapshot, entity business feature parameters and network link feature parameters are extracted. Combined with the pre-acquired service instance health status, the comprehensive score of each candidate protocol channel is calculated to generate a channel scheduling strategy for the entity.

[0028] Alternatively, based on a unified entity snapshot, entity business feature parameters are extracted, and network link feature parameters corresponding to heterogeneous protocol channels are obtained. Combined with the pre-obtained service instance health status, a comprehensive score of each candidate protocol channel in the heterogeneous protocol channel is calculated, and a channel scheduling strategy for the entity is generated.

[0029] Specifically, after obtaining a reliable entity status, the system further performs reverse communication governance. The processor extracts entity business characteristic parameters representing the operational status of the business and network link characteristic parameters representing network transmission quality from a unified entity snapshot. Simultaneously, it obtains the health status of service instances detected by the underlying network node probes by connecting to the service registry. When calculating the comprehensive score, the aforementioned multi-dimensional parameters spanning the business domain, network domain, and infrastructure domain are converted into normalized values ​​under the same dimension and then weighted and fused. The calculated comprehensive score intuitively reflects the applicability of each candidate protocol channel in the current business scenario. A corresponding channel scheduling strategy is generated based on the comprehensive score. The channel scheduling strategy manifests as control instructions issued to the underlying communication agent, instructing the agent to take actions such as switching to the optimal channel, reducing the transmission frequency, or performing batch packaging for the data flow of that entity, thereby achieving dynamic backpressure governance and quality of service (QoS) assurance in complex communication environments.

[0030] Furthermore, after completing the above processing, the system will persistently write the structured metadata and relational attributes in the unified entity snapshot into the relational database, and persistently write the frequently changing telemetry component data into the time series database, so that upper-layer applications can perform long-term historical trajectory playback, fault tracing and statistical analysis, forming a complete data observability closed loop.

[0031] This embodiment provides an end-to-end comprehensive platform environment to solve the problem of unified management difficulties caused by the large-scale deployment of heterogeneous entities such as drones, unmanned ships, radar, video cameras and algorithm models, due to the diversity of communication protocols, fragmented data structures and insufficient service availability.

[0032] In one possible implementation, the pre-configured semantic anchor dictionary is obtained in the following way:

[0033] Obtain the protocol field path corresponding to each heterogeneous protocol channel;

[0034] For each semantic item in a unified semantic item set, establish at least one mapping record to map the predetermined protocol field paths with the same logical meaning to the corresponding semantic item;

[0035] Each semantic item is bound to the standard data type, valid value range, and default value for missing values ​​of the corresponding target component, resulting in a pre-configured semantic anchor dictionary.

[0036] In this embodiment, before the system officially receives the real-time data stream, the processor offline constructs a pre-configured semantic anchor dictionary in non-volatile storage media based on the pre-acquired communication interface protocol specifications of various heterogeneous middleware. The semantic anchor dictionary is a global configuration table, loaded into memory during system startup, used to uniformly map heterogeneous field names from different protocols to standard semantic items. Each mapping record in the pre-configured semantic anchor dictionary includes a unique semantic anchor identifier, readable name, target component, standard data type, standard unit, valid value range, required attributes, default values ​​for missing fields, and the actual field path mapping table for that semantic item under each protocol. By introducing a structure where the same anchor record contains multiple protocol field paths, it supports the normalization of multi-source inputs to the same semantic item and automatically performs out-of-bounds checks and default value supplementation during the parsing process.

[0037] Specifically, the pre-configured semantic anchor dictionary contains several typical anchor entries. Taking the semantic anchor representing latitude as an example, its unique identifier is defined as LOC_LAT, the target component is bound to the location component, the standard data type is set to FLOAT64 (64-bit floating-point number) format, the unit is set to degrees, the valid value range is limited to greater than or equal to -90.0 and less than or equal to 90.0, the required field attribute is set to true, and the default value is set to empty. In the actual field path mapping table of this anchor, for the DDS channel, its path is configured as position.latitude and the primitive type is double (double-precision floating-point number); for the MQTT channel, the path is configured as loc.lat and the primitive type is number (number type); for the gRPC channel, the path is configured as gps_position.lat_deg; for the HTTP channel, the path is configured as location.latitude. And so on, the semantic anchor representing longitude is identified as LOC_LNG, and the valid value range is limited to greater than or equal to -180.0 and less than or equal to 180.0. The semantic anchor for altitude is LOC_ALT, with the unit set to meters, and a default value of 0.0. The semantic anchor for battery percentage is PWR_BATTERY, with the target component bound to the power component, and a valid value range limited to greater than or equal to 0.0 and less than or equal to 100.0. The semantic anchor for device online status is ONL_STATUS, with the standard data type being an enumeration, and a valid value range including online, offline, and unknown states, with a default value of unknown. The semantic anchor for device alarm codes is HLT_ERROR_CODE, with a valid value range limited to greater than or equal to 0 and less than or equal to 65535. The semantic anchor for task phase is TSK_PHASE, with the target component bound to the task component, and a valid value range including standby, executing, returning to base, fault handling, and offline maintenance.

[0038] Furthermore, when establishing mapping records, if the unit of the raw data reported by a certain protocol is inconsistent with the standard unit, the processor will additionally mark the conversion rule in the actual field path mapping table. For example, if the heading angle data reported by a certain protocol is expressed in radians, the system will add a radian-to-degree conversion rule identifier to the corresponding path configuration for execution during the online parsing phase. Similarly, if the raw value of the battery level reported by the MQTT channel is a decimal greater than or equal to 0.0 and less than or equal to 1.0, the processor will mark a conversion rule of multiplying by 100 to match the standard unit percentage.

[0039] like Figure 2 As shown, according to one aspect of this application, a candidate component state object is obtained, including:

[0040] Perform field parsing on the original entity message to extract the entity identifier field, source channel field, and business status field.

[0041] Alternatively, it can be described as performing field parsing on the original entity message to extract the entity identifier field, message time field, source channel field, and business status field.

[0042] In this embodiment, during the real-time online operation phase of the system, when the communication middleware receives network data packets, the processor immediately performs unpacking and deserialization processing on the original entity messages according to the decoding rules of the corresponding protocol, extracting the entity identifier field used to maintain the lifecycle, the message time field used to record the generation time, the source channel field indicating the data access link, and the service status field containing specific physical measurement values ​​or control status.

[0043] Based on the pre-configured semantic anchor dictionary, and combined with the entity identifier field and the source channel field, the business status field is mapped to a unified set of semantic items.

[0044] Specifically, after extracting the business status field, the processor queries the pre-configured semantic anchor dictionary in memory using the entity identifier field and the source channel field as search conditions. The system traverses the matched actual field paths and extracts the corresponding original business values. The processor performs type conversion according to the standard data types and conversion rules bound in the dictionary, and performs out-of-bounds checks using the set valid value range. For data that meets the constraints, its conversion result, along with its corresponding semantic anchor unique identifier, is packaged together to generate a unified semantic item set. For data that fails the out-of-bounds check, the system intercepts it at the entry point or marks it as abnormal to avoid polluting subsequent business logic. In addition, if a protocol does not provide a field corresponding to a required field, the processor automatically fills in the preset data according to the default value rules configured in the dictionary, or marks the data as incomplete.

[0045] According to the preset component assembly rules, the unified semantic item set is written into the component set that matches the corresponding entity type to obtain the candidate component state object.

[0046] Alternatively, the entity type is determined based on the entity identifier field. Combined with the preset component assembly rules, the unified semantic item set is written into the component set that matches the corresponding entity type, and the entity identifier field, message time field, and source channel field are associated with the candidate component status object.

[0047] In this embodiment, after obtaining a standardized set of unified semantic items, the processor queries preset component assembly rules based on the specific type of the entity. Based on this, each data item in the unified semantic item set is distributed and loaded into the various functional components enabled by the entity.

[0048] In a preferred implementation, the set of components matching the corresponding entity type includes at least:

[0049] Location component used to record the geospatial location of an entity;

[0050] A health component used to record the health status consisting of device alarm codes and service reachability;

[0051] An online component used to record the online status of a device;

[0052] A power supply component used to record power data;

[0053] A task component used to record the list of activity tasks and stage identifiers.

[0054] Furthermore, during write operations, to address memory access conflicts caused by high-concurrency data streams, the processor utilizes mutexes and multi-threaded synchronization mechanisms to protect each component instance. After the loading operation is completed, the processor instantiates candidate component state objects in dynamic memory. It should be noted that the candidate component state objects at this point only reflect a snapshot of the observations from a single data source at a specific moment, and have not yet been merged and adjudicated based on time-series and reliability dimensions with data reported from other channels.

[0055] Optionally, in some edge computing nodes with extremely high performance requirements and relatively fixed entity types, the offline configuration process can be further staticized by hardcoding the pre-configured semantic anchor dictionary into a static mapping table at compile time, thereby omitting the runtime dictionary lookup overhead and improving the generation efficiency of candidate component state objects.

[0056] In one exemplary embodiment, the preset component assembly rules are constructed in the following manner:

[0057] A configuration matrix is ​​constructed based on preset entity types and component types;

[0058] In the configuration matrix, the enabling status of the corresponding components and the set of semantic items to be associated are configured for each entity type;

[0059] Configure the expected update frequency for components that are enabled as required or optional, and obtain the preset component assembly rules.

[0060] Specifically, after dictionary construction, the processor further constructs pre-defined component assembly rules offline. The component assembly rules are represented as a two-dimensional configuration matrix with entity types as rows and component types as columns. Each cell in the configuration matrix records three attribute data points: whether the component is enabled for that entity type, the set of semantic anchors required by the component, and the expected update frequency of the component. The expected update frequency is subsequently extracted for calculating the time window and data freshness.

[0061] For example, for the drone entity type, the processor configures the activation status of its location component as mandatory in the configuration matrix, and configures the required semantic anchor point set to include latitude, longitude, altitude, and heading angle, with an expected update frequency set to 1.0 to 10.0 Hz; it also configures the activation status of its health component as mandatory, with the required semantic anchor point including device alarm codes; and it configures the activation status of its power component, online component, and task component as mandatory, binding the corresponding semantic anchor points and expected update frequencies respectively. Conversely, for the camera entity type, considering that fixed network cameras typically use AC power, the processor configures the activation status of its power component as disabled in the configuration matrix; it configures the activation status of its location component as optional; and it enables a unique video stream status component for it, with the required semantic anchor point set including stream output address, encoding format, and resolution, and the expected update frequency set to event-driven update.

[0062] This embodiment solves the problem of data structure fragmentation caused by multi-source heterogeneous protocols by constructing dictionaries and matrices offline and performing parsing and assembly online, and realizes the normalization transformation from underlying network data to the state of digital twin entities.

[0063] According to another aspect of this application, the candidate component state object is obtained in the following way:

[0064] Obtain a pre-built component projection template as a pre-configured semantic anchor dictionary. The component projection template includes field path definitions and type conversion rules for each entity type.

[0065] In this embodiment, in specific industrial control or edge computing environments, the types of devices accessed by the system are often highly deterministic. To reduce runtime addressing overhead, the system visualizes the pre-configured semantic anchor dictionary as a series of independent configuration files, i.e., component projection templates, during the initialization phase. The processor pre-creates one or more component projection templates for each entity type. The component projection template not only includes field path definitions for locating the original data extraction position but also includes type conversion rules for constraining data format.

[0066] Specifically, the component projection template can further include default value filling rules, exception field discarding rules, and component write location definitions. Through the templated data structure, the system can provide customized parsing logic for different types of entities. For example, for fixed-wing UAVs and multi-rotor UAVs, the system can create independent position parsing templates respectively. The template for fixed-wing UAVs includes extraction path definitions for airspeed and angle of attack, while the template for multi-rotor UAVs only configures extraction rules for hovering state.

[0067] Field extraction is performed on the original entity message according to the component projection template of the corresponding entity type, and the extracted content is converted into standard data format according to the type conversion rules.

[0068] Specifically, when the underlying communication agent receives the original entity message from a certain entity, the processor reads the device type identifier in the message packet header and loads the matching component projection template into memory accordingly. The processor parses the component projection template and, according to the field path definitions recorded therein, directly performs byte offset or key value read operations on the payload portion of the original entity message to complete field extraction. After the extraction operation is completed, the processor calls the type conversion rules declared in the component projection template to process the target data. For example, if the original temperature data extracted through the underlying communication protocol is in 16-bit integer format, while the system's internal standard data format is 32-bit floating-point, the processor will execute the corresponding floating-point type conversion instruction. During the conversion process, if the processor detects that the original field is missing, it will trigger the preset default value filling rule to assign a safe initial value to the field; if it detects that the extracted value exceeds the physically reasonable range, the processor will terminate the subsequent transmission operation of the field according to the abnormal field discarding rule. By directly executing the matching and conversion based on the template, the intermediate process of multi-level dictionary hash lookup is avoided, and data cleaning and standardization can be completed with extremely low instruction cycles.

[0069] The converted field values ​​are directly written to the component that matches the entity type to obtain the candidate component state object.

[0070] In this embodiment, after completing field extraction and type conversion, the processor bypasses the step of generating an intermediate semantic item set and directly initiates a memory write operation based on the component write location definition set in the component projection template. Specifically, the processor calculates the address offset of the target component in the system memory model and uses a memory copy instruction to overwrite the converted field values ​​into the corresponding physical address of the component matching the entity type. After the write operation is completed, the system instantiates a candidate component state object in dynamic memory. The candidate component state object contains complete and compliant observation data of the entity within the current sampling period. The generated candidate component state object is submitted to the subsequent conflict resolution module for multi-dimensional merging and elimination of data generated by the system and other channels. Through template-projected entity state objects, effective decoupling of the entity access module is achieved while maintaining consistency between the final output interface and the core data flow.

[0071] In some optional implementations, for server devices equipped with hardware acceleration modules, the processor can invoke the underlying driver to compile the component projection template into a field-programmable gate array (FPGA) or application-specific integrated circuit (ASIC) hardware execution logic. Under the hardware acceleration architecture, field extraction, type conversion, and direct memory write operations for the original entity message are completed at the firmware layer of the network interface card, reducing system data access latency. Furthermore, when the system needs to be compatible with new unregistered entities, the processor can listen for configuration update events and inject new component projection templates into memory via hot loading, enabling rapid device expansion without modifying existing business orchestration logic.

[0072] This embodiment illustrates a lightweight mapping and writing method for directly mapping from raw messages to entity components by replacing the global semantic anchor dictionary with a preset component projection template in application scenarios with limited resources or fixed entity types. This effectively reduces the computational overhead of dynamic dictionary lookups and provides a more intuitive and easily implementable alternative path.

[0073] like Figure 3 As shown, in one embodiment of this application, generating a unified entity snapshot includes:

[0074] For a predetermined number of candidate component state objects, the comparison and decision are made step by step according to a preset priority chain. If a winning object is determined at the current priority, the subsequent comparisons are terminated.

[0075] In this embodiment, within a unified network architecture, the same entity may send status updates to the server through different heterogeneous protocol channels within a preset time window. To avoid resource contention and dirty write issues during data processing, the processor extracts multiple candidate component status objects belonging to the same entity from memory and executes short-circuit evaluation logic.

[0076] Specifically, the processor filters each object level by level based on its built-in rule engine. If a unique valid object has been calculated under a higher priority rule, the processor immediately discards the remaining objects and skips the comparison instructions at subsequent levels; the processor only activates the comparison logic at the next level when multiple objects with the same score or when the corresponding fields are all missing under a higher priority rule.

[0077] The priority chain, from high to low, is as follows: compare the entity version number carried by each candidate component state object; compare the original message timestamp of each candidate component state object; compare the source trust level of the source protocol channel corresponding to each candidate component state object; and compare the sensitivity of the current task stage of the entity to which each candidate component state object belongs to the communication reliability.

[0078] Preferably, the entity version number is a monotonically increasing identifier carried by the candidate component state object from the data source; the current task stage is extracted from the task component of the candidate component state object.

[0079] Specifically, when the processor performs the first priority comparison, it extracts the entity version number carried by each object. The entity version number is monotonically incremented by the entity management service with each write operation. If the entity version number of an object is numerically greater than the entity version numbers of other objects, the processor determines that object wins. If the entity version numbers are the same or both are missing, the processor moves to the second priority and extracts the original message timestamp marked by the sender for comparison. For example, the processor sets a clock tolerance threshold of 50 milliseconds. If the difference between the timestamps of two objects is less than or equal to 50 milliseconds, the processor considers them to have the same timestamp and moves to the third priority; otherwise, the processor determines that the object with the newer timestamp wins. It should be noted that the specific value of the clock tolerance threshold can be adaptively adjusted according to the clock synchronization accuracy in the actual deployment environment.

[0080] Furthermore, in the third priority level, the processor extracts the source trust level of the source protocol channel corresponding to each object. The processor determines that the object with the higher source trust level wins. If the source trust levels are the same, the processor enters the fourth priority level and makes a business semantic-level decision based on the current task stage of the entity. When it is detected that the entity is currently in the fault handling or execution stage, the processor prioritizes retaining candidate component state objects from the control plane channel; when it is detected that the entity is currently in the standby or offline maintenance stage, the processor prioritizes retaining candidate component state objects from the data plane channel. If multiple objects are still tied after the above four levels of comparison, the processor extracts the server's received timestamp and retains the candidate component state object with the latest arrival time from the server as the final winning object.

[0081] In one possible implementation, after comparing the original message timestamps of each candidate component state object, and before comparing the source trust level of the source protocol channel corresponding to each candidate component state object, a step of determining the source trust level is also included, specifically:

[0082] Obtain the preset static baseline trust level for each source protocol channel; calculate the message arrival rate of each source protocol channel within the preset sampling period.

[0083] In this embodiment, to support the third-priority decision-making logic, the system pre-allocates a quantified trust foundation for each channel. The processor reads the configuration file to obtain the preset static baseline trust level for each source protocol channel. The parameter of the static baseline trust level is an integer with a value range limited to 1 to 4. For example, the specific configuration can be set as follows: the static baseline trust level of the gRPC channel is 4, the static baseline trust level of the HTTP channel is 3, the static baseline trust level of the DDS channel is 3, the static baseline trust level of the MQTT channel is 2, and the static baseline trust level of the local controller channel is 1. During system operation, the processor continuously monitors network quality and, within a preset sampling period, calculates the message arrival rate of each source protocol channel by measuring the ratio of the actual number of messages received to the expected number of messages received.

[0084] When the message arrival rate is lower than the preset first threshold, the static baseline trust level is downgraded to obtain the dynamically corrected source trust level; when the message arrival rate recovers to above the preset second threshold and continues for a preset period, the dynamically corrected source trust level is restored to the static baseline trust level.

[0085] Specifically, the physical state of network links fluctuates dynamically, and a fixed baseline value cannot reflect the true channel availability. Therefore, the processor executes dynamic correction logic.

[0086] For example, a preset sampling period is set to include 10 sampling intervals, and a preset first threshold is set to 0.7. When the processor calculates that the message arrival rate of a certain channel is less than 0.7, the processor decrements the static baseline confidence level of that channel by 1, and hard-truncates the lower limit of the subtraction result to 1, obtaining the dynamically corrected source confidence level. A preset second threshold is set to 0.9, and the preset period includes 5 sampling intervals. When the processor continuously monitors that the message arrival rate of the channel is greater than or equal to 0.9, and this state is stably maintained for 5 sampling intervals, the processor clears the downgrade penalty and restores the source confidence level to the initial static baseline confidence level.

[0087] The data of the winning entity determined by the comparison are merged to generate a unified entity snapshot.

[0088] In this embodiment, after completing the priority chain calculation and filtering, the processor removes the rejected candidate component state objects from the cache queue. For the winning objects, the processor extracts the cleaned and standardized field values ​​and performs a memory merging operation.

[0089] Specifically, the processor locks the memory region corresponding to the entity in the global entity state hash table, uses a mutex lock to block other threads from writing, overwrites the data of the winning object to the target address, and releases the lock resource after the operation is completed, thereby generating a unique and thread-safe unified entity snapshot. After generation, the processor triggers an asynchronous callback mechanism to synchronously write the data of the unified entity snapshot to the backend persistent storage engine, so that external services can obtain consistent entity data through standard interfaces.

[0090] In some alternative implementations, for high-bandwidth entities containing large video streams or radar point clouds, the processor uses pointer reference substitution instead of a full memory copy when performing data merging. The processor only updates the memory address pointers to the large payloads in the unified entity snapshot, thereby reducing the CPU's bus bandwidth usage during concurrent decision-making.

[0091] This embodiment illustrates how, when multiple channels concurrently report the same entity status, the system resolves timing conflicts and state overwriting issues through a four-level priority chain and a dynamic trust level correction mechanism, thereby ensuring data consistency of the unified entity snapshot.

[0092] like Figure 4 As shown, in one embodiment of this application, generating a channel scheduling policy for an entity includes:

[0093] The entity task stage identifier and component importance identifier extracted from the unified entity snapshot are used as entity business feature parameters, and the link latency, link packet loss rate and message backlog length of the corresponding channel are extracted as network link feature parameters.

[0094] Specifically, before the system executes communication scheduling, the processor needs to acquire basic evaluation data. On one hand, the processor queries the unified entity snapshot in memory, reads the entity task stage identifier recorded in the task components, and the component importance identifiers inherent in each data component, collectively referred to as entity business characteristic parameters. Entity business characteristic parameters reflect the entity's subjective business requirements for communication quality at a specific moment. On the other hand, the processor periodically extracts objective physical indicators of the current communication channel by calling the network interface controller driver of the underlying operating system and the statistics module of the communication middleware. These include link latency calculated from the round-trip time of messages, link packet loss rate calculated from the checksum and sequence number retransmission rate, and message backlog length obtained from the sending buffer queue. These physical quantities together constitute network link characteristic parameters. It should be noted that the component importance identifier is a pre-configured identifier for each enabled component in the preset component assembly rules, used to characterize the criticality of the component to the entity's operating state.

[0095] Dimensionless normalization is performed on the entity business characteristic parameters, network link characteristic parameters, and service instance health status to obtain the normalized indicators.

[0096] In a preferred implementation, for any parameter among the network link characteristic parameters, dimensionless normalization is performed to obtain the normalized indices, which is achieved in the following way:

[0097] Obtain the observed values ​​of the parameters in the current evaluation period and the pre-set maximum allowable threshold;

[0098] Calculate the ratio of the observed value to the maximum allowed threshold;

[0099] Subtract the ratio from the value to obtain the initial difference. If the initial difference is less than zero, the corresponding normalization index is truncated to zero; if the initial difference is greater than or equal to zero, the initial difference is used as the corresponding normalization index.

[0100] In this embodiment, for each physical indicator in the network link characteristic parameters, due to their different units—for example, link latency is measured in milliseconds, link packet loss rate is a percentage, and message backlog length is the number of packets—the processor cannot directly add them together. Therefore, the processor performs dimensionless normalization processing. Taking link latency as an example, its actual calculation logic is reflected in the following formula:

[0101] q delay =max(0, 1-d) obs / d max );

[0102] Where, q delay d is the normalized latency metric. obs d represents the link delay observation.max This is a pre-set maximum allowable link latency threshold.

[0103] The processor calculates the ratio of the observed value to the threshold. By subtracting this ratio from the value, the physical quantity, which was originally better the smaller it is, is transformed into a positive index that is better the larger it is. A non-negative truncation judgment mechanism is introduced. When the observed value exceeds the maximum allowable boundary, resulting in a negative initial difference, a zero value is forcibly output, ensuring that all normalized indices are constrained within the dimensionless interval of 0 to 1.

[0104] Furthermore, in addition to network link characteristic parameters, the processor uses the same logic to perform dimensionless mapping on parameters of other dimensions, generating corresponding normalized indices. These include the state freshness index calculated by dividing the silent time by the maximum silent time threshold, and the instance health index obtained from the service registry. This unified mapping of complex parameters across different domains to an evaluation space of equal numerical scale eliminates dimensional conflicts caused by direct calculation of different physical quantities.

[0105] In a further embodiment, when the entity task stage identifier extracted based on the unified entity snapshot is used as an entity business feature parameter, it further includes:

[0106] The entity task stage identifier is mapped to a priority weight that characterizes the sensitivity to communication reliability, and is used as one of the normalization indicators in the weighted summation calculation.

[0107] In the priority weight mapping rules, the priority weight corresponding to the fault handling stage is higher than the priority weight corresponding to the execution stage, the priority weight corresponding to the execution stage is higher than the priority weight corresponding to the return stage, and the priority weight corresponding to the return stage is higher than the priority weight corresponding to the standby stage.

[0108] In this embodiment, to reflect the business-driven governance approach, the processor performs a quantitative weight mapping on the entity's business characteristic parameters. The entity's task stages are a finite discrete enumeration type, and the processor maps them to priority weights between 0 and 1, indicating the sensitivity of the current stage to the reliability of the communication link.

[0109] For example, a specific configuration could be as follows: a priority weight of 1.0 for the fault handling phase, 0.8 for the execution phase, 0.6 for the return phase, 0.3 for the standby phase, and 0.1 for the offline maintenance phase. When an entity is not bound to any specific task, the processor assigns it a default weight of 0.3 for the standby phase. Through this progressively decreasing mapping logic, entities in an emergency handling state can obtain the highest channel resource scheduling priority when network congestion occurs.

[0110] Furthermore, after obtaining the task phase priority weights, the processor also reads component importance identifiers from each functional component of the unified entity snapshot and converts these identifiers into component importance coefficients with values ​​between 0 and 1 according to a preset mapping rule. The processor then performs a weighted fusion of the task phase priority weights using these component importance coefficients; for example, it takes the arithmetic mean or weighted average of the two to obtain a comprehensive service priority value that balances communication reliability sensitivity and component criticality. This comprehensive service priority value is used as q. task It participates in subsequent weighted summation calculations.

[0111] The normalized indicators are weighted and summed according to the preset weighting coefficients to obtain the comprehensive score of each candidate protocol channel.

[0112] Specifically, after obtaining all normalized metrics, the processor calculates the overall score. Its mathematical logic is expressed by the following linear formula:

[0113] Score p =α*q delay +β*q loss +γ*q backlog +δ*q fresh +η*q health +θ*q task ;

[0114] Among them, Score p This represents the overall score for a specific channel; α, β, γ, δ, η, and θ are the preset weight coefficients for each normalized indicator, and the sum of all weight coefficients is strictly equal to 1; q delay q is the normalized time delay metric; loss q is the normalized link packet loss rate metric; backlog q is a normalized message backlog length metric. fresh q is a normalized state freshness index; health To normalize the health metric for service instances; q task The comprehensive business priority index, which comprehensively reflects the sensitivity of the entity to communication reliability and the importance of related components at the current task stage, is calculated by combining the task stage priority weight and the component importance coefficient.

[0115] For example, assume the preset weighting coefficients are 0.15, 0.15, 0.10, 0.10, 0.25, and 0.25 respectively. In a certain evaluation, the normalized latency for the MQTT channel was measured to be 0.9, the normalized packet loss rate to be 0.8, the normalized backlog length to be 1.0, the state freshness to be 0.6, and the service instance health to be 0.5. Simultaneously, the entity is in the execution phase, and the overall business priority is 0.8. The processor performs the calculation: 0.15*0.9 + 0.15*0.8 + 0.10*1.0 + 0.10*0.6 + 0.25*0.5 + 0.25*0.8, finally summing to obtain a comprehensive score of 0.74 for the channel. The processor then compares this score with the scores of other competing channels.

[0116] Identify whether the pre-stored messages to be sent are control plane messages or data plane messages, and select the channel with the highest comprehensive score from the candidate protocol channels bound to the message type as the actual sending channel, and generate a channel scheduling strategy.

[0117] In this embodiment, to prevent high-frequency state updates from crowding out critical instruction bandwidth, the system logically isolates the heterogeneous channels into control plane and data plane dual channels. When a request is received from an upper-layer application, the processor reads the message type field. If the message is identified as a task delivery, rule update, or parameter configuration, it is marked as a control plane message, and its selection is limited to the HTTP channel and gRPC channel, choosing the channel with the highest overall score as the actual sending channel. If the message is identified as a location telemetry, radar measurement, or event-aware stream, the processor marks it as a data plane message, limiting its selection to the DDS channel and MQTT channel, choosing the one with the highest overall score. Based on the selection result, a channel scheduling policy is generated, and the message is pushed onto the designated network interface card queue.

[0118] In a further embodiment, generating a channel scheduling policy for an entity further includes:

[0119] When the overall score of a candidate protocol channel is lower than a preset threshold, a throttling, batch processing, or backoff control instruction for that candidate protocol channel is generated in the channel scheduling strategy.

[0120] In this embodiment, during communication operation, if the processor detects that the overall score of a candidate protocol channel is lower than a preset threshold, such as 0.5, it indicates that the channel has encountered congestion or availability degradation. At this time, the processor injects a degradation control instruction into the channel scheduling strategy.

[0121] Specifically, the processor can issue throttling instructions to limit the maximum number of messages that can be sent on the channel per unit time; or issue batch processing instructions to control the communication middleware to aggregate multiple fragmented small byte status messages into a large payload data packet before sending it, thereby reducing the transmission overhead rate of the network protocol header; or issue backoff control instructions to extend the waiting time interval for retransmission attempts by an exponential multiple, thereby actively alleviating network congestion.

[0122] When a message to be sent is identified to carry a version number, sequence number, or idempotent write flag, a controlled switching instruction is generated in the channel scheduling policy to switch the sending path to other candidate protocol channels in order to avoid state overwriting or out-of-order execution.

[0123] Alternatively, if the overall score is below a preset threshold, when a message to be sent is identified to carry a version number, sequence number, or idempotent write identifier, a controlled switching instruction is generated in the channel scheduling strategy to switch the sending path to other candidate protocol channels in order to avoid state overwriting or out-of-order execution.

[0124] Specifically, when encountering extreme channel degradation, the system needs to perform channel switching. However, unconstrained switching can lead to causal consistency errors. Therefore, the processor must perform idempotency checks before triggering a channel switch. The processor will only generate a controlled switching instruction in the channel scheduling policy if it recognizes that the message to be sent carries a globally unique version number and an incrementing sequence number in the header, or if the message itself is marked by the application layer as having idempotent write properties. The controlled switching instruction forcibly cuts off the transmission process of the currently degraded link and reroutes subsequent messages to other healthy candidate protocol channels. By introducing mandatory precondition constraints, the system avoids the risks of out-of-order execution of control commands due to underlying protocol latency differences and the erroneous overwriting of new states by old telemetry states.

[0125] In some optional implementations, for data plane messages that do not carry an idempotent write flag and cannot undergo controlled switching, a protocol fallback alternative is provided when the preferred channel to which they are bound fails. When generating the channel scheduling policy, the processor does not trigger cross-channel rerouting, but instead forcibly reduces the data reporting frequency of the entity while simultaneously activating the HTTP polling probe interface on the peer device. In this way, the system replaces high-frequency passive pushing with low-frequency active fetching, maximizing the reliability of core operational status acquisition while sacrificing some real-time performance.

[0126] This embodiment illustrates how, in a heterogeneous network environment with multiple sources and high-frequency concurrency, the service status in a unified entity snapshot is used to drive the quality assessment of network channels, thereby achieving separate governance of the control plane and data plane, as well as controlled switching of cross-protocol channels.

[0127] In a preferred embodiment, before performing dimensionless normalization processing on the entity business characteristic parameters, network link characteristic parameters, and service instance health status, the method further includes:

[0128] The basic health score is determined based on the pre-acquired service instance health status.

[0129] In this embodiment, under a microservice architecture, the system introduces a service registry to perform health checks on the communication gateways or proxy processes corresponding to each entity. It periodically receives pre-acquired service instance health statuses returned by the registry. Service instance health statuses are typically generated by the registry by sending network heartbeat probes to detect specified network ports of each instance. After obtaining the service instance health status, the processor performs quantitative numerical mapping operations to determine a basic health score.

[0130] Specifically, when the registry returns a probe success status, the processor assigns a base health score of 1.0; when it returns a warning status indicating a probe timeout but not failure, the processor assigns a base health score of 0.5; and when it returns an abnormal status indicating a probe failure or instance deregistration, the processor assigns a base health score of 0.0. Through numerical mapping, the system transforms the discrete underlying infrastructure network reachability into quantifiable parameter indicators.

[0131] The most recent state update time of the entity is extracted based on the unified entity snapshot, and the data layer health score is calculated in combination with the preset maximum silence duration.

[0132] Specifically, in a physical communication environment, network reachability of a proxy process does not equate to the normal operation of the physical entity. For example, when a drone's onboard sensor experiences a hardware failure and stops outputting telemetry payloads, its corresponding gateway process can still respond to the registry's heartbeat probe. To identify such silent anomalies at the business data layer, the processor accesses the memory area where the unified entity snapshot is located, reads the current system clock time, and extracts the most recent state update time recorded in the component for the entity. The difference between the current time and the most recent state update time is calculated to obtain the entity's actual silent duration. Accordingly, based on the entity's specific device type, the maximum silent duration pre-set in the configuration file is obtained. Based on the above two physical parameters, a data layer health score is determined through a specific linear calculation relationship. For example, the formula for calculating the data layer health score is:

[0133] h fresh =max(0, 1-t) silent / t max_silent );

[0134] Among them, h fresh For data layer health score, t silent t represents the actual silence duration of the entity. max_silentThis is the preset maximum silence duration.

[0135] The processor extracts the ratio of the actual silence duration to the maximum silence duration; based on this, it subtracts the ratio from the value 1.0 to obtain the initial difference; it further determines whether the initial difference is less than 0.0. If it is less than 0.0, the calculation result is forcibly truncated to 0.0; if it is greater than or equal to 0.0, the initial difference is directly used as the data layer health score.

[0136] The smaller value between the basic health score and the data layer health score is selected as the comprehensive health score, and the comprehensive health score is used as the health status of the service instance in subsequent dimensionless normalization processing.

[0137] In this embodiment, after obtaining the basic health score reflecting the infrastructure status and the data layer health score reflecting the freshness of business data, a fusion calculation is performed. Its mathematical logic is expressed by the following formula:

[0138] q health =min(h consul h fresh );

[0139] Where, q health For comprehensive health score, h consul Based on health score, h fresh Health score for the data layer.

[0140] The processor invokes the system's extreme value determination instruction, compares the base health score with the data layer health score, and forces the output of the smaller value as the comprehensive health score. This minimum-value calculation mechanism establishes a lower limit constraint on system reliability. In other words, regardless of whether there is a network outage or severe delay in business data, if the state of either dimension deteriorates, the overall availability evaluation of the entity will be simultaneously lowered. After calculation, the processor overwrites the original variables with the comprehensive health score, using this as a true and effective large-loop state feedback, which is then input into the system's subsequent dimensionless normalization processing module.

[0141] It should be noted that when using a comprehensive health score... health At that time, q health The freshness of the data layer has been constrained as a lower limit of reliability through the minimum value mechanism; while q is independently retained in the scoring formula. fresh The first item is used to directly quantify the absolute freshness of the current state data, reflecting the evaluation dimension of the entity data update rate itself. The two have different focuses and are complementary rather than completely overlapping. Understandably, when there is a higher requirement for the overlap between the two, they can also be combined into a single comprehensive indicator, and the specific weight configuration can be adjusted adaptively according to the actual business scenario.

[0142] Furthermore, to intuitively demonstrate the execution process of the fusion mechanism, a simplified example including specific numerical derivations is provided. The system pre-sets the maximum silent duration of a certain type of drone entity to 5.0 seconds. Within the current calculation cycle, the processor detects that the drone entity has not reported its location status for 2.0 seconds, meaning the actual silent duration is 2.0 seconds. Simultaneously, the registry center returns a timeout warning status for the drone communication instance, generating a base health score of 0.5. When performing the aforementioned data layer health score calculation operation, the processor extracts the ratio 2.0 / 5.0 = 0.4; calculates the difference 1.0 - 0.4 = 0.6; since 0.6 ≥ 0.0, the data layer health score is determined to be 0.6. The processor performs a fusion calculation, compares the values ​​of 0.5 and 0.6, and outputs the minimum value of 0.5. The final comprehensive health score is 0.5. This value accurately conveys the physical fact that the entity is currently in a communication degradation state to the routing policy layer.

[0143] Optionally, as an extended implementation of the health check mechanism, after generating a comprehensive health score, the processor combines the key-value storage and tag isolation functions of the registry center to perform differentiated instance governance. Based on the entity's type identifier and the calculated comprehensive health score, a routing weight identifier is dynamically written to the registry center. When performing service discovery, the underlying gateway parses the above identifier and, for instances whose health has decreased but are not yet completely offline, calls a pre-defined weighted least connections algorithm or round-robin algorithm to reduce their traffic allocation base, thereby achieving a smooth transition in service availability and automatic load balancing scheduling.

[0144] This embodiment illustrates how, before calculating the comprehensive score of the computing channel, the probe detection results of the infrastructure layer are combined with the data freshness of the business layer to calculate the comprehensive availability level of the computing entity, thus solving the problem that relying solely on the registry center cannot detect data flow anomalies.

[0145] like Figure 5As shown in another embodiment of this application, the unified management method for multimodal entities and heterogeneous messages can also include: mapping DDS IDL types, gRPC ProtoBuf (Remote Procedure Call Protocol Buffer) messages, MQTT, and local C++ structures to a unified entity model through an entity adapter, avoiding the fragmentation of multiple models. Furthermore, it manages complex states using component-based structures such as location, health, power, and tasks, providing thread-safe access. Configurable throttling, batching, prioritization, and backoff strategies are introduced into the DDS / HTTP / gRPC / MQTT cross-stack data stream to uniformly handle the load differences between high-frequency telemetry and low-frequency configurations, ensuring end-to-end latency and packet loss constraints. For the real-time state of each type of entity, a unified lifecycle management system is adopted, including parameter verification, threaded operation, signal processing, and safe shutdown, enabling rapid expansion of adding new entity devices with zero intrusion. Multiple source states such as UAVs / USVs / cameras / radar / model services are integrated into the entity twin, supporting collaborative governance of virtual entities and physical entities such as rules / regions / routes. It supports integration with Consul as a pluggable registry center, enabling service registration / discovery, health checks, instance governance, policy-based load balancing, and automated fault recovery. This changes the traditional application's approach of hard-coding IP addresses or using inflexible Domain Name System (DNS) addressing. Service instances register themselves, and consumers discover healthy, available instance addresses by querying the service name. Load balancing algorithms such as round-robin or random selection of an instance can then be used for invocation.

[0146] In this embodiment, the entity union types include camera entities, model entities, platform entities (UAVs / unmanned surface vessels), radar entities, region entities, rule entities, and route entities; the componentized states include dozens of components such as LOCATION, HEALTH, ONLINE, POWER, and TASKS, using multi-threading and mutual exclusion mechanisms to ensure concurrency safety; the TASKS component maintains an array of active tasks and task states to support task orchestration and execution tracking. In HTTP / REST (Hypertext Transfer Protocol / Representational State Transfer Interface), Crow provides application programming interfaces (APIs) for entities and tasks, including / api / v1 / publishEntity (entity publishing interface), / api / v1 / entities (entity query interface), / api / v1 / tasks (task interface), and task status query / update, etc.; gRPC is used for high-performance internal inter-service calls; DDS carries the distribution of real-time device status / measurement data, such as camera real-time status controllers; MQTT is used for low-bandwidth transmission of lightweight devices / edge terminals, such as real-time status transmission and reception of drones; depending on the device type, data real-time requirements, and network conditions, the above protocol set is selected or switched.

[0147] Furthermore, HTTP, gRPC, MQTT, and DDS services register with Consul upon startup (saving service address information), and clients obtain available instances through service discovery. An HTTP health probe is configured for each instance, and Consul periodically probes and maintains its health status. Policies such as round-robin, least connections, weighted, and health-priority are provided to the caller side. When a health probe fails, the instance is automatically isolated and a restart / switchover process is triggered; it automatically reverts to its previous state after recovery. Differentiated governance strategies for different device types can be implemented using Consul KV / Tag (key-value store / tag). Entity and task metadata are stored in a PostgreSQL database, and monitoring / telemetry data is written to a TimescaleDB time-series database to support long-term time-series queries. Logs and metrics are collected using spdlog and system metrics, supporting troubleshooting and capacity planning. Entities are created and stored in the database, and the corresponding service instances (HTTP / gRPC / DDS / MQTT bridges) are registered with Consul; clients query healthy instances from Consul by device type / tag; the control plane uses HTTP / gRPC, and the data plane uses DDS / MQTT; Consul periodically probes, isolates anomalies and triggers recovery; newly added instances are automatically registered and added to the load balancer; offline instances are automatically removed.

[0148] This embodiment achieves unified management and monitoring of various entity devices through multiple communication methods such as HTTP, gRPC, MQTT, and DDS. In terms of communication mechanisms, the system uses HTTP or gRPC protocols to handle request-response interactions such as entity registration and information queries, and uses MQTT or DDS middleware to implement real-time publishing and subscription of entity status, events, and other data, ensuring the system's real-time performance and reliability. Furthermore, it introduces Consul-based service registration, discovery, health checks, load balancing, and fault recovery to ensure high availability and elastic scaling. It also integrates Consul with protocols such as HTTP, gRPC, MQTT, and DDS to overcome the problems caused by frequent IP address changes and achieve dynamic addressing.

[0149] In terms of data management, a storage solution combining relational databases (such as PostgreSQL) and time-series databases (such as TimescaleDB) is adopted to achieve efficient management of static entity information and dynamic status data, forming an observable closed loop with logs and indicator systems. The system also integrates a comprehensive data processing mechanism, supporting real-time data analysis, historical queries, and statistical displays, providing rich data services for upper-layer applications. Through standardized interface specifications and flexible extension mechanisms, new entity types and management needs can be easily integrated. The system's front-end interface adopts a modular design, providing intuitive visualization and a user-friendly operating experience.

[0150] According to one aspect of this application, a unified management system for multimodal entities and heterogeneous messages includes:

[0151] Memory, used to store computer programs;

[0152] A processor is configured to implement the steps of the unified management method for multimodal entities and heterogeneous messages described in any of the above embodiments when executing the computer program.

[0153] In this embodiment, the system physically connects and coordinates the processor, memory, and network communication interface via a system bus in its hardware topology. The network communication interface specifically includes a physical network card module that supports Ethernet protocol, 5G communication technology protocol, or Wi-Fi technology. This module receives electromagnetic wave signals generated by physical devices such as drones, radars, and cameras, and converts them into underlying network data packets for extraction by subsequent protocol proxy modules.

[0154] Specifically, the processor can be implemented using a central processing unit (CPU), microprocessor, application-specific integrated circuit (ASIC), programmable logic device (PLC), or digital signal processor (DSP). As the core of the system's computational execution, the processor is responsible for reading received network data packets from the network communication interface and invoking the operating system kernel protocol stack to execute protocol offloading. Based on this, the processor invokes computer programs stored in memory to perform actions including field parsing, dictionary mapping, component assembly, multi-dimensional conflict resolution, and channel comprehensive scoring. During state conflict resolution, the processor uses its internal cache to read data segments from multiple candidate component state objects and executes timestamp comparison instructions and logical calculations driven by the system clock. During comprehensive scoring, the processor invokes the floating-point unit to perform dimensionless normalization and weighted summation calculations, converting the generated channel scheduling policy into low-level machine instructions and issuing them to the transmission queue of the network communication interface.

[0155] Furthermore, the memory can specifically include volatile memory and non-volatile memory. Volatile memory can be implemented using high-speed random access memory (RAM) for dynamically allocating memory space during system runtime. For example, unified entity snapshots and object instances containing state data such as location, health, and power reside in the address space of volatile memory, and data consistency for multi-threaded concurrent read / write operations is maintained through the operating system's mutex primitives. Non-volatile memory can be implemented using solid-state drives (SSDs), hard disk drives (HDDs), or flash memory chips for persistently storing the binary executable files of the computer program, as well as pre-configured semantic anchor dictionaries and component assembly rule matrices. In addition, non-volatile memory provides physical storage block resources for relational databases and time-series databases to support disk write operations for long-cycle state data.

[0156] According to another aspect of this application, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, implements the steps of the unified management method for multimodal entities and heterogeneous messages described in any of the above embodiments.

[0157] In this embodiment, the computer-readable storage medium is a non-transient physical data carrier medium. The medium utilizes magnetic, optical, electrical, or solid-state storage mechanisms to permanently store computer programs in the form of binary machine code or cross-platform bytecode. For example, the computer-readable storage medium can specifically manifest as a Universal Serial Bus (USB) flash drive, a read-only optical disc, an erasable programmable read-only memory (EPROM), or flash memory chips based on non-volatile memory standards.

[0158] When a computer program is loaded into the memory of a computing device and executed by its processor, the program instructions drive the device to logically construct the corresponding communication middleware agent, dictionary mapping engine, state conflict arbitrator, and network scheduling controller, thereby performing the aforementioned full-process technical actions of collecting, normalizing, arbitrating, and scheduling heterogeneous raw entity messages on the hardware entity surface.

[0159] In some optional implementations, the system can also be configured with a hardware acceleration module for high-load conditions with multiple sources and high-frequency concurrency. Specifically, the hardware acceleration module can be implemented using a field-programmable gate array (FPGA). The system writes the instruction logic involving field extraction and type conversion from the computer program into the hardware acceleration module, enabling it to directly execute packet parsing and component memory write operations at the data link layer, reducing the processor's computational load and shortening the physical latency of data processing.

[0160] This invention employs pre-configured semantic anchor rules for underlying normalization of heterogeneous fields and introduces a multi-dimensional priority adjudication mechanism composed of version number, timestamp, trust level, and task stage. This effectively solves the problem of concurrent dirty writes in the traditional gateway direct translation mode, transforming the risk of timing errors and old value overwriting during cross-protocol state synchronization from passive network layer retransmission to proactive semantic-level adjudication, ensuring the causal consistency of multimodal entity twin snapshots. On one hand, by integrating infrastructure probe status and business data freshness, it eliminates the pseudo-health blind spot caused by sensor deadlocks. On the other hand, it transforms the current task stage and component importance of an entity into dimensionless priority weights, and performs joint weighted scoring with objective physical indicators such as link latency and backlog length. This breaks the limitation of the separation between traditional communication middleware QoS strategies and business context, transforming the delivery process of critical control commands in congested networks from blind buffering and queuing to high-priority deterministic delivery based on business sensitivity. Meanwhile, in conjunction with a controlled switching mechanism based on idempotent flags, the probability of instruction overload caused by high-frequency telemetry contention is reduced to a low level, enhancing the adaptive resilience of large-scale device clusters under complex communication conditions.

[0161] The preferred embodiments of the present invention have been described in detail above. However, the present invention is not limited to the specific details in the above embodiments. Within the scope of the technical concept of the present invention, various equivalent transformations can be made to the technical solutions of the present invention, and these equivalent transformations all fall within the protection scope of the present invention.

Claims

1. A unified management method for multimodal entities and heterogeneous messages, characterized in that, include: Receive raw entity messages reported by heterogeneous protocol channels; Based on a pre-configured semantic anchor dictionary, semantic mapping and component assembly are performed on the original entity message to obtain candidate component state objects; For a predetermined number of candidate component state objects generated by the same entity within a preset time window, state conflict adjudication is performed based on multi-dimensional adjudication priority to generate a unified entity snapshot; Based on the unified entity snapshot, entity business feature parameters and network link feature parameters are extracted. Combined with the pre-acquired service instance health status, the comprehensive score of each candidate protocol channel is calculated to generate a channel scheduling strategy for the entity. Generate channel scheduling policies for entities, including: The entity task stage identifier and component importance identifier extracted from the unified entity snapshot are used as entity business feature parameters, and the link latency, link packet loss rate and message backlog length of the corresponding channel are extracted as network link feature parameters. Dimensionless normalization is performed on the entity business characteristic parameters, network link characteristic parameters, and service instance health status to obtain each normalized index; The normalized indicators are weighted and summed according to the preset weight coefficients to obtain the comprehensive score of each candidate protocol channel. Identify whether the pre-stored messages to be sent are control plane messages or data plane messages, and select the channel with the highest comprehensive score from the candidate protocol channels bound to the message type as the actual sending channel, and generate a channel scheduling strategy; Generating channel scheduling policies for entities also includes: When the overall score of a candidate protocol channel is lower than a preset threshold, a throttling, batch processing, or backoff control instruction for that candidate protocol channel is generated in the channel scheduling strategy. When a message to be sent is identified to carry a version number, sequence number, or idempotent write flag, a controlled switching instruction is generated in the channel scheduling policy to switch the sending path to other candidate protocol channels. Before performing dimensionless normalization on entity business characteristic parameters, network link characteristic parameters, and service instance health status, the following steps are also included: A basic health score is determined based on the pre-acquired service instance health status. The most recent state update time of the entity is extracted based on the unified entity snapshot, and the data layer health score is calculated in combination with the preset maximum silence duration. The smaller value between the basic health score and the data layer health score is selected as the comprehensive health score, and the comprehensive health score is used as the health status of the service instance in subsequent dimensionless normalization processing.

2. The method according to claim 1, characterized in that, Obtain the candidate component state object, including: Perform field parsing on the original entity message to extract the entity identifier field, source channel field, and business status field; Based on the pre-configured semantic anchor dictionary, and in combination with the entity identifier field and the source channel field, the business status field is mapped to a unified set of semantic items; According to the preset component assembly rules, the unified semantic item set is written into the component set that matches the corresponding entity type to obtain the candidate component state object.

3. The method according to claim 1, characterized in that, Generate a unified entity snapshot, including: For a predetermined number of candidate component state objects, the comparison and decision are made step by step according to a preset priority chain. If a winning object is determined at the current priority, the subsequent comparison is terminated. The priority chain, from high to low, is as follows: compare the entity version number carried by each candidate component state object; compare the original message timestamp of each candidate component state object; compare the source trust level of the source protocol channel corresponding to each candidate component state object; compare the sensitivity of the current task stage of the entity to which each candidate component state object belongs to the communication reliability. The data of the winning entity determined by the comparison are merged to generate a unified entity snapshot.

4. The method according to claim 1, characterized in that, The candidate component state object is obtained in the following way: Obtain a pre-built component projection template as a pre-configured semantic anchor dictionary, wherein the component projection template includes field path definitions and type conversion rules for each entity type; Field extraction is performed on the original entity message according to the component projection template of the corresponding entity type, and the extracted content is converted into standard data format according to the type conversion rules; The converted field values ​​are directly written to the component that matches the entity type to obtain the candidate component state object.

5. The method according to claim 3, characterized in that, After comparing the original message timestamps of each candidate component state object, and before comparing the source trust level of the source protocol channel corresponding to each candidate component state object, the process also includes a step of determining the source trust level, specifically: Obtain the preset static baseline trust level for each source protocol channel; Statistical analysis of message arrival rates for each source protocol channel within a preset sampling period; When the message delivery rate is lower than a preset first threshold, the static baseline trust level is downgraded to obtain a dynamically corrected source trust level. Once the message delivery rate recovers to above the preset second threshold and remains above it for a preset period, the dynamically corrected source trust level will be restored to the static baseline trust level.

6. The method according to claim 2, characterized in that, The default component assembly rules are constructed in the following way: A configuration matrix is ​​constructed based on preset entity types and component types; In the configuration matrix, the enabling status of the corresponding components and the set of semantic items to be associated are configured for each entity type; Configure the expected update frequency for components that are enabled as required or optional, and obtain the preset component assembly rules.

7. The method according to claim 2, characterized in that, The set of components that match the corresponding entity type includes at least: Location component used to record the geospatial location of an entity; A health component used to record the health status consisting of device alarm codes and service reachability; An online component used to record the online status of a device; A power supply component used to record power data; A task component used to record the list of activity tasks and stage identifiers.

Images