A heterogeneous simulation system access system and method based on HLA and DDS

Abstract

The application belongs to the technical field of distributed simulation system, and discloses a heterogeneous simulation system access system and method based on HLA and DDS; through initializing a DDS communication component and creating a communication handle, data type publishing and subscription registration are completed; according to simulation node role configuration time limited and control attribute, a time management hierarchical relationship is established; intelligent classification processing of messages is realized, time sequence messages and ordinary messages are distinguished; step feasibility judgment is executed based on a time management cluster; an ordered data refreshing mechanism is adopted to guarantee the correctness of causality; and a dynamic time compensation algorithm is introduced to eliminate synchronization error. The application improves time synchronization precision and system interoperability in a distributed environment, solves the problems of message time sequence confusion and time drift. In the field of complex system simulation such as spacecraft cooperative simulation, the application effectively enhances system expansibility and resource utilization efficiency, and provides reliable technical support for large-scale heterogeneous system cooperative simulation.

Description

Technical Field

[0001] This invention relates to the field of distributed simulation system technology, and more specifically, to a heterogeneous simulation system access system and method based on HLA and DDS. Background Technology

[0002] In the field of spacecraft co-simulation, traditional simulation architectures generally suffer from difficulties in integrating heterogeneous systems. Various simulation systems are built on different communication protocols and data standards, leading to significant barriers between systems and making the integration process cumbersome and error-prone. Furthermore, due to inconsistent integration standards for heterogeneous systems, the insufficient accuracy of distributed time synchronization during multi-system co-simulation is particularly prominent. The varying processing capabilities of different nodes, coupled with unstable network transmission latency, cause significant drift in the simulation timeline. Over long periods of operation, the time differences between nodes gradually accumulate, severely impacting the accuracy and reliability of the simulation results. The problem of disordered message processing timing is particularly evident in high-intensity interaction scenarios. The lack of a unified message classification and prioritization mechanism causes events that should logically be processed in a specific order to be processed out of order during actual execution, leading to causal errors. Existing time management mechanisms generally lack flexibility and cannot be configured differently according to the characteristics of different levels of simulation systems. This forces all nodes to follow the same time progression strategy, failing to fully utilize the computing power of high-performance nodes and causing resource-constrained nodes to struggle. In complex network environments, the system lacks an effective dynamic compensation mechanism, failing to adaptively adjust time step parameters to real-time monitored network fluctuations and load changes, resulting in insufficient robustness in the face of external interference. Furthermore, as simulation scales up, such as in collaborative simulations of multiple spacecraft simulators in the same scenario, the scalability limitations of traditional methods become increasingly apparent. Adding each new node requires significant manual configuration work, leading to an exponential increase in management complexity and severely restricting the efficiency of collaborative simulation implementation. These technical bottlenecks not only increase system development and maintenance costs but also limit the accuracy and scale of spacecraft collaborative simulations, failing to meet the growing demands for accuracy and flexibility in future large-scale spacecraft joint simulations.

[0003] In view of this, the present invention proposes a heterogeneous simulation system access system and method based on HLA and DDS to solve the above problems. Summary of the Invention

[0004] To overcome the aforementioned deficiencies of the prior art and to achieve the above objectives, the present invention provides the following technical solution: a heterogeneous simulation system access method based on HLA and DDS, comprising:

[0005] Initialize the DDS communication component, create a DDS communication handle, and complete the data type publication and subscription registration based on the DDS communication handle to generate an initialized simulation node;

[0006] Add the initialized simulation nodes to the time management cluster, configure the node time-limited attributes and node time control attributes according to the role of the simulation nodes in the co-simulation, and generate the configured simulation nodes.

[0007] Receive messages to be published through the DDS communication handle, classify the messages to be published into time-series messages or ordinary messages according to the correlation between the timestamp of the message to be published and the current simulation time and the node time control attributes, and execute message publishing. At the same time, store the received subscription messages into the message cache.

[0008] Based on the configured simulation node, a time stepping request is initiated to the time management cluster. According to the node time control attributes of each simulation node in the time management cluster and the current simulation time, a stepping feasibility judgment is performed to determine whether it is possible to step to the target simulation time.

[0009] Once the feasibility of the stepping is approved, historical messages with timestamps no greater than the target simulation time are filtered from the message cache. A data refresh operation is performed to process the historical messages sequentially through callback functions in chronological order. After the time stepping is completed, stepping response information is generated.

[0010] Collect the step response information returned by each simulation node in the time management cluster, calculate the time synchronization error between each simulation node and generate a time compensation amount, and apply the time compensation amount to the next round of time stepping to achieve distributed time synchronization between heterogeneous simulation systems.

[0011] A heterogeneous simulation system access system based on HLA and DDS, which is used to implement a method for accessing a heterogeneous simulation system based on HLA and DDS, includes:

[0012] The DDS communication initialization module is used to initialize the DDS communication component, create a DDS communication handle, and complete the publication and subscription registration of data types based on the DDS communication handle, and generate initialized simulation nodes.

[0013] The time management configuration module is used to add initialized simulation nodes to the time management cluster, configure node time-limited attributes and node time control attributes according to the role of the simulation node in the co-simulation, and generate the configured simulation node.

[0014] The message processing module is used to receive messages to be published through the DDS communication handle, classify the messages to be published into time-series messages or ordinary messages according to the correlation between the timestamp of the message to be published and the current simulation time and the node time control attributes, and execute message publishing. At the same time, the received subscription messages are stored in the message cache.

[0015] The time stepping request module is used to initiate a time stepping request to the time management cluster based on the configured simulation nodes. According to the node time control attributes of each simulation node in the time management cluster and the current simulation time, it performs a stepping feasibility judgment to determine whether it is possible to step to the target simulation time.

[0016] The historical message processing module is used to filter historical messages with timestamps no greater than the target simulation time from the message cache after the step feasibility judgment is passed, perform a data refresh operation, process the historical messages in chronological order through callback functions, and generate step reply information after the time step is completed.

[0017] The time synchronization compensation module is used to collect the step response information returned by each simulation node in the time management cluster, calculate the time synchronization error between each simulation node and generate the time compensation amount, and apply the time compensation amount to the next round of time stepping.

[0018] The technical effects and advantages of the heterogeneous simulation system access system and method based on HLA and DDS of the present invention are as follows:

[0019] This invention, based on a unified HLA simulation architecture and DDS communication components, breaks down data barriers between different simulation protocols. It effectively improves the access efficiency and time synchronization accuracy of simulation systems in large-scale heterogeneous co-simulation scenarios across domains and granularities, ensuring that event processing during complex interactions between systems in multi-system co-simulation always follows logical timing, thus resolving message timing disorder and time drift issues. In complex system simulation fields such as spacecraft co-simulation, it effectively enhances system scalability and resource utilization efficiency, providing reliable technical support for large-scale heterogeneous system co-simulation. The related results can also be effectively applied to other fields such as aerospace co-simulation and intelligent transportation. Attached Figure Description

[0020] Figure 1 This is a schematic diagram of a heterogeneous simulation system access method based on HLA and DDS according to the present invention;

[0021] Figure 2 This is a schematic diagram of a heterogeneous simulation system access system based on HLA and DDS according to the present invention. Detailed Implementation

[0022] 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.

[0023] This application provides a heterogeneous simulation system access system and method based on HLA and DDS. The execution entities of this access system include, but are not limited to: distributed simulation platform, heterogeneous system integration environment, simulation interoperability interface, time synchronization manager, etc., which can be regarded as general computing nodes of this application. The system components include, but are not limited to: DDS communication middleware, HLA runtime infrastructure, time management service component, etc., at least one of them.

[0024] Please see Figure 1 In this embodiment of the invention, the specific steps of a heterogeneous simulation system access method based on HLA and DDS include:

[0025] The DDS communication component is initialized, a DDS communication handle is created, and data type publication and subscription registration are completed based on the DDS communication handle, generating initialized simulation nodes. The DDS communication component, as the infrastructure for distributed data transmission, provides a reliable data exchange mechanism. The initialization process first creates a communication handle according to the system configuration, then parses the data interaction configuration file to obtain publication and subscription information, and completes data type registration. The communication handle maintains the channels and rules for data exchange between nodes, publication registration determines the data types that nodes can output, and subscription registration specifies the external data types that nodes need to receive. This step establishes the basic communication framework for subsequent data interaction, ensuring that each simulation node can efficiently exchange information in a unified data space.

[0026] The initialized simulation nodes are added to the time management cluster. Based on the node's role in the co-simulation, the node's time-constrained and time-control attributes are configured, generating a fully configured simulation node. The time management cluster is the core component coordinating the time progression of distributed simulations, ensuring simulation consistency by uniformly managing the time progress of each node. The joining process first obtains the node identifier and role information, then registers the node by calling the cluster interface, and finally sets the time attributes according to the node's role. The time-constrained attribute determines whether a node needs to wait for time step permission from other nodes, while the time-control attribute determines whether a node can influence the global time progression. This role-based time management configuration mechanism ensures the coordinated operation of different types of simulation systems in a co-simulation environment, avoiding timing chaos and data inconsistency issues.

[0027] Messages to be published are received via the DDS communication handle. Based on the correlation between the timestamp of the message to be published and the current simulation time, as well as the node time control attributes, the messages are classified into time-series messages or ordinary messages and published accordingly. Simultaneously, received subscribed messages are stored in the message cache. Message classification is a crucial step in ensuring data timing consistency, achieving precise data transmission control by distinguishing different message types. The process first checks whether the message carries a timestamp, then classifies it based on the node time control status and the timestamp value. Time-series messages must be published strictly according to the simulation time sequence to ensure that causal relationships are not disrupted; ordinary messages can be published immediately and are suitable for control information with less stringent timing requirements. This dual-channel message processing mechanism improves the system's flexibility, ensuring the timing accuracy of critical data while avoiding unnecessary processing delays.

[0028] Once configured, the simulation nodes initiate time stepping requests to the time management cluster. Based on the node time control attributes of each simulation node in the time management cluster and the current simulation time, a stepping feasibility determination is performed to determine whether stepping to the target simulation time is possible. Time stepping management is the core mechanism of distributed simulation synchronization, ensuring global time consistency by centrally coordinating the advancement requests of each node. The stepping process first obtains the node's time-constrained attributes, and then executes different judgment strategies based on the attribute status. For non-time-constrained nodes, stepping can be directly determined; for time-constrained nodes, the status of all time control nodes needs to be checked to ensure the rationality of global time advancement. This attribute-based judgment mechanism achieves flexible synchronization control, ensuring the overall timing consistency of the system while providing necessary flexibility to adapt to the needs of different types of simulation systems.

[0029] Once the feasibility of the stepping process is approved, historical messages with timestamps no greater than the target simulation time are selected from the message cache. A data refresh operation is then performed, and the historical messages are processed sequentially through callback functions according to their time sequence. After the time stepping is completed, a stepping response message is generated. The data refresh operation is a crucial step in ensuring that messages are processed in the correct time sequence. A caching mechanism and sorting process decouple time management from data processing. The refresh process first selects messages that meet the time criteria from the cache, then sorts them by timestamp, and finally calls the corresponding callback functions in sequence to process the data. This sorting mechanism ensures that even if messages arrive at different physical times, they are processed according to their logical time (timestamp) order, guaranteeing the correctness of causal relationships. After processing, the time information is recorded, and a stepping response is generated to provide necessary feedback data for subsequent synchronization control.

[0030] This process collects step feedback information from each simulation node in the time management cluster, calculates the time synchronization error between the simulation nodes, generates a time compensation amount, and applies this compensation amount to the next round of time stepping to achieve distributed time synchronization between heterogeneous simulation systems. Distributed time synchronization is the final step to ensure the coordinated operation of heterogeneous systems, eliminating accumulated time errors by dynamically adjusting stepping parameters. The synchronization process first collects step feedback from each node, extracts completion time and latency information, then calculates the time deviation between nodes, determines the maximum synchronization error, and finally generates an appropriate compensation amount to adjust the next round of stepping. This feedback-based adaptive synchronization mechanism can effectively cope with time drift caused by factors such as network latency and processing performance differences, ensuring system stability during long-term simulations and improving overall simulation accuracy.

[0031] In this embodiment of the invention, the detailed implementation steps for initializing the DDS communication component, creating a DDS communication handle, and completing data type publication and subscription registration based on the DDS communication handle to generate an initialized simulation node include:

[0032] The communication domain identifier is determined based on the system level to which the simulation system belongs, and DDS communication handles are created based on the communication domain identifier. The communication domain identifier is a key parameter for dividing the data space, ensuring that communication in different ranges is isolated from each other. The determination process first analyzes the level attributes of the simulation system, such as system level, unit level, etc., and then maps them to the corresponding domain identifier values. The communication domain adopts a hierarchical coding strategy, with high bits representing the main domain category and low bits representing the subdomain division, which facilitates unified management and flexible expansion. When creating the communication handle, the domain identifier is used as a key parameter. The DDS middleware API is called to initialize the participant instance and set QoS (Quality of Service) parameters such as reliability level, persistence policy, and resource limits to ensure that communication performance meets simulation requirements. The reasonable division of communication domains avoids data conflicts and irrelevant traffic interference, improves network utilization efficiency, and provides a scalable communication foundation for large-scale heterogeneous system integration.

[0033] The simulation system's data interaction configuration file is parsed to extract the sets of data types to be published and subscribed to. The data interaction configuration is fundamental for system interoperability, defining the data exchange rules between nodes through a structured description. The parsing process uses an XML or JSON parser to read the configuration file content, analyzing the data structure definitions and interaction relationships. The configuration file contains key information such as topic names, data type definitions, QoS parameters, and interaction identifiers, using a standardized format to ensure seamless integration across different development teams. Data type definitions use IDL (Interface Definition Language), supporting nested combinations of basic and composite types to express complex data structures. Interaction identifiers explicitly specify the data flow direction: publish identifiers indicate data output capabilities, and subscribe identifiers indicate data reception requirements. This configuration-based data interaction definition method improves system flexibility and maintainability, facilitating dynamic adjustment and expansion.

[0034] The system iterates through the set of data types to be published, creating a data writer for each data type in the DDS communication handle and completing the publication registration. The data writer is the core component for data publishing, responsible for converting application data into a network transmission format and sending it. The creation process first defines a corresponding topic for each data type, setting the topic name and data type description; then, it creates a publisher instance, configuring publication QoS such as data lifecycle, priority, and transmission optimization strategies; finally, it creates a dedicated data writer for each topic, completing the publication registration. The data writer maintains a send buffer and history cache, supports reliable transmission and status query functions, and can handle network anomalies and data loss issues. The registration process establishes a mapping relationship between the data writer and the application layer data source, facilitating upper-layer applications to publish data through a unified interface without needing to concern themselves with the underlying communication details. This layered design improves the system's modularity and development efficiency.

[0035] The process iterates through the set of data types to be subscribed to, creating a data reader for each data type in the DDS communication handle and binding a corresponding callback function. After completing the subscription registration, an initialized simulation node is generated. The data reader is a key component for implementing data subscription, responsible for receiving network data and converting it into an application-usable format. The creation process is similar to that of a data writer: first, the corresponding topic is defined; then, a subscriber instance is created, configuring subscription QoS such as data filtering conditions, receive buffer size, and data persistence strategy; finally, a dedicated data reader is created for each topic, and a callback function is bound. The callback function is the core mechanism for data processing, automatically triggered when new data arrives, implementing an asynchronous processing mode. The binding process associates the callback function with the data reader and sets trigger conditions such as data availability, state change, or timeout events. After all registrations are completed, the simulation node possesses full data interaction capabilities, able to send and receive various types of data, becoming an initialized and usable node. This callback-based asynchronous processing mechanism improves the system's responsiveness and concurrent processing capabilities, making it suitable for handling multi-source asynchronous data streams.

[0036] In this embodiment of the invention, the detailed implementation steps for adding the initialized simulation nodes to the time management cluster and configuring the node time-constrained attributes and node time control attributes according to the role of the simulation nodes in the co-simulation to generate the configured simulation nodes include:

[0037] The process retrieves the node identifiers and role information of initialized simulation nodes, including those for centralized or distributed simulation systems. Node identifiers and role information are fundamental data for time management configuration, determining a node's identity and responsibilities within the simulation cluster. The retrieval process first reads the identifier information from the node configuration file or startup parameters, including the globally unique node ID, node name, and system type. Then, it analyzes the node's functional characteristics and the simulated objects to determine its role classification. Centralized simulation system nodes typically simulate higher-level command and decision-making and collaborative behavior, possessing a global perspective and control capabilities; distributed simulation system nodes focus on the detailed behavior of a single device or subsystem, requiring higher-level coordination and control. Role classification employs a hierarchical system, supporting multi-level nesting and composite role definitions, capable of expressing complex simulation system organizational structures. Accurate role identification is a prerequisite for correctly configuring time attributes, ensuring the effectiveness and precision of distributed time management.

[0038] The cluster join interface is invoked to register the initialized simulation node to the time management cluster and obtain the node sequence number assigned by the cluster. Cluster join is the formal step for a node to participate in distributed simulation, establishing a connection between the node and the time management framework. The join process first prepares registration information, including node identifier, communication parameters, and initial state data; then, it calls the cluster management interface to send a join request and waits for cluster confirmation; finally, it receives the sequence number returned by the cluster, completing the registration process. The cluster join interface adopts a secure handshake mechanism, supports node authentication and communication encryption, and ensures cluster security. Registration information is transmitted through a dedicated control channel to ensure high-priority processing and reliable delivery. The node sequence number is a unique identifier for internal cluster management, used for message routing and priority sorting, affecting the processing order of nodes in conflict resolution. During the join process, cluster state information is synchronously obtained, including the list of currently active nodes, the global time base, and synchronization parameters, ensuring that the new node can seamlessly integrate with the existing system.

[0039] The time management mode is determined based on node role information. When the node role information is a centralized simulation system node, the node's time control attribute is set to "enabled". The time control attribute determines whether a node can actively advance the global simulation time and is the core mechanism of distributed time management. The setting process is based on role judgment; system-level systems typically have time control permissions and can influence the overall simulation process. Nodes with the time control attribute set to "enabled" can initiate time step requests to the cluster, pushing the global simulation time forward. Control permission management adopts a role-based access control model, determining the control capabilities of various roles through a predefined permission matrix. The attribute setting process is completed through the time management interface, and the setting results are cached locally and synchronized to the cluster management center to ensure global consistency. The reasonable allocation of time control permissions is crucial to avoiding control conflicts and deadlocks. The system-level system, as the global coordinator, bears the main responsibility for time advancement, ensuring the orderly progress of the simulation process.

[0040] When a node's role information is a distributed simulation system node, the node's time-constrained attribute is set to "enabled," and a configured simulation node is generated after attribute configuration. The time-constrained attribute determines whether a node needs to adhere to global time constraints, serving as a guarantee mechanism for ensuring the correctness of causal relationships. The setting process is also based on role judgment; single-installation-level systems typically need to accept time constraints to ensure their behavior is consistent with global timing. Nodes with the time-constrained attribute enabled must wait for global permission to advance their local time, ensuring that future events are not processed prematurely. Attribute configuration adopts a safe default principle; newly added nodes have time constraints enabled by default, and the constraint can only be disabled if explicitly specified. After configuration, the node's status is updated to "ready," enabling it to participate in normal simulation interactions and becoming a configured simulation node. This role-based dual attribute configuration mechanism establishes a clear hierarchical relationship for time control: higher-level systems are responsible for time advancement decisions, while lower-level systems adhere to time constraints, jointly ensuring causal consistency and behavioral coordination in the distributed simulation environment.

[0041] In this embodiment of the invention, the detailed implementation steps for receiving messages to be published via a DDS communication handle, classifying the messages to be published into time-series messages or ordinary messages based on the correlation between the timestamp of the message to be published and the current simulation time, as well as the node time control attributes, and then executing message publishing include:

[0042] The process checks whether the message to be published carries a timestamp field. If it does not, the message is marked as a normal message and published via the DDS communication handle. Timestamp detection is the first step in message classification, determining the message's time sensitivity. The detection process first analyzes the message structure and searches for predefined timestamp fields; if the field is missing or empty, it is determined to be a message without a timestamp. Normal messages are not subject to time management constraints and can be directly published to the network. They are suitable for interactive information with low timing requirements, such as control commands and status queries. The publishing process calls the DDS communication handle's write interface to serialize the message data and pass it to the corresponding data writer. The DDS middleware is responsible for network transmission and reliability assurance. The normal message channel adopts an optimized processing flow, reducing unnecessary time checks and sorting operations, thus reducing latency and resource consumption. This fast channel mechanism improves the processing efficiency of non-critical messages, ensures that control commands can reach the target node in a timely manner, and enhances the system's responsiveness and flexibility.

[0043] When a message to be published carries a timestamp field, the system checks whether the node's time control attribute is enabled. Checking the node's time control status is a crucial step in determining the message processing strategy, as it determines the message publishing mode based on node permissions. The check process retrieves the current node's time control attribute value and determines whether it has time advancement permissions. Nodes with enabled time control attributes must strictly adhere to the time consistency principle, ensuring that the timestamp of the published message is synchronized with the current simulation time. Nodes with disabled time control attributes employ a more flexible processing strategy, allowing for differences between the message timestamp and the current time. This attribute-based processing routing mechanism enables differentiated management of different types of nodes, ensuring the timing accuracy of critical nodes while providing operational convenience for ordinary nodes, thus adapting to the complex needs of heterogeneous simulation environments.

[0044] When the node's time control attribute is enabled, the timestamp field value is checked against the current simulation time. If they match, the message to be published is marked as a time-series message and published. Timestamp verification is a crucial processing step for the time control node, ensuring the correct timing of sent messages. The verification process compares the message timestamp with the current simulation time, requiring a perfect match. Time-series messages represent the state or event at a specific simulation moment, with strict timing requirements; they must be processed in chronological order to ensure causal relationships. The publishing process is similar to that of ordinary messages, but with the addition of a time attribute marker, allowing the receiver to sort and process messages accordingly. The time-series channel employs a priority mechanism to ensure that time-critical messages receive sufficient network resources and processing bandwidth. This rigorous time consistency check is the foundation for achieving precise timing control in a distributed environment, ensuring that the system-level system can accurately control the progress and state of the global simulation and maintaining the temporal integrity of the distributed simulation.

[0045] When the node's time control attribute is disabled, messages to be published carrying timestamp fields are processed as ordinary messages and published. Non-time-controlled nodes employ a simplified message processing flow, reducing operational complexity. The processing ignores the matching requirement between timestamps and the current time, allowing messages to carry arbitrary time stamps, suitable for auxiliary systems such as observers and recorders that do not affect the simulation process. The publishing process retains the original timestamp of the message but does not add time-series markers; the receiver determines its processing strategy based on its own needs. This flexible processing method adapts to the diverse needs of non-critical nodes, allowing asynchronous observation and recording without interfering with the main simulation flow. Simultaneously, the retention of the original timestamp provides a time reference for subsequent analysis and playback, facilitating post-simulation reconstruction and causal analysis. This differentiated message processing strategy enables time-controlled and non-controlled nodes to work collaboratively within a unified framework, ensuring both strict timing of critical processes and flexibility for auxiliary functions.

[0046] In this embodiment of the invention, the detailed implementation steps for determining the feasibility of stepping from a configured simulation node to a time management cluster, based on the node time control attributes of each simulation node in the time management cluster and the current simulation time, include:

[0047] Retrieve the time-constrained attributes of the configured simulation nodes. Time-constrained attribute checking is a prerequisite for time-stepping decisions, determining whether a node requires global permission to advance time. The retrieval process accesses the node's attribute library and reads the time-constrained status value. Time-constrained attributes record the node's dependence on global time synchronization and are key parameters determined during configuration based on the node's role. Attribute values ​​are typically stored in a local configuration database, supporting dynamic querying and modification at runtime. The retrieval operation employs a caching optimization strategy, keeping frequently accessed attribute values ​​in memory to reduce storage access latency. Accurate attribute determination is fundamental to the correct execution of time-stepping control, ensuring that different types of nodes can participate in the global time synchronization process according to expected rules, maintaining the time consistency of the distributed system.

[0048] When the time-constrained attribute of a node is disabled, the step feasibility check is directly passed. Non-time-constrained nodes employ a simplified step-by-step decision-making process, improving processing efficiency. The decision-making process skips global coordination checks and directly returns a pass result, allowing nodes to autonomously advance their local time. The non-time-constrained mode is suitable for simulation nodes with high independence, low timing requirements, or purely observational functions, such as environmental simulators and recording systems. These nodes do not depend on the precise order of external events and can operate at their own pace without waiting for global permission. The direct pass mechanism uses a fast path design to minimize decision latency and improve system response speed. Simultaneously, to avoid long-term offsets caused by complete detachment from global control, non-time-constrained nodes typically have periodic synchronization points, periodically calibrating with global time to maintain approximate synchronization. This flexible time management strategy ensures accurate synchronization of critical nodes while providing greater autonomy and efficiency for non-critical nodes, optimizing overall system performance.

[0049] When the time-controlled attribute of a node is enabled, the system iterates through all time-controlled nodes in the time management cluster whose time control attribute is enabled. Checking the status of time-controlled nodes is a core step in strict time synchronization, ensuring that all critical nodes are ready. The iteration process first obtains a list of active nodes in the cluster, then filters out critical nodes with enabled time control attributes. Time-controlled nodes are responsible for advancing the global simulation time, and their status directly affects the synchronization process of the entire system. The iteration operation employs an efficient set-based iterative algorithm, supporting parallel queries and caching optimization to reduce the communication overhead of cluster status acquisition. For large-scale distributed environments, a hierarchical query strategy is adopted, first checking nodes within the local domain, then expanding to cross-domain nodes to optimize query performance. The traversal results include the node ID, current status, and latest time value, providing complete data for subsequent step condition judgments. This comprehensive control node checking mechanism ensures that time advancement decisions in the distributed environment are based on globally complete information, avoiding inconsistent decisions due to incomplete information.

[0050] The time-stepping feasibility check is passed if all time control nodes have completed their stepping or are requesting a stepping, and if the simulation time of each time control node is not less than the target simulation time. Global state consistency checks are the key logic for time-stepping decisions, ensuring the system does not violate causal relationships. The process first checks the current state of each time control node, requiring all nodes to have completed the previous stepping or are requesting a new stepping, indicating a stable system. Then, it compares the current simulation time of each node with the requested target time, ensuring that none of the node's time lags behind the target time, preventing the skipping of unprocessed events. This double-check mechanism guarantees the safety of time progression and avoids timing chaos caused by different node processing speeds. The global consistency check adopts the "most conservative" principle; only when all conditions are met does the check pass. If any control node fails to meet the conditions, the request is rejected, ensuring strict timing of the system. This strict decision-making strategy based on global state is a key mechanism for achieving causal consistency in a distributed environment, ensuring the correct event processing order is maintained even in heterogeneous systems with varying performance, avoiding simulation errors caused by timing violations.

[0051] In this embodiment of the invention, the detailed implementation steps of filtering historical messages with timestamps no greater than the target simulation time from the message cache, performing a data refresh operation to process the historical messages sequentially through callback functions according to time sequence, and generating step-by-step response information after completing the time stepping include:

[0052] Historical messages with timestamps no greater than the target simulation time are filtered from the message cache to generate a message queue to be refreshed. Time range filtering is the first step in data refresh, determining the set of messages to be processed in the current step cycle. The filtering process first accesses the message cache system to retrieve all received but unprocessed messages; then, it compares the message timestamps with the target simulation time, filtering out a subset of messages with timestamps no greater than the target time. The message cache uses an efficient index structure, supporting fast time-based queries and reducing retrieval latency under large data volumes. The filtering operation uses range query optimization, retrieving all messages that meet the conditions in a single request, reducing the overhead of multiple accesses. The filtering results are organized into a message queue to be refreshed, retaining complete information of the original messages, including data content, timestamps, source identifiers, and priority markers. This time window-based message filtering mechanism ensures that each step only processes logically "occurred" events, maintaining the correctness of causal relationships and avoiding logical errors where future messages prematurely affect the current state.

[0053] Historical messages in the message queue to be refreshed are sorted in ascending order by timestamp. Time-series sorting is a crucial step in ensuring the correctness of message processing order, ensuring that events are executed in chronological order. The sorting process uses a stable sorting algorithm to maintain the original order of messages with the same timestamp. For large-scale message sets, a multi-stage sorting strategy is adopted: first, pre-classification is performed according to coarse-grained time buckets; then, precise sorting is performed within each bucket; finally, the results are merged to optimize sorting performance. The sorting operation considers the special properties of timestamps and uses a comparison function optimized for time series to correctly handle time wraparound and time zone conversion issues. The sorting result maintains the strict time order of messages, ensuring correct processing even if the physical order of message arrival differs from the logical order of occurrence. This is crucial for maintaining causal relationships in a distributed environment. The sorted message queue constitutes a logically continuous sequence of events, providing a foundation for subsequent sequential processing and ensuring the correct evolution of the simulation state.

[0054] Historical messages are retrieved sequentially from the sorted message queue, and the corresponding callback function is invoked according to the data type to complete the callback processing. The processed historical messages are then removed from the message cache. Sequential callback processing is the core process of data updates, executing event responses in chronological order. The processing adopts a single-threaded sequential model, strictly processing each message according to the sorting result to ensure consistency between the processing order and the chronological order. For each message, the corresponding callback function registry is first looked up based on the data type identifier to obtain a reference to the processing function; then, the execution environment is prepared, including context information and parameter passing; finally, the callback function is invoked to complete the actual processing and update the simulation state. The callback function is a processing routine pre-bound during subscription registration, encapsulating the application layer's processing logic for specific data types. After processing, the message is removed from the cache to release storage space and avoid duplicate processing. This type-based distribution mechanism decouples data from processing logic, supports flexible functional expansion and customization, and ensures consistency and predictability of state updates through strict sequential execution.

[0055] Once the message queue to be refreshed is cleared, the step completion timestamp and step duration are recorded, and step response information is generated. Performance statistics and response generation are the final steps in completing data refresh, providing feedback information on step execution. The statistics process first records the current system time as the step completion timestamp; then calculates the time taken from the start to the completion of the step as a performance evaluation indicator; finally, it integrates this information to generate structured response data. The step response information includes key fields such as node identifier, target time, completion time, number of messages processed, and processing time, comprehensively reflecting the process and results of step execution. The response information uses a standardized format, facilitating parsing and statistics by the upper-level management system and supporting cross-platform compatibility. The complete response mechanism establishes a closed-loop feedback between nodes and the cluster management system, enabling the management system to monitor the execution status and performance characteristics of each node in real time, providing data support for load balancing and performance optimization. Simultaneously, accurate time recording provides the necessary basis for subsequent synchronization control and error compensation, forming the foundation for adaptive time management.

[0056] In this embodiment of the invention, the detailed implementation steps for collecting the step response information returned by each simulation node in the time management cluster, calculating the time synchronization error between each simulation node, and generating the time compensation amount include:

[0057] The system receives step-by-step response information from each simulation node in the time management cluster, extracting the step completion timestamp and step duration from these responses. Response information collection forms the data foundation for global synchronization control, providing a comprehensive view of the system's operational status. The collection process employs a strategy combining proactive reception and timeout queries to ensure complete node feedback is obtained. For nodes that return responses normally, their responses are processed directly; for nodes that do not respond within a timeout period, a status query request is initiated to obtain the latest status. Key performance indicators are extracted from the response information, including the completion timestamp (recording the actual physical time of step completion) and step duration (recording the time interval from step start to completion). These time indicators are crucial parameters for measuring node processing capabilities and network latency, directly impacting the accuracy and efficiency of global synchronization. Data extraction utilizes a structured parsing method, extracting field values ​​according to a predefined message format, supporting format version compatibility and error recovery. Complete data collection ensures that synchronization control decisions are based on comprehensive global information, avoiding biased decisions caused by partial information and improving the overall coordination and stability of the system.

[0058] The difference between the stepping time of each simulation node and the preset stepping period is calculated, and this difference is recorded as the single-node time deviation. Time deviation calculation is a crucial step in evaluating node performance matching, quantifying the difference between the actual processing speed and the expected speed of a node. The calculation process first determines the system's preset standard stepping period, which is an ideal time interval set based on simulation requirements and performance targets; then, the difference between the actual stepping time of each node and the standard period is calculated to obtain the time deviation value. A positive deviation indicates that the node's processing speed is slower than expected, potentially facing performance pressure; a negative deviation indicates that the processing speed is faster than expected, suggesting insufficient resource utilization. The deviation calculation formula is:

[0059] ;

[0060] in, For nodes Time deviation, For nodes The step time, The preset stepping period.

[0061] Time deviation analysis employs statistical methods to calculate the mean, variance, and distribution characteristics of the deviation, identifying performance anomalies and trend changes in the system. Accurate deviation assessment is the foundation of adaptive time management, providing a basis for subsequent load balancing and resource scheduling decisions.

[0062] The maximum time deviation of each individual node in the time management cluster is calculated and recorded as the time synchronization error. Determining the synchronization error is a crucial step in global time control, using the "barrel principle" to determine the overall synchronization state of the system. The statistical process iterates through the time deviations of all nodes, identifying the largest positive deviation, which represents the gap between the slowest node in the system and its expected performance. The synchronization error calculation formula is as follows:

[0063] ;

[0064] in, For time synchronization error, For nodes Time deviation, This represents the total number of nodes.

[0065] The error value directly reflects the time synchronization quality of the system; the closer it is to zero, the closer the system is to its ideal state. For heterogeneous systems, due to large differences in node performance, significant synchronization errors often occur, requiring adjustments through compensation mechanisms. Error statistics employ a rolling window method, comprehensively considering error values ​​from multiple recent steps to avoid over-adjustment caused by a single fluctuation. Comprehensive error assessment ensures the accuracy and stability of compensation decisions, providing reliable foundational data for achieving high-precision time synchronization.

[0066] A time compensation amount is generated based on the time synchronization error, and this compensation is added to the stepping cycle in the next time step. Compensation generation is the core mechanism of adaptive synchronization, eliminating accumulated errors by dynamically adjusting stepping parameters. The generation process first analyzes the nature and trend of the synchronization error, distinguishing between random fluctuations and systematic deviations; then, based on the error characteristics and system requirements, it calculates the appropriate compensation amount and application method. The compensation amount calculation uses a proportional-integral controller (PIController) method, comprehensively considering the current error value and historical accumulated errors to achieve a stable compensation effect. The compensation amount calculation formula is:

[0067] ;

[0068] in, For time compensation amount, This represents the current time synchronization error. This is due to historical accumulated error. and These are the proportional and integral coefficients.

[0069] The compensation is applied using an additive approach, adding the calculated compensation value to the standard step cycle in the next round to form the adjusted actual step interval. This closed-loop feedback mechanism can automatically adapt to changes in node performance and network state fluctuations, maintaining the long-term stable operation of the system. Adaptive compensation strategies are a key technology for heterogeneous system collaboration, solving the synchronization problem caused by performance imbalances and improving the accuracy and stability of distributed simulation.

[0070] In this embodiment of the invention, the detailed implementation steps for extracting the set of data types to be published and the set of data types to be subscribed from the data interaction configuration file include:

[0071] The system reads data structure descriptions defined in the data interaction configuration file. These descriptions include basic and composite data types. Data structure descriptions are the core of the interaction configuration, defining the format specifications for data transmission between systems. The reading process first opens the configuration file to verify file format and version compatibility; then, it parses the file content to extract the data structure definitions. The data structures use a hierarchical description approach. Basic data types are predefined atomic types, such as integers, floating-point numbers, and strings, with fixed sizes and encoding rules. Composite data types are structured types built from basic types and other composite types, such as structs, arrays, and maps, supporting nested definitions and recursive references. The description information is organized in a three-tier structure of type-field-attribute. Each type definition contains a unique identifier, semantic description, and a list of fields. Each field contains a name, type reference, and constraints. The parsing process uses a recursive descent algorithm to handle nested definitions, constructing a complete type dependency graph to ensure the integrity and consistency of type definitions, providing a unified format foundation for subsequent data exchange.

[0072] For composite data types, nested data members are recursively parsed until all members are primitive data types. Recursive parsing is a key method for handling complex data structures, ensuring that deep hierarchical structures are fully resolved. The parsing process employs a depth-first strategy, starting with the top-level composite type and expanding nested members layer by layer. For each composite type, its direct member list is first identified, and then the type of each member is checked: if it is a primitive type, parsing is complete; if it is a composite type, the same parsing process is recursively applied until a primitive type is reached. The recursive process uses a type caching mechanism to avoid repeatedly parsing already processed types, optimizing performance and handling circular references. To prevent excessive recursion from causing stack overflow, an iterative simulation of recursion is used in the implementation, employing an explicit stack to manage the parsing state. Complete recursive parsing ensures the full expansion of complex data structures, revealing the complete internal composition of the data and providing precise guidance for subsequent serialization and deserialization. This bottom-up type expansion method is the foundation for handling data structures of arbitrary complexity, enabling the system to adapt to various complex data exchange needs.

[0073] Based on the publication identifier in the data interaction configuration file, data types identified as to be published are added to the set of data types to be published. Publication type identification is a crucial step in determining a node's output capabilities, clarifying the types of data the node can provide. The identification process parses the interaction rules section of the configuration file, extracting type definition references with publication identifiers. Publication identifiers are typically represented by explicit tags, such as the "publish" attribute or a dedicated tag element, clearly indicating that this type of data will be generated and sent to the network by this node. Type references use unique identifiers and are associated with the type definition section to ensure type consistency. The identification results are organized into a publication type set, containing key information such as type identifiers, topic names, and publication parameters. The set construction process performs type dependency checks to ensure that all dependent types are also correctly loaded and processed, avoiding runtime type resolution errors. The complete publication type set defines the node's data production capabilities, serves as the direct basis for creating the data writer, and provides clear functional specifications for subsequent communication initialization.

[0074] Based on the subscription identifiers in the data interaction configuration file, data types identified as being subscribed to are added to the set of data types requiring subscription. Subscription type identification is a crucial step in determining node input requirements, clarifying the types of data the node needs to receive from external sources. The identification process is similar to that of publishing types, parsing type references with subscription identifiers in the configuration file. Subscription identifiers are represented using dedicated tags such as the "subscribe" attribute, indicating that the node expects to receive this type of external data. In addition to basic type references, subscription rules typically include data filtering conditions, priority settings, and callback function binding information for fine-grained control over data reception and processing behavior. The identification results are organized into a set of subscription types, serving as the direct basis for creating data readers. The set construction process performs integrity verification to ensure that each subscription type has a corresponding callback processing function, avoiding issues where data cannot be processed after reception. Clear subscription type definitions enable nodes to selectively receive data of interest, reducing the processing burden of irrelevant data, improving system resource utilization efficiency, and laying the foundation for efficient distributed data exchange.

[0075] In this embodiment of the invention, the detailed implementation steps for determining whether all time control nodes have completed stepping or are requesting stepping include:

[0076] This system acquires the current status information of all time control nodes in the time management cluster. The current status includes idle, step-in request, and step-complete states. Node status acquisition is the data foundation for global synchronization judgment, providing a snapshot of the system's current operating state. The acquisition process first constructs a query request, specifying all time control nodes as the target; then, it sends a status query command through the cluster management interface; finally, it receives and parses the returned status data. Status information is represented by an enumeration type, including three basic states: idle (node ​​is not currently participating in time advancement activities and is waiting for a new simulation task); step-in request (node ​​has initiated a time advancement request and is waiting for global permission); and step-complete (node ​​has completed data processing for the current step cycle and entered a stable state). Status acquisition employs an efficient batch query mechanism, retrieving the status of multiple nodes in a single request, reducing the number of network interactions. To handle query latency and network instability, the implementation uses status caching and timeout retry mechanisms to ensure the completeness and timeliness of the acquired status information. This comprehensive state awareness capability is the foundation for distributed coordination, providing the necessary global perspective for synchronization decisions.

[0077] For time control nodes whose current state is idle, they are determined not to meet the stepping conditions. Idle node determination is a conservative measure to prevent excessively rapid time progression, ensuring all control nodes participate in synchronization decisions. The determination process checks the state flag of each time control node; if an idle node is found, it is directly determined that it is not ready to participate in this time progression. An idle state typically indicates that the node is in the initialization phase, waiting for user input, or executing a non-simulation task, and has not entered the normal time loop flow. For federated simulations, the idle state of a control node is a blocking signal, indicating that the system has not yet achieved progress consistency and needs to wait for the node to join the time synchronization process. The determination result will lead to the rejection of stepping requests, preventing an inconsistent state where some nodes advance prematurely while others lag behind. This conservative strategy based on full participation, while potentially reducing the peak progress speed of the system, effectively guarantees the temporal integrity in the distributed environment, avoids causal errors caused by time fragmentation, and improves the reliability of simulation results.

[0078] For time control nodes whose current status is either in the step request or step completion state, their simulation time is further compared with the target simulation time. Comparison of active node times is the core of the step decision, ensuring that time progression does not violate global causality. The comparison process obtains the current simulation time of each non-idle node and compares it numerically with the requested target time. Simulation time is a logical time concept, representing the physical moment currently simulated by the node, and is independent of the actual physical execution time. The comparison is based on scalar values ​​at time points, using size relation operators to determine the order. To handle compatibility issues with different time units and starting points, the system performs a standardization conversion before comparison to ensure a unified measurement standard. Time comparison uses precise arithmetic to correctly handle floating-point precision issues and time representation boundaries, avoiding judgment errors caused by rounding errors. Complete time comparison ensures that the time state of each node is correctly evaluated, providing an accurate time sequence relationship for the final step decision, and is a key guarantee for maintaining global causal consistency.

[0079] The stepping condition is considered met when all time control nodes are not idle and the simulation time of each node is not less than the target simulation time. The final logic of the stepping decision is a comprehensive global condition judgment, based on complete node state and time information. The judgment process uses an AND logic to combine two key conditions: first, all control nodes must be in a non-idle state, indicating that the system has fully entered normal operation mode; second, the current time of all nodes is not behind the target time, indicating that advancing to the target time will not cross unprocessed event regions. Only when both conditions are met simultaneously can the stepping be considered safe and feasible. The comprehensive judgment adopts a fast-fail strategy; once any node that does not meet the conditions is found, a failure result is immediately returned to avoid unnecessary full checks. A successful judgment indicates that the system has reached a consensus on advancement, the target time point is the next stable point for global safety, and the actual state update operation can be executed. This conservative judgment strategy based on a global perspective ensures causal consistency and predictable behavior in the distributed environment, and is the core technical guarantee for achieving reliable distributed simulation.

[0080] The above describes a heterogeneous simulation system access method based on HLA and DDS in the embodiments of this application. The following describes a heterogeneous simulation system access system based on HLA and DDS in the embodiments of this application. Please refer to [link to relevant documentation]. Figure 2 An embodiment of a heterogeneous simulation system access system based on HLA and DDS in this application includes:

[0081] The DDS communication initialization module is used to initialize the DDS communication component, create a DDS communication handle, and complete the publication and subscription registration of data types based on the DDS communication handle, and generate initialized simulation nodes.

[0082] The time management configuration module is used to add initialized simulation nodes to the time management cluster, configure node time-limited attributes and node time control attributes according to the role of the simulation node in the co-simulation, and generate the configured simulation node.

[0083] The message processing module is used to receive messages to be published through the DDS communication handle, classify the messages to be published into time-series messages or ordinary messages according to the correlation between the timestamp of the message to be published and the current simulation time and the node time control attributes, and execute message publishing. At the same time, the received subscription messages are stored in the message cache.

[0084] The time stepping request module is used to initiate a time stepping request to the time management cluster based on the configured simulation nodes. According to the node time control attributes of each simulation node in the time management cluster and the current simulation time, it performs a stepping feasibility judgment to determine whether it is possible to step to the target simulation time.

[0085] The historical message processing module is used to filter historical messages with timestamps no greater than the target simulation time from the message cache after the step feasibility judgment is passed, perform a data refresh operation, process the historical messages in chronological order through callback functions, and generate step reply information after the time step is completed.

[0086] The time synchronization compensation module is used to collect the step response information returned by each simulation node in the time management cluster, calculate the time synchronization error between each simulation node and generate the time compensation amount, and apply the time compensation amount to the next round of time stepping.

[0087] The modules are connected via wired and / or wireless means to enable data transmission between them.

[0088] This invention enables the integration of heterogeneous simulation systems based on HLA and DDS through DDS communication component initialization, time management cluster configuration, message classification and processing, time step management, data refresh operations, and distributed time synchronization. The time management and synchronization method of this invention can precisely control the event sequence and data flow in a distributed environment, effectively solving the interoperability problem between heterogeneous systems and providing a unified access framework for large-scale distributed simulation.

[0089] The above description is merely a preferred embodiment of the present invention and is not intended to limit the present invention. Although the present invention has been described in detail with reference to the foregoing embodiments, those skilled in the art can still modify the technical solutions described in the foregoing embodiments or make equivalent substitutions for some of the technical features. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the protection scope of the present invention.

[0090] It should be noted that all formulas in this manual are calculated by removing dimensions and taking their numerical values. The formulas are derived from software simulations based on a large amount of collected data to obtain the most recent real-world results. The preset parameters and thresholds in the formulas are set by those skilled in the art according to the actual situation.

[0091] Although embodiments of the invention have been shown and described, those skilled in the art will understand that various changes, modifications, substitutions and alterations can be made to these embodiments without departing from the principles and spirit of the invention, the scope of which is defined by the claims and their equivalents.

Claims

1. A method for accessing heterogeneous simulation systems based on HLA and DDS, characterized in that, include: Initialize the DDS communication component, create a DDS communication handle, and complete the data type publication and subscription registration based on the DDS communication handle to generate an initialized simulation node; Add the initialized simulation node to the time management cluster, configure the node time-limited attribute and node time control attribute according to the role of the simulation node in the co-simulation, and generate the configured simulation node. The message to be published is received through the DDS communication handle. Based on the correlation between the timestamp of the message to be published and the current simulation time, as well as the node time control attribute, the message to be published is classified into a time-series message or a normal message and the message is published. At the same time, the received subscription messages are stored in the message cache. Based on the configured simulation node, a time stepping request is initiated to the time management cluster. According to the node time control attribute of each simulation node in the time management cluster and the current simulation time, a stepping feasibility determination is performed to determine whether it is possible to step to the target simulation time. Once the feasibility determination of the step is passed, historical messages with timestamps no greater than the target simulation time are filtered from the message cache, and a data refresh operation is performed to process the historical messages sequentially through callback functions in chronological order. After the time step is completed, step reply information is generated. Collect the step response information returned by each simulation node in the time management cluster, calculate the time synchronization error between each simulation node and generate a time compensation amount, and apply the time compensation amount to the next round of time stepping.

2. The method according to claim 1, characterized in that, The process of initializing the DDS communication component, creating a DDS communication handle, and completing data type publication and subscription registration based on the DDS communication handle to generate an initialized simulation node includes: The communication domain identifier is determined based on the system level to which the simulation system belongs, and the DDS communication handle is created based on the communication domain identifier; The data interaction configuration file of the simulation system is parsed, and the set of data types to be published and the set of data types to be subscribed to are extracted from the data interaction configuration file; Iterate through the set of data types to be published, create a data writer for each data type in the DDS communication handle, and complete the publication registration. Iterate through the set of data types that need to be subscribed, create a data reader for each data type in the DDS communication handle and bind the corresponding callback function, and generate the initialized simulation node after completing the subscription registration.

3. The method according to claim 1, characterized in that, The step of adding the initialized simulation node to the time management cluster, configuring the node time-constrained attributes and node time control attributes according to the role of the simulation node in the co-simulation, and generating the configured simulation node includes: Obtain the node identifier and node role information of the initialized simulation node, wherein the node role information includes system-level simulation system or single-assembly-level simulation system; The initialized simulation node is registered to the time management cluster by calling the cluster join interface, and the node sequence number assigned by the cluster is obtained; The time management mode is determined based on the node role information. When the node role information is a system-level simulation system, the node time control attribute is set to the enabled state. When the node role information is a single-assembly-level simulation system, the node time-limited attribute is set to the enabled state, and the configured simulation node is generated after the attribute configuration is completed.

4. The method according to claim 1, characterized in that, The step of classifying the message to be published into a time-series message or a regular message and publishing the message based on the correlation between the timestamp of the message to be published and the current simulation time, as well as the node time control attribute, includes: Detect whether the message to be published carries a timestamp field. If it does not carry a timestamp field, mark the message to be published as a normal message and execute the publication through the DDS communication handle. When the message to be published carries a timestamp field, determine whether the node time control attribute is enabled; When the node time control attribute is enabled, check whether the value of the timestamp field is equal to the current simulation time. If they are equal, mark the message to be published as the time-series message and execute the publication. When the node time control attribute is disabled, the message to be published, which carries a timestamp field, will be processed as a normal message and published.

5. The method according to claim 1, characterized in that, The step-by-step feasibility determination, based on the node time control attributes of each simulation node in the time management cluster and the current simulation time, includes: Obtain the node time-constrained attribute of the configured simulation node; When the node time-limited attribute is in an unactivated state, the feasibility determination of the step is directly passed; When the node time-restricted attribute is enabled, traverse all time control nodes in the time management cluster whose node time control attribute is enabled. Determine whether all the time control nodes have completed stepping or are requesting stepping, and whether the simulation time of each time control node is not less than the target simulation time. If the conditions are met, the stepping feasibility determination is passed.

6. The method according to claim 1, characterized in that, The process involves filtering historical messages from the message cache whose timestamps are not greater than the target simulation time, performing a data refresh operation, processing the historical messages sequentially through callback functions according to their time order, and generating step-by-step response information after completing the time stepping, including: Filter historical messages whose timestamps are not greater than the target simulation time from the message cache, and generate a message queue to be refreshed; Sort the historical messages in the message queue to be refreshed in ascending order by timestamp; The historical messages are retrieved sequentially from the sorted message queue to be refreshed, and the corresponding callback function is called according to the data type to complete the callback processing. The processed historical messages are then removed from the message cache. Once the message queue to be refreshed is cleared, the step completion timestamp and step time are recorded, and the step reply information is generated.

7. The method according to claim 1, characterized in that, The process of collecting the step response information returned by each simulation node in the time management cluster, calculating the time synchronization error between each simulation node, and generating a time compensation amount includes: Receive the step response information returned by each simulation node in the time management cluster, and extract the step completion timestamp and step time from the step response information; Calculate the difference between the step time of each simulation node and the preset step cycle, and record the difference as the single-node time deviation; The maximum value of the single-node time deviation of all simulation nodes in the time management cluster is calculated, and the maximum value is recorded as the time synchronization error. The time compensation amount is generated based on the time synchronization error.

8. The method according to claim 2, characterized in that, The step of extracting the set of data types to be published and the set of data types to be subscribed from the data interaction configuration file includes: Read the data structure description information defined in the data interaction configuration file, the data structure description information including basic data types and composite data types; For the composite data type, recursively parse its nested data members until all members are of the basic data type; According to the publishing identifier in the data interaction configuration file, the data types identified as being published are added to the set of data types that need to be published; Based on the subscription identifier in the data interaction configuration file, the data types identified as being subscribed are added to the set of data types that need to be subscribed.

9. The method according to claim 5, characterized in that, The determination of whether all the time control nodes have completed stepping or are requesting stepping includes: Obtain the current status information of all time control nodes in the time management cluster, including idle status, step request status, and step completion status; For the time control node whose current state information is idle, it is determined that it does not meet the stepping condition; For the time control node whose current status information is either in the step request state or the step completed state, its simulation time is further compared with the target simulation time. When the current state information of all the time control nodes is not idle, and the simulation time of each time control node is not less than the target simulation time, the stepping condition is determined to be satisfied.

10. A heterogeneous simulation system access system based on HLA and DDS, used to implement the heterogeneous simulation system access method based on HLA and DDS as described in any one of claims 1 to 9, characterized in that, include: The DDS communication initialization module is used to complete the initialization of DDS communication components and the publication and subscription registration of data types, and generate initialized simulation nodes. The time management configuration module is used to connect the initialized simulation node to the time management cluster and complete the time management attribute configuration, thereby generating a configured simulation node. The message processing module is used to classify and publish messages to be published and to manage the caching of received subscription messages; The time stepping request module is used to initiate a time stepping request to the time management cluster and perform a stepping feasibility determination. The historical message processing module is used to perform ordered callback processing on the cached historical messages and generate step-by-step response information after the step feasibility determination is passed. The time synchronization compensation module is used to calculate the time synchronization error based on the step response information of each simulation node and generate a time compensation amount, which is then applied to the next round of time stepping.

Images