Isochronic scaling based high frequency simulation data dynamic control interaction method, system, terminal and medium

Abstract

The application discloses a high-frequency simulation data dynamic control interaction method and system based on isochronous scaling, a terminal and a medium, and relates to the technical field of simulation.The technical scheme is as follows: at the starting point of each fixed control period, a synchronous control hub encapsulates control instructions and time stamps into broadcast frames and simultaneously sends them to all physical PLCs and simulation instances;after the broadcast is completed, a blocking waiting timer is started, and all controlled nodes are waited for returning confirmation signals in the current period;if all the confirmation signals are received, the blocking is released and the next period is entered;if there is an abnormal node, an intelligent fault-tolerant module is triggered to take over data and inject the system data stream.The application realizes the hard synchronization of the simulation process and the physical clock, solves the timing mismatch problem caused by time drift in the semi-physical simulation, and improves the fidelity and reliability of the cluster control system verification.

Description

Technical Field

[0001] This invention relates to the field of simulation technology, and more specifically, to a dynamic control interaction method, system, terminal, and medium for high-frequency simulation data based on isochronous scaling. Background Technology

[0002] Wind farm cluster control systems rely on real-time monitoring of the status of multiple wind turbines, precise issuance of control commands, and dynamic optimization of collaborative strategies to achieve safe, efficient, and economical wind farm operation. The development and verification of this system requires large-scale wind turbine linkage experiments to reproduce complex operating conditions, thereby optimizing scheduling strategies and improving overall stability and operational efficiency. However, relying solely on physical wind turbines for experiments presents significant challenges: not only are the costs of turbine procurement, deployment, and long-term maintenance extremely high, but frequent strategy iterations during experiments can easily cause irreversible damage to the mechanical and electrical control components of the turbines, and even pose safety risks. Therefore, using simulation technology to replace physical turbines has become the mainstream choice in the industry to reduce costs and risks. Some simulation software, as mainstream turbine simulation tools in the industry, possess high-precision aerodynamic and mechanical model simulation capabilities and are indispensable core tools in cluster control system experimental scenarios. However, although simulation can effectively simulate wind turbine behavior and support rapid iteration, its models still have inherent limitations and cannot fully reproduce the nonlinear characteristics, signal interference, communication delays, and physical boundary behaviors under extreme conditions in real hardware systems. Therefore, retaining some physical fans or key hardware in the experimental platform remains an indispensable step for ultimately verifying the functionality, reliability, and safety of the control system in a real-world environment. Thus, a hardware-in-the-loop simulation platform becomes a necessary solution that balances verification realism, experimental economy, and engineering feasibility.

[0003] In wind farm cluster control systems, the centralized control system needs to synchronously issue control commands to all controlled units according to a fixed physical cycle and strictly adhere to the same timing reference when receiving operational status feedback from each unit. This high-frequency closed-loop interaction across physical and virtual boundaries requires that the response rhythm of all units, whether in physical or simulated form, must be highly consistent with the global clock of the centralized control system to truly ensure that the verification of multi-unit collaborative control strategies has realistic timing logic and reliable closed-loop performance. However, traditional simulation technology uses independent local clocks, and its simulation step size is dynamically affected by model complexity and real-time computing resources, resulting in inherent time drift characteristics. This leads to a fundamental scale deviation between the flexible time in the simulation environment and the rigid clock in the physical world. Due to the lack of a synchronization mechanism that forces the simulation process into the physical timing framework, the status feedback of the simulated wind turbines cannot be aligned with the command cycle of the centralized control system and the response timing of the physical PLC (Programmable Logic Controller), thus introducing uncertain delays and logical misalignments in the closed loop. This not only makes it difficult for simulation platforms to accurately reproduce the dynamic coupling effects in real-world scenarios, but also severely restricts the feasibility and effectiveness of high-confidence hardware-in-the-loop verification of cluster control systems during the development phase.

[0004] Therefore, researching and designing a dynamic control interaction method, system, terminal, and medium based on isochronous scaling of high-frequency simulation data that can overcome the above-mentioned defects is an urgent problem to be solved. Summary of the Invention

[0005] To address the shortcomings of existing technologies, the present invention aims to provide a dynamic control interaction method, system, terminal, and medium based on isochronous scaling of high-frequency simulation data. This method forcibly incorporates the simulation process into the physical clock scheduling framework, enabling precise alignment between the state feedback of the simulated wind turbine and the instruction cycle of the cluster control system, as well as the response timing of the physical PLC. This allows for the reproduction of the complex dynamics and precise timing logic of multi-unit collaborative operation in a real wind farm within a laboratory environment, significantly improving the authenticity, reliability, and effectiveness of hardware-in-the-loop simulation verification.

[0006] The above-mentioned technical objective of the present invention is achieved through the following technical solution: Firstly, a dynamic control interaction method based on high-frequency simulation data using isochronous scaling is provided, applied to a hardware-in-the-loop simulation platform for cluster control systems. This platform comprises at least one physical PLC and multiple simulation instances, and includes the following steps: At the start of each fixed control cycle locked by an external high-precision clock, the synchronization control center receives control command vectors and global environment data from the cluster control system, and encapsulates the control command vectors, the global environment data, the global cycle number, and the high-precision timestamp into a broadcast frame, which is then simultaneously sent to all the physical PLCs and all the simulation instances via multicast or broadcast protocols. After the synchronous control center completes the broadcast frame transmission, it starts a blocking wait timer. The timeout of the blocking wait timer is set to be equal to the length of the fixed control cycle minus a preset protection margin, and waits for all controlled nodes to return a confirmation signal that the calculation of this cycle is completed within the current fixed control cycle. If the synchronization control center receives confirmation signals from all controlled nodes before the current fixed control cycle ends, the blockage is lifted and the next fixed control cycle begins. If there are abnormal nodes that have not returned confirmation signals before the current fixed control cycle ends, the intelligent fault-tolerant module is triggered to take over the data of the abnormal nodes, generate an equivalent status data packet, and inject it into the system data stream through the shared memory channel.

[0007] Furthermore, the method also includes: The parallel scheduling controller maintains a registry containing all active simulation instance identifiers and resource mappings, binds the broadcast frames with differentiated micro-environment data to generate personalized computing task packages, and simultaneously distributes them to the corresponding computing nodes in the parallel computing engine pool through a low-latency internal communication bus. The parallel computing engine pool uses operating system-level containerization technology and resource control group mechanism to pre-allocate and lock a specific number of CPU cores, memory blocks and I / O bandwidth for each container, thereby achieving resource isolation and quota control.

[0008] Furthermore, the method also includes: The acceleration module consists of a pre-computation synchronous input optimization stage, an in-computation intelligent data compression stage, and a post-computation zero-wait channel delivery stage, which compresses and stabilizes the time consumption of each stage within the microsecond range. In the pre-computation synchronous input optimization stage, data frames are simultaneously written to a predetermined memory area accessible to all computing nodes through multicast communication protocol or shared memory mapping technology, and hardware synchronization pulse signals are generated in conjunction with an external precision clock source to trigger all simulation instances to simultaneously read the input data of this cycle from the shared memory area and start the calculation immediately. The intelligent data compression stage in the calculation adopts a dynamic differential compression mechanism, which forcibly inserts key frames that record the full values ​​of all variables at fixed time periods, or immediately inserts key frames when the change of any variable exceeds a preset emergency threshold. When the key frame conditions are not met, the difference between the current value and the previous retained value of each variable is calculated independently and a judgment is made independently according to the preset dynamic compression threshold. If the absolute value of the difference is not greater than the threshold, it is discarded; otherwise, it is encoded and transmitted. The receiving end recovers the variable value by accumulating the difference value and resets the accumulated error periodically through key frames. The zero-wait channel delivery phase after computation bypasses the operating system network protocol stack and establishes a shared memory area between the memory space of the simulation process and the memory space of the cluster control system process as a direct data channel. The compressed data packets are written to the specified location of the shared channel through direct memory access or efficient memory copy operation, and the data ready notification signal is obtained by modifying atomic variables in the shared memory area or triggering user-mode interrupt events.

[0009] Furthermore, the method also includes: The intelligent fault-tolerant module continuously collects the computation progress, process status and time margin of each simulation instance through a high-precision monitor, and makes forward-looking predictions in the middle of the cycle based on a preset computation time consumption model and historical data to assess the risk level of each simulation instance completing the computation on time. The intelligent fault-tolerant module uses a hierarchical strategy decision-making and arbitrator to pre-set a multi-level fault-tolerant strategy library that includes interpolation strategy, last effective value preservation strategy and safe state injection strategy, and selects the corresponding fault-tolerant strategy based on the risk assessment results of the high-precision monitor. Specifically, when the interpolation strategy predicts that the computation of the abnormal node will be delayed but can be completed at the start of the next cycle, it uses historical valid state data from the most recent cycles to estimate the expected value for the current cycle through linear or quadratic extrapolation algorithms; when the last valid value preservation strategy detects that the computation has been severely interrupted or prematurely terminated, it directly outputs the valid state data verified in the previous cycle; when the safe state injection strategy detects continuous timeouts or system-level failures, it forces the key control variables of the abnormal node to be set to predefined absolute safe values, generates a logical isolation state identifier for the abnormal node, and notifies the cluster control system to suspend issuing control commands to the abnormal node. The intelligent fault-tolerant module sends a safety suspension signal to the problem simulation instance through the data takeover engine, and generates a wind turbine status data packet that meets the requirements of the selected strategy in real time. It is then seamlessly injected into the system data stream through the shared memory channel, so that the cluster control system cannot detect that the data packet originates from the intelligent fault-tolerant module in terms of interface, timing and format.

[0010] Secondly, a dynamic control interaction system based on isochronous scaling high-frequency simulation data is provided, applied to a hardware-in-the-loop simulation platform for cluster control systems. The hardware-in-the-loop simulation platform includes at least one physical PLC and multiple simulation instances. The system comprises: The synchronization control center is configured as follows: At the start of each fixed control cycle locked by an external high-precision clock, control command vectors and global environment data are received from the cluster control system. The control command vectors, global environment data, global cycle number, and high-precision timestamp are encapsulated into a broadcast frame and simultaneously sent to all physical PLCs and all simulation instances via multicast or broadcast protocol. After the broadcast frame is sent, a blocking wait timer is started. The timeout of the blocking wait timer is set to be equal to the length of the fixed control cycle minus a preset protection margin. The timer waits for all controlled nodes to return a confirmation signal that the calculation of this cycle is completed within the current fixed control cycle. If acknowledgment signals from all controlled nodes are received before the current fixed control cycle ends, the blockage is lifted and the next fixed control cycle begins; if there are abnormal nodes that have not returned acknowledgment signals before the current fixed control cycle ends, the intelligent fault-tolerant module is triggered to take over the data of the abnormal nodes.

[0011] Furthermore, the system also includes: Parallel simulation cluster, comprising a parallel scheduler controller and a parallel computing engine pool; The parallel scheduling controller is configured to maintain a registry containing all active simulation instance identifiers and resource mappings, bind the broadcast frames with differentiated micro-environment data to generate personalized computing task packages, and simultaneously distribute them to the corresponding computing nodes in the parallel computing engine pool via a low-latency internal communication bus. The parallel computing engine pool consists of multiple high-performance computing nodes, each of which is equipped with multiple lightweight isolated containers. Each container corresponds to a simulation instance and is preloaded with the same high-fidelity simulation kernel and parameter configuration file of the simulation instance. The parallel computing engine pool uses operating system-level containerization technology and resource control group mechanism to pre-allocate and lock a certain number of CPU cores, memory blocks and I / O bandwidth for each container to achieve resource isolation and quota control.

[0012] Furthermore, the system also includes: The acceleration module is configured to form an accelerated processing pipeline through a pre-computation synchronous input optimization stage, an in-computation intelligent data compression stage, and a post-computation zero-wait channel delivery stage, compressing and stabilizing the time consumption of each stage within the microsecond range. In the pre-computation synchronous input optimization stage, data frames are simultaneously written to a predetermined memory area accessible to all computing nodes through multicast communication protocol or shared memory mapping technology, and hardware synchronization pulse signals are generated in conjunction with an external precision clock source to trigger all simulation instances to simultaneously read the input data of this cycle from the shared memory area and start the calculation immediately. The intelligent data compression stage in the calculation adopts a dynamic differential compression mechanism, which forcibly inserts key frames that record the full values ​​of all variables at fixed time periods, or immediately inserts key frames when the change of any variable exceeds a preset emergency threshold. When the key frame conditions are not met, the difference between the current value and the previous retained value of each variable is calculated independently and a judgment is made independently according to the preset dynamic compression threshold. If the absolute value of the difference is not greater than the threshold, it is discarded; otherwise, it is encoded and transmitted. The receiving end recovers the variable value by accumulating the difference value and resets the accumulated error periodically through key frames. The zero-wait channel delivery phase after computation bypasses the operating system network protocol stack and establishes a shared memory area between the memory space of the simulation process and the memory space of the cluster control system process as a direct data channel. The compressed data packets are written to the specified location of the shared channel through direct memory access or efficient memory copy operation, and the data ready notification signal is obtained by modifying atomic variables in the shared memory area or triggering user-mode interrupt events.

[0013] Furthermore, the system also includes: The intelligent fault-tolerant module is configured to continuously collect the computation progress, process status and time margin of each simulation instance through a high-precision monitor, and make forward-looking predictions in the middle of the cycle based on a preset computation time consumption model and historical data to assess the risk level of each simulation instance completing the computation on time. The intelligent fault-tolerant module is also configured to select the appropriate fault-tolerant strategy based on the risk assessment results of the high-precision monitor by using a hierarchical strategy decision-making mechanism and an arbitrator to pre-set a multi-level fault-tolerant strategy library that includes interpolation strategy, last effective value preservation strategy and safe state injection strategy. Specifically, when the interpolation strategy predicts that the computation of the abnormal node will be delayed but can be completed at the start of the next cycle, it uses historical valid state data from the most recent cycles to estimate the expected value for the current cycle through linear or quadratic extrapolation algorithms; when the last valid value preservation strategy detects that the computation has been severely interrupted or prematurely terminated, it directly outputs the valid state data verified in the previous cycle; when the safe state injection strategy detects continuous timeouts or system-level failures, it forces the key control variables of the abnormal node to be set to predefined absolute safe values, generates a logical isolation state identifier for the abnormal node, and notifies the cluster control system to suspend issuing control commands to the abnormal node. The intelligent fault-tolerant module is also configured to send a safety suspension signal to the problem simulation instance through the data takeover engine, and generate a wind turbine status data packet that meets the policy requirements in real time according to the selected policy. The data packet is then seamlessly injected into the system data stream through the shared memory channel, so that the cluster control system cannot detect that the data packet originates from the intelligent fault-tolerant module in terms of interface, timing and format.

[0014] Thirdly, a computer terminal is provided, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the computer program to implement the dynamic control and interaction method for high-frequency simulation data based on isochronous scaling as described in any one of the first aspects.

[0015] Fourthly, a computer-readable medium is provided having a computer program stored thereon, the computer program being executed by a processor to implement the dynamic control interaction method for high-frequency simulation data based on isochronous scaling as described in any one of the first aspects.

[0016] Compared with the prior art, the present invention has the following beneficial effects: 1. The high-frequency simulation data dynamic control interaction method based on isochronous scaling provided by this invention encapsulates the control command vector, global environment data, global cycle number, and high-precision timestamp into a broadcast frame at the beginning of each fixed control cycle locked by an external high-precision clock. This frame is then simultaneously distributed to all physical PLCs and all simulation instances via multicast or broadcast protocols. This achieves microsecond-level synchronous arrival of commands at the physical transmission layer, providing a completely consistent command starting point and time reference for the entire system. Based on this, the synchronous control center starts a blocking wait timer after the broadcast frame is distributed. The timeout of this blocking wait timer is set to be equal to the length of the fixed control cycle minus a preset protection margin. Within the current fixed control cycle, it waits for all controlled nodes to return confirmation signals indicating completion of the current cycle's calculation. When all controlled nodes return confirmation signals on time, the synchronous control center unblocks and enters the next fixed control cycle. When an abnormal node fails to return a confirmation signal, an intelligent fault-tolerant module is triggered to take over the data of that abnormal node, generating an equivalent status data packet and injecting it into the system data stream through a shared memory channel. This mandatory cycle control mechanism, which involves issuing commands, waiting, and collecting data for advancement, combined with a dual logic design that allows for timeout and fault tolerance, fundamentally solves the time drift and timing mismatch problems caused by the independent local clock driving the simulation process in traditional simulation technologies. Specifically, this mechanism forcibly incorporates the simulation process into the physical clock scheduling framework, ensuring precise alignment between the simulated wind turbine's status feedback, the command cycle of the cluster control system, and the response timing of the physical PLC. This allows for the reproduction of the complex dynamics and precise timing logic of multi-unit collaborative operation in a real wind farm within a laboratory environment, significantly improving the realism, reliability, and effectiveness of hardware-in-the-loop simulation verification.

[0017] 2. This invention maintains a registry containing identifiers and resource mappings of all active simulation instances through a parallel scheduling controller. It binds broadcast frames with differentiated micro-environment data to generate personalized computing task packages, which are then simultaneously distributed to corresponding computing nodes in the parallel computing engine pool via a low-latency internal communication bus. This achieves parallel scheduling and task distribution for large-scale simulation instances. Simultaneously, the parallel computing engine pool, through operating system-level containerization technology and resource control group mechanisms, pre-allocates and locks specific CPU cores, memory blocks, and I / O bandwidth for each container, achieving strict resource isolation and quota control. This invention solves the technical problem of how to drive the parallel operation of large-scale high-fidelity simulation instances at low cost and high efficiency under single-license restrictions. Specifically, containerization technology enables the deployment of multiple isolated simulation instances on a single high-performance computing node, making full use of hardware resources; the resource control group mechanism ensures that the computing load fluctuation of any simulation instance will not affect the runtime performance and progress of other instances, achieving deterministic parallel computing; the data parallel mode achieves horizontal scaling while maintaining the original model fidelity, enabling fifty high-fidelity wind turbine simulation instances to be launched in parallel on five high-performance servers, significantly reducing the overall cost and complexity of hardware-in-the-loop simulation verification.

[0018] 3. This invention constructs an accelerated processing pipeline consisting of a pre-computation synchronous input optimization stage, an in-computation intelligent data compression stage, and a post-computation zero-wait channel delivery stage through an acceleration module, compressing and stabilizing the time consumption of each stage within the microsecond range. In the pre-computation synchronous input optimization stage, data frames are simultaneously written to a predetermined memory area accessible to all computing nodes using multicast communication protocols or shared memory mapping technology. This, in conjunction with an external precision clock source, generates a hardware synchronization pulse signal, triggering all simulation instances to simultaneously read the input data for the current cycle from the shared memory area and immediately begin computation, controlling the synchronization error at the start of the entire cluster computation within the microsecond range. In the in-computation intelligent data compression stage, a dynamic differential compression mechanism is employed. Through the classification and processing of keyframes and transition frames, and differential decision based on a dynamic compression threshold, the total amount of data to be transmitted is significantly reduced while ensuring the required accuracy of the control algorithm. In the post-computation zero-wait channel delivery stage, the operating system network protocol stack is bypassed, establishing a shared memory area as a direct data channel between the simulation process and the cluster control system process. This transforms the inherent millisecond-level, randomly jittered communication latency of traditional network interactions into a deterministic memory access operation with extremely short latency and no jitter. This invention solves the technical problem that inherent delays in data preparation, transmission, and exchange before and after simulation calculations within a fixed physical cycle squeeze the available time window for high-fidelity simulation calculations. By compressing the time consumed in data processing and transmission to a minimum, deterministic value, high-fidelity simulation calculations can achieve a maximized and stable execution time window within a fixed cycle time budget, significantly reducing the risk of cycle timeouts due to data processing and transmission delays.

[0019] 4. This invention continuously collects the computation progress, process status, and time margin of each simulation instance through a high-precision monitor embedded in the intelligent fault-tolerant module. Based on a preset computation time consumption model and historical data, it performs forward-looking predictions in the middle of the cycle to assess the risk level of each simulation instance completing the computation on time, achieving early warning of computational anomalies. Simultaneously, the intelligent fault-tolerant module uses a hierarchical strategy decision-making and arbitrator to preset a multi-level fault-tolerant strategy library including interpolation strategies, last effective value preservation strategies, and safe state injection strategies. It selects the appropriate fault-tolerant strategy based on the risk assessment results of the high-precision monitor, achieving hierarchical response from minor anomalies to severe failures. Furthermore, the intelligent fault-tolerant module sends a safe suspension signal to the problematic simulation instance through a data takeover engine and generates a wind turbine status data packet that meets the strategy requirements in real time according to the selected strategy. This data packet is seamlessly injected into the system data stream through a shared memory channel, making it impossible for the cluster control system to detect that the data packet originates from the intelligent fault-tolerant module in terms of interface, timing, and format. This invention solves the technical problem that the inherent time uncertainty of high-fidelity simulation computation may lead to cycle timeouts or computational anomalies, thereby compromising the timing integrity and system stability of the entire control closed loop. Specifically, the forward-looking prediction mechanism enables the system to prepare for fault tolerance before anomalies occur, the hierarchical strategy ensures that the most appropriate response measures are taken under different degrees of anomalies, and the transparent data injection enables the cluster control system to continue operating without being aware of it. Thus, even when there are fluctuations in the underlying computing, it can still unconditionally maintain the timing integrity, output validity and system stability of the entire control loop, providing the system with crucial fault tolerance and operational resilience. Attached Figure Description

[0020] The accompanying drawings, which are included to provide a further understanding of embodiments of the invention and form part of this application, do not constitute a limitation thereof. In the drawings: Figure 1 This is a flowchart from Embodiment 1 of the present invention; Figure 2 This is a system block diagram in Embodiment 4 of the present invention. Detailed Implementation

[0021] To make the objectives, technical solutions, and advantages of the present invention clearer, the present invention will be further described in detail below with reference to the embodiments and accompanying drawings. The illustrative embodiments and descriptions of the present invention are only used to explain the present invention and are not intended to limit the present invention.

[0022] Example 1: A dynamic control interaction method based on high-frequency simulation data using isochronous scaling is applied to a hardware-in-the-loop simulation platform for a cluster control system. The hardware-in-the-loop simulation platform includes at least one physical PLC and multiple simulation instances, such as... Figure 1 As shown, it includes the following steps: S1: At the start of each fixed control cycle locked by an external high-precision clock, the synchronous control center receives the control command vector and global environment data from the cluster control system, and encapsulates the control command vector, global environment data, global cycle number and high-precision timestamp into a broadcast frame, which is then simultaneously sent to all physical PLCs (Programmable Logic Controllers) and all simulation instances via multicast or broadcast protocol. S2: After the synchronous control center completes the broadcast frame transmission, it starts a blocking wait timer. The timeout of the blocking wait timer is set to be equal to the length of the fixed control cycle minus the preset protection margin, and waits for the completion confirmation signal of the current cycle calculation returned by all controlled nodes within the current fixed control cycle. S3: If the synchronous control center receives confirmation signals from all controlled nodes before the current fixed control cycle ends, the blockage is lifted and the next fixed control cycle begins; if there are abnormal nodes that have not returned confirmation signals before the current fixed control cycle ends, the intelligent fault tolerance module is triggered to take over the data of the abnormal nodes, generate an equivalent status data packet, and inject it into the system data stream through the shared memory channel.

[0023] In step S1, this embodiment applies a hardware-in-the-loop simulation platform for a cluster control system. This platform includes at least one physical PLC and multiple simulation instances. The physical PLC corresponds to a real, complete wind turbine, receiving control signals from the cluster control system and executing corresponding operations through its own hardware and control logic, outputting feedback on the actual main control operating status. The simulation instances, based on a high-fidelity simulation kernel, simulate the aerodynamic and mechanical responses and environmental adaptability characteristics of a complete wind turbine through built-in model calculations. The physical PLC and simulation instances together constitute the unit carrier for the cluster control system experiment.

[0024] The synchronization control center is the core timing management module of the hardware-in-the-loop simulation platform. It is configured to encapsulate and broadcast synchronization instructions at the beginning of each fixed control cycle, and execute blocking synchronization control logic after the broadcast is completed to achieve hard synchronization between the simulation process and the physical clock.

[0025] An external high-precision clock provides a globally unified time reference for the entire hardware-in-the-loop simulation platform. This external high-precision clock is independent of the local clock of any simulation process or control process, and has timing accuracy at the microsecond or even nanosecond level, effectively eliminating time deviations caused by local clock drift at each node.

[0026] A fixed control cycle is the basic time unit for a cluster control system to synchronously issue control commands to all controlled units and receive status feedback. This fixed control cycle is locked by an external high-precision clock, and its length is typically set to the order of tens of milliseconds. Between the start of every two adjacent fixed control cycles, the cluster control system completes a closed-loop interaction process of command issuance, unit response calculation, and status feedback reception. Locking the fixed control cycle by an external high-precision clock ensures that the response rhythm of all controlled units, whether in physical or simulated form, remains highly consistent with the global clock of the cluster control system.

[0027] At the start of each fixed control cycle locked by an external high-precision clock, the synchronization control center first receives two types of input data from the cluster control system: control command vectors and global environment data.

[0028] The control command vector is a unified set of control signals issued by the cluster control system to all controlled units. It includes active power dispatching commands, reactive power dispatching commands, start-stop control commands, etc., and is used to guide the operating behavior of each wind turbine in the next control cycle. Global environmental data is a set of parameters describing the overall environmental state of the current wind farm, including average wind speed, average wind direction, ambient temperature, air density, etc., providing a unified boundary condition input for the simulation model.

[0029] After receiving the control command vector and global environment data, the synchronization control center performs a broadcast frame encapsulation operation. A broadcast frame is a data unit with a unified structure, containing four components: control command vector, global environment data, global cycle number, and high-precision timestamp.

[0030] The global cycle number is a monotonically increasing integer sequence number used to identify the sequential position of the current fixed control cycle throughout the simulation process. Starting from the initial value at system startup, the global cycle number automatically increments by one after each fixed control cycle. The purpose of the global cycle number is twofold: firstly, to ensure that all controlled nodes clearly understand their current cycle position, avoiding cycle misalignment caused by network latency or data retransmission; and secondly, to provide a reference benchmark for cycle alignment for subsequent lockstep synchronization control and intelligent fault-tolerant modules.

[0031] A high-precision timestamp is a precise time value read from an external high-precision clock, recording the absolute time point when the broadcast frame encapsulation was completed. This high-precision timestamp can achieve microsecond-level accuracy or even higher, providing a unified timing reference for all controlled nodes. This allows each node to accurately grasp the moment the instruction was issued, thus maintaining timing consistency during subsequent calculations and feedback.

[0032] The synchronization control center serializes and encapsulates the above four components according to a predetermined data format to form a complete broadcast frame data packet. The data structure of this broadcast frame uses a compact binary encoding method to minimize data transmission overhead.

[0033] After encapsulating the broadcast frame, the synchronous control center does not use traditional serial or polling communication methods, but instead sends the broadcast frame simultaneously to all pre-registered controlled node addresses via multicast or broadcast communication protocols. These controlled nodes include all physical PLCs and all simulation instances.

[0034] Multicast communication protocols are a one-to-many network communication method. The sending end only needs to send data packets to a specific multicast address, and all receivers that have joined the multicast group can receive the data packets simultaneously. Broadcast communication protocols, on the other hand, send data packets to all nodes within a local area network. A common feature of both protocols is that the sending end only needs to perform a single transmission operation to achieve parallel distribution of data packets at the physical transport layer, avoiding the time overhead and timing differences caused by sending data to each node individually in serial communication.

[0035] The purpose of sending broadcast frames via multicast or broadcast communication protocols is to achieve microsecond-level synchronous arrival of commands at the physical transport layer. Since all controlled nodes receive the exact same broadcast frame content almost simultaneously, a completely consistent command starting point and time reference are provided for the entire system. This synchronous arrival at the physical layer constitutes the first layer of guarantee for the timing alignment of the entire system.

[0036] Through the above steps, the synchronization control center completes the entire process from receiving input data, encapsulating broadcast frames, to synchronously sending them at the beginning of each fixed control cycle. This process ensures that all physical PLCs and all simulation instances receive broadcast frames containing the same control instructions, environmental data, cycle number, and timestamp at the same time, laying a solid timing foundation for subsequent synchronous calculations and feedback at each node. This step is a crucial prerequisite for achieving hard synchronization between the simulation process and the physical clock, fundamentally solving the time drift and timing mismatch problems caused by independent local clock driving in traditional simulation technology.

[0037] In step S2, after completing the broadcast frame distribution operation, the synchronization control center immediately initiates a blocking and waiting mechanism. This blocking and waiting mechanism is the core synchronization control logic of this invention, designed to force the simulation process into the physical clock scheduling framework, achieving precise coupling and alignment between the simulation timeline and the physical timeline.

[0038] The blocking and waiting mechanism is activated precisely after the broadcast frame has been successfully sent and before the start of the next fixed control cycle. This activation is automatically triggered by the logic controller within the synchronization control center, requiring no external intervention. After confirming that the broadcast frame has been successfully sent to all controlled nodes via multicast or broadcast protocol, the synchronization control center immediately sends a signal to the system master thread, causing it to enter a blocking and waiting state.

[0039] The synchronization control center initializes and starts the blocking wait timer simultaneously with initiating the blocking wait mechanism. The blocking wait timer is a high-precision timer used to measure the waiting time from the current moment and triggers the timeout handling logic when the timeout occurs.

[0040] The timeout period of the blocking wait timer is set to be equal to the length of the fixed control cycle minus a preset protection margin. Let the length of the fixed control cycle be T, and the preset protection margin be Δ, then the timeout period of the blocking wait timer... The following relationship must be satisfied: ; The fixed control cycle is the basic time unit for the cluster control system to synchronously issue control commands and receive status feedback from all controlled units, locked by an external high-precision clock. A preset protection margin is used to reserve a safe time window before the fixed control cycle expires, so that in the event of a timeout, the intelligent fault-tolerant module can complete data takeover before the fixed control cycle boundary arrives, ensuring that the system can output valid fan status data before the fixed cycle boundary under any operating condition. The timeout time is the maximum allowable duration for the synchronous control center to wait for acknowledgment signals from all controlled nodes within the current fixed control cycle. When the accumulated count of the blocking wait timer reaches... When the timeout event is triggered, it is considered a timeout event.

[0041] After the blocking wait timer starts, the synchronization control center continuously listens for completion confirmation signals from all controlled nodes within the current fixed control cycle. Controlled nodes include all physical PLCs and all simulation instances.

[0042] This cycle calculation completion confirmation signal is a feedback signal sent by each controlled node to the synchronous control center after completing the calculation task for this fixed control cycle. This confirmation signal contains the node's unique identifier and the status information indicating the completion of the cycle calculation. For a physical PLC, this confirmation signal indicates that the physical PLC has completed the execution of the control instructions and output the actual main control operating status. For a simulation instance, this confirmation signal indicates that the simulation instance has completed high-fidelity simulation calculations and output the fan operating status parameters.

[0043] The synchronization control center maintains a controlled node acknowledgment status table to record the acknowledgment signal reception status of each controlled node. This acknowledgment status table is indexed by the unique identifier of each controlled node; initially, all nodes are marked as not received. Whenever the synchronization control center receives an acknowledgment signal from a controlled node, it updates the corresponding record in the acknowledgment status table to "received."

[0044] The essence of the blocking wait mechanism is to make the system master thread actively enter a waiting state after the broadcast frame is sent, until all controlled nodes have completed the calculation of this cycle and returned an acknowledgment signal, or until the blocking wait timer expires.

[0045] During the blocking wait period, the system master thread suspends all subsequent operations, including but not limited to receiving instructions for the next fixed control cycle, encapsulating and sending broadcast frames, etc. The blocking state of the system master thread will continue until one of the following two conditions is met: Condition 1, the synchronization control center receives acknowledgment signals from all controlled nodes, at which point an unblocking signal is generated, allowing the system master thread to continue execution; Condition 2, the blocking wait timer times out, at which point the timeout handling logic is triggered.

[0046] This mandatory timing control mechanism, which involves issuing commands, waiting, and then accumulating them, essentially forces the system's physical clock cycle to proactively adapt and wait for the simulation calculation cycle to complete. Since the time consumption of simulation calculations is uncertain, while the physical clock cycle is fixed, this blocking and waiting mechanism absorbs the time uncertainty of simulation calculations within a fixed control cycle, thereby achieving precise coupling and alignment between the simulation timeline and the physical timeline at the system level. This mechanism fundamentally eliminates timing mismatches and state misalignments caused by simulation response delays or uncertainties.

[0047] The blocking and waiting mechanism resolves a fundamental contradiction in traditional simulation technology: the simulation process is driven by an independent local clock, and its simulation step size is dynamically affected by model complexity and real-time computing resources, exhibiting inherent time drift characteristics; while the clock in the physical world is rigid and fixed. This discrepancy between these two time scales leads to a misalignment between the simulated wind turbine's state feedback and the command cycle of the cluster control system, as well as the response timing of the physical PLC, thus introducing uncertain delays and logical misalignments into the closed loop.

[0048] Through a blocking and waiting mechanism, the synchronization control center forces the simulation process into the physical clock scheduling framework. Within each fixed control cycle, the synchronization control center waits for all simulation calculations to complete before entering the next cycle, thus constraining the flexible time of the simulation process within the rigid framework of the physical clock. This constraint ensures that the simulated wind turbine can act as a virtual PLC with completely consistent timing behavior, receiving instructions, performing parallel calculations, and providing synchronous feedback within the same fixed cycle as the real wind turbine controller. This allows for the reproduction of the complex dynamics and precise timing logic of multi-unit collaborative operation in a real wind farm within a laboratory environment.

[0049] In step S3, if the synchronization control center receives confirmation signals from all controlled nodes indicating completion of the current cycle calculation before the current fixed control cycle ends, it executes an unblocking operation. The specific process of the unblocking operation is as follows: the synchronization control center sends an unblocking signal to the system master thread, allowing the system master thread to exit the blocked waiting state and continue to execute subsequent operations.

[0050] Upon receiving the unblocking signal, the system's main control thread immediately enters the initial stage of the next fixed control cycle. The starting point of the next fixed control cycle is locked by an external high-precision clock. At this starting point, the synchronization control center will again execute the broadcast frame reception, encapsulation, and transmission operations of step S1, as well as the blocking and waiting operations of step S2. This process repeats continuously, forming a continuous, periodic closed-loop control interaction flow.

[0051] Assuming all controlled nodes return acknowledgment signals on time, the blocking wait time within each fixed control cycle depends on the computation completion time of the slowest node. Since the computational load and capabilities of different controlled nodes may vary, the completion times of each node will differ. The synchronization control center ensures that all nodes complete their computations within the current cycle through a blocking wait mechanism, thereby guaranteeing the timing consistency of the entire system's output data.

[0052] If a controlled node fails to return an acknowledgment signal before the end of the current fixed control cycle, the synchronization control center determines that the node is an abnormal node. The determination of an abnormal node is based on the timeout event of the blocking wait timer. When the accumulated count of the blocking wait timer reaches the preset timeout period, the synchronization control center triggers a timeout event, indicating that there is a controlled node that has not been responded to in a timely manner within the current fixed control cycle.

[0053] The process for identifying abnormal nodes is as follows: The synchronization control center queries the controlled node acknowledgment status table to find all controlled nodes whose acknowledgment status is still marked as "not received." These nodes are the abnormal nodes that failed to complete the calculation and return an acknowledgment signal within the current fixed control cycle. Possible causes of abnormal nodes include, but are not limited to: simulation calculation timeout, abnormal process crash, data communication interruption, hardware failure, etc.

[0054] Upon detecting an abnormal node, the synchronous control center immediately triggers the intelligent fault-tolerant module to take over the data from the abnormal node. The intelligent fault-tolerant module is a reliability assurance component of the hardware-in-the-loop simulation platform. Its core function is to monitor, make intelligent decisions, and seamlessly take over the simulation computing cluster in real time for possible computation timeouts, process anomalies, or data anomalies, ensuring that the system can output logically coherent and engineering-safe wind turbine status data before fixed cycle boundaries under any operating conditions.

[0055] The trigger signal for the intelligent fault-tolerant module is generated and sent by the synchronization control center. This trigger signal contains a unique identifier for the faulty node and information about the fault type. Upon receiving the trigger signal, the intelligent fault-tolerant module immediately initiates the data takeover process.

[0056] Upon receiving a trigger signal, the intelligent fault-tolerant module selects the appropriate fault-tolerant strategy from a pre-defined multi-level fault-tolerant strategy library and generates an equivalent status data packet based on the selected strategy. An equivalent status data packet refers to wind turbine status data that is completely identical to data generated through normal calculations in terms of interface, timing, and format, making it impossible for downstream cluster control systems to detect that the data originates from the fault-tolerant module.

[0057] The multi-level fault tolerance strategy library includes three preset fault tolerance strategies: interpolation strategy, last valid value preservation strategy, and safe state injection strategy. The intelligent fault tolerance module selects the most appropriate fault tolerance strategy based on the specific exception situation of the abnormal node and the current operating state of the system.

[0058] Interpolation strategies are suitable for scenarios with slight computational delays or near completion. When a computational delay is predicted for an abnormal node but can be completed at the start of the next cycle, the intelligent fault-tolerant module employs an interpolation strategy, using historical valid state data from the most recent several cycles to estimate the expected value for the current cycle through linear or quadratic extrapolation algorithms. Let the sequence of historical valid state data from the most recent n cycles be... Until ,in This represents the status data from the previous period. This represents the state data from the previous period, and so on. The calculation formula for the linear extrapolation algorithm is: ; in, This represents the estimated value for the current period. This represents the valid state data from the previous period. This represents the valid state data from the previous period. The quadratic extrapolation algorithm, based on more historical data, considers acceleration factors for a more accurate estimate. The interpolation strategy can provide a smooth and coherent state transition when computational resources are momentarily strained, minimizing the impact on the control loop.

[0059] The last valid value hold strategy is suitable for scenarios where computation is severely interrupted or prematurely terminated. When an abnormal node's computation process is detected to be severely interrupted or prematurely terminated, the intelligent fault-tolerant module adopts the last valid value hold strategy, directly outputting the valid state data verified in the previous cycle. The essence of this strategy is to maintain the system state unchanged during periods of uncertainty, providing a stable and conservative input benchmark for the control algorithm, and is suitable for robust control scenarios that can tolerate single-step delays.

[0060] The safe state injection strategy is applicable to scenarios where consecutive timeouts or system-level faults are detected. When an abnormal node fails to return an acknowledgment signal for multiple consecutive cycles, or when a system-level fault is detected, the intelligent fault-tolerant module employs the safe state injection strategy. At the unit level, this strategy forces the critical control variables of the abnormal node to be set to predefined absolute safe values. These predefined absolute safe values ​​include: a pitch angle of 90 degrees (i.e., feathering blades) and generator torque of zero. These safe values ​​ensure that the virtual wind turbine instantly enters and remains in a safe operating condition, thereby unconditionally preventing control actions from triggering dangerous states in the simulation or logic.

[0061] After generating an equivalent status data packet, the intelligent fault-tolerant module injects the packet into the system data stream via a shared memory channel. The shared memory channel is a data transmission path established during the zero-wait delivery phase after computation in the acceleration module. By bypassing the operating system network protocol stack, a shared memory area is established between the simulation process's memory space and the cluster control system process's memory space as a direct data channel.

[0062] The equivalent status data packet is written to a designated location in the shared memory area via direct memory access or efficient memory copy operations. After writing, the intelligent fault-tolerant module sends a data readiness notification signal by modifying an atomic variable in the shared memory area or triggering a user-mode interrupt event. The cluster control system is configured to poll this atomic variable or listen for this interrupt event at an extremely high frequency, thereby detecting data readiness within microseconds and directly reading the processed data packet from the shared memory.

[0063] Because the equivalent state data packet is completely identical to the data generated by normal computation in terms of interface, timing, and format, the cluster control system cannot detect that the data originates from the intelligent fault-tolerant module. This seamless and uninterrupted fault shielding mechanism ensures that even if an anomaly or timeout occurs during high-fidelity simulation computation, the system can still immediately switch to degrade mode, providing valid data output that meets safety and logical consistency requirements before the arrival of fixed periodic boundaries. This maintains the timing integrity of the control loop and prevents the entire verification platform from stalling due to the failure of a single computing unit.

[0064] After completing the data takeover for the current fixed control cycle, the intelligent fault-tolerant module also generates a logical isolation status identifier for the abnormal node and notifies the cluster control system of this identifier. The logical isolation status identifier is a flag field used to indicate that the node is currently in a fault state and needs to be temporarily removed from the coordination control logic of the cluster control system.

[0065] Upon receiving a logical isolation status flag, the cluster control system will suspend issuing control commands to the abnormal node in subsequent control cycles, thereby dynamically removing it from the current coordination control logic. The abnormal node will be isolated for maintenance until operations personnel intervene and perform manual recovery operations before it can reconnect to the system. This mechanism ensures that a severe failure of a single node will not have a cascading impact on the stability and performance of the cluster-level control algorithm, providing the system with crucial fault tolerance and operational resilience.

[0066] In some preferred examples, the intelligent fault-tolerant module serves as a core component ensuring the reliability of the system's hard real-time closed-loop operation. Its design is based on a crucial understanding: even under strict synchronization mechanisms, the inherent time uncertainty of high-fidelity simulation computation remains a significant source of risk for system operation. The module's core function is to monitor, intelligently decide on, and seamlessly take over in real-time any computation timeouts, process anomalies, or data anomalies that may occur in the simulation computation cluster. Its fundamental goal is to ensure that, under any operating condition, the system can output logically coherent and engineering-safe wind turbine status data before the strict physical cycle boundaries locked by the synchronization mechanism. This ensures that even when there are fluctuations in the underlying computation, the temporal integrity, output validity, and system stability of the entire control closed loop can be unconditionally maintained.

[0067] This module is implemented based on a layered processing architecture, comprising three core stages: real-time monitoring and prediction, hierarchical strategy decision-making and arbitration, and data takeover and transparent injection. These three stages are closely linked, forming a complete closed loop from anomaly detection to anomaly handling.

[0068] The intelligent fault-tolerant module embeds a high-precision monitor, which is configured to continuously collect real-time signals from the simulation cluster module. The real-time signals include three key types of information: the computation progress of each simulation instance, the process status, and the time margin.

[0069] Computation progress refers to the proportion of computational work completed by a simulation instance within the current cycle relative to the total workload, usually expressed as a percentage of iterations completed. For example, a computation progress of 60% for a simulation instance means that the instance has completed 60% of the computational tasks for the current cycle. Process status refers to the operational health of the process containing the simulation instance, including status indicators such as normal operation, computational delay, process suspension, and process crash. Time margin refers to the remaining available time from the current moment to the deadline of the fixed control cycle, reflecting how much time the instance has left to complete the remaining computational tasks.

[0070] This high-precision monitor does not passively wait for the cycle to end before making a judgment. Instead, it makes forward-looking predictions midway through the cycle based on a preset computation time model and historical data. The specific method for forward-looking prediction is as follows: the high-precision monitor compares the computation progress collected at the current moment with the preset computation time model, and combines this with the computation performance of the simulation instance in historical cycles to predict the probability that the instance will complete the computation on time within the current cycle. For example, if a simulation instance has only completed 20% of the computation progress halfway through the cycle, while historical data shows that this instance usually completes more than 50% of the progress by the midpoint of the cycle, the high-precision monitor determines that the instance has a high risk of timeout.

[0071] Through this forward-looking prediction mechanism, the high-precision monitor can assess the risk level of each simulation instance's timely completion of calculations midway through the cycle. The risk level is categorized into three levels: low, medium, and high. Low risk indicates that the instance has a high probability of completing the calculation on time and requires no intervention. Medium risk indicates that the instance has a certain possibility of timeout and requires close monitoring. High risk indicates that the instance is highly likely to fail to complete the calculation on time and requires advance preparation for fault-tolerant takeover.

[0072] The intelligent fault-tolerance module uses a hierarchical strategy decision-making and arbitrator to pre-set a multi-level fault-tolerance strategy library. This library contains three pre-set fault-tolerance strategies: interpolation strategy, last valid value preservation strategy, and safe state injection strategy. These three strategies are arranged from low to high according to their degree of intervention in the normal operation of the system, and are suitable for different degrees of abnormal situations.

[0073] The hierarchical strategy decision-making and arbitration mechanism selects the appropriate fault-tolerance strategy based on the risk assessment results provided by the high-precision monitor. When the risk assessment result is low risk, the hierarchical strategy decision-making and arbitration mechanism does not trigger any fault-tolerance strategy, allowing the system to operate normally. When the risk assessment result is medium risk, the hierarchical strategy decision-making and arbitration mechanism initiates an interpolation strategy as a contingency plan, while continuing to monitor the computation progress of the instance. When the risk assessment result is high risk or a timeout has been confirmed, the hierarchical strategy decision-making and arbitration mechanism selects the most suitable fault-tolerance strategy based on the specific type of anomaly.

[0074] Once the hierarchical strategy decision-making and arbitrator make their decisions, the data takeover engine of the intelligent fault-tolerant module immediately activates. The data takeover engine has the authority to send a safety suspension signal to the corresponding problematic simulation instance. The safety suspension signal is a control command used to notify the problematic simulation instance to stop its current computational task and enter a suspended state to prevent it from continuing to generate invalid or erroneous data in subsequent cycles.

[0075] Based on the selected strategy, the data takeover engine uses cached historical data or built-in security parameters to generate wind turbine status data packets that meet the strategy requirements in real time. These data packets contain status information in a format completely consistent with the data that should be output under normal conditions for this simulation instance, including key operating parameters such as pitch angle, generator speed, generator torque, and nacelle acceleration.

[0076] Subsequently, the turbine status data packet is seamlessly injected into the system data stream via a shared memory channel. The shared memory channel is a data transmission path established during the zero-wait delivery phase after computation in the acceleration module. By bypassing the operating system network protocol stack, a shared memory area is established between the simulation process's memory space and the cluster control system process's memory space as a direct data channel. The data takeover engine writes the generated turbine status data packet to a designated location in the shared memory area through direct memory access or efficient memory copy operations, and sends a data readiness notification signal by modifying atomic variables within the shared memory area or triggering user-mode interrupt events.

[0077] For downstream cluster control systems, this data is completely consistent with and transparent to data generated by normal computation in terms of interface, timing, and format, and it is impossible for the system to perceive that it originates from the intelligent fault-tolerant module. This seamless and uninterrupted fault shielding mechanism ensures that even if anomalies or timeouts occur during high-fidelity simulation computation, the system can still immediately switch to degraded mode, providing valid data output that meets safety and logical consistency requirements before the arrival of fixed periodic boundaries. This maintains the timing integrity of the control closed loop, preventing the entire verification platform from stalling due to the failure of a single computing unit, and providing the system with crucial fault tolerance and operational resilience.

[0078] Example 2: Building upon Example 1, Example 2 considers that in the hardware-in-the-loop verification of a wind farm cluster control system, to reproduce the coordinated operation of dozens or even hundreds of wind turbines in a real wind farm, a simulation environment matching its scale must be constructed. If only a single or a small number of simulation devices are used, it is impossible to evaluate the scheduling performance, communication load, and potential conflicts of the control system under large-scale unit linkage. Therefore, this example introduces a parallel simulation cluster.

[0079] The parallel simulation cluster consists of a logically coupled parallel scheduler and a parallel computing engine pool. The cluster can run a large number of high-fidelity simulation models in parallel and can work collaboratively with the physical controller within a unified timing framework. The parallel scheduler is responsible for task scheduling and distribution, while the parallel computing engine pool is responsible for the actual simulation computation execution. The two interact via a low-latency internal communication bus.

[0080] The parallel scheduler controller is configured to maintain a registry. This registry contains identifiers and resource mapping information for all active simulation instances. The active simulation instance identifier is a unique identifier for each running simulation instance, used to distinguish different simulation tasks. The resource mapping information records the correspondence between each simulation instance and the compute nodes in the parallel computing engine pool, including the compute node number, container number, and allocated hardware resource information of the simulation instance.

[0081] The registry maintenance process includes the registration and deregistration of simulation instances. When a new simulation instance starts, the parallel scheduler assigns a unique simulation instance identifier to it, adds a new record to the registry, and maps the instance to an idle compute node and container in the parallel computing engine pool. When a simulation instance completes its task or terminates abnormally, the parallel scheduler deletes the record corresponding to that instance from the registry and releases the computing resources it occupied. Dynamic registry maintenance ensures that the parallel simulation cluster can flexibly respond to changes in the number of simulation instances, supporting the dynamic expansion and contraction of the simulation scale.

[0082] At the start of each physical cycle defined by an external precision clock source, the parallel scheduling controller receives a synchronization control command frame from the synchronization triggering center. This synchronization control command frame encapsulates a global cycle number and a high-precision timestamp, providing a unified timing reference for all simulation instances.

[0083] The parallel scheduling controller, based on the simulation instance identifiers and resource mapping information recorded in the registry, binds the broadcast frames contained in the synchronization control command frames with differentiated microenvironmental data obtained from the environment server, generating a series of personalized computational task packages. The differentiated microenvironmental data consists of local environmental parameters associated with the virtual coordinates of each simulation instance, including wind speed, wind direction, and turbulence intensity at the location of that simulation instance. Because the actual environmental conditions of each wind turbine in a real wind farm differ, each simulation instance needs to receive microenvironmental data that matches its virtual location in order to accurately simulate the operating characteristics of the wind turbine at that location.

[0084] The data structure of a personalized computing task package includes the following components: a global cycle number, a high-precision timestamp, a global control command vector, differentiated microenvironment data for the simulation instance, and an instance identifier for the simulation instance. Each personalized computing task package is customized for a specific simulation instance and contains all the input information required for that instance to complete the simulation calculation within the current cycle.

[0085] After generating all personalized computing task packages, the parallel scheduling controller simultaneously distributes these task packages to the corresponding computing nodes in the parallel computing engine pool via a low-latency internal communication bus. The low-latency internal communication bus is a dedicated high-speed data path with microsecond-level transmission latency and deterministic transmission time, ensuring that all task packages arrive at the target computing nodes almost simultaneously.

[0086] The implementation of a low-latency internal communication bus can employ various technical solutions, including but not limited to high-speed Ethernet combined with real-time communication protocols, InfiniBand (a dedicated high-speed data path) high-speed interconnect network, or PCIe (Peripheral Component Interconnect Express) point-to-point direct communication. Regardless of the physical implementation method used, the core design requirement is to control the data transmission latency within the microsecond range, and the jitter of the transmission latency should be minimized to ensure that all simulation instances can start computing at almost the same time.

[0087] By employing a low-latency internal communication bus to simultaneously dispatch task packets, the design logically ensures that all simulation calculation tasks start strictly synchronously. This synchronous startup is a crucial step in achieving system-wide timing alignment, laying the foundation for subsequent lockstep synchronization control.

[0088] The physical implementation of the parallel computing engine pool is based on a set of high-performance computing nodes. Each high-performance computing node is equipped with multiple CPU (Central Processing Unit) cores, large-capacity memory, and high-speed storage devices, enabling it to run multiple simulation computing tasks simultaneously. The number of high-performance computing nodes is configured according to the needs of the simulation scale; for example, five high-performance computing nodes can support the parallel operation of fifty simulation instances.

[0089] Each high-performance computing node deploys multiple lightweight isolated containers. Lightweight isolated containers are an operating system-level virtualization technology that enables the creation of multiple isolated runtime environments on a single operating system kernel. Each container corresponds to a simulation instance and is pre-loaded with the same high-fidelity simulation kernel and parameter configuration file for the simulation instance. The high-fidelity simulation kernel can be in the form of a dynamic link library, providing accurate aerodynamic and mechanical model simulation capabilities. The parameter configuration file for the simulation instance contains personalized configuration information such as the wind turbine model, rated power, blade parameters, and tower parameters for that simulation instance.

[0090] The parallel computing engine pool uses operating system-level containerization technology and resource control group mechanisms to pre-allocate and lock specific CPU cores, memory blocks, and I / O bandwidth for each container, achieving strict resource isolation and quota control.

[0091] Operating system-level containerization technologies like Docker can create multiple isolated user-space instances on a single operating system instance. Each container has its own independent file system, network stack, and process space, and processes within a container cannot directly access resources outside the container. This isolation ensures that fluctuations in the computational load of any simulation instance will not affect the runtime performance and progress of other instances.

[0092] Resource control groups (R&D groups) are a feature provided by the Linux kernel used to limit, allocate, and monitor the use of system resources by process groups. In parallel computing engine pools, R&D groups are used to set strict resource limits for each container. Specifically, the `cpuset` subsystem (CPU aggregation subsystem) binds specific CPU cores to a particular container, ensuring that the container's computational tasks run only on the designated CPU cores, avoiding competition for CPU resources with other containers. The `memory` subsystem sets a memory usage limit for containers, preventing a single container from exhausting system memory due to memory leaks or sudden memory demands. The `blkio` subsystem (block I / O subsystem) limits the disk I / O bandwidth of containers, ensuring that data read / write operations in one container do not affect the I / O performance of other containers.

[0093] Through the synergy of operating system-level containerization technology and resource control mechanisms, each simulation instance is guaranteed deterministic and undisturbed computing resources. This resource isolation and quota control are the hardware resource foundation for deterministic parallel computing, ensuring that all simulation instances can complete their simulation tasks in a fair and stable resource environment.

[0094] To ensure strict consistency in the timing of output across the entire cluster, a lockstep synchronization controller is embedded within the parallel computing engine pool. This controller monitors the computation progress of all containers based on a global cycle number. It mandates that all instances complete the current cycle's computation before the next cycle's instruction arrives, and coordinates the progress of each instance through a central barrier synchronization primitive.

[0095] The central barrier synchronization primitive is a synchronization mechanism in parallel programming. Its working principle is as follows: all simulation instances participating in the synchronization pause execution when they reach the barrier point, waiting for all other instances to reach the barrier point as well. Only when all instances have reached the barrier point is the barrier removed, allowing all instances to continue executing subsequent operations. In the parallel computing engine pool, the central barrier synchronization primitive is set at the end of each computation cycle. For instances that complete computation early, the lockstep synchronization controller puts them into a waiting state, waiting for other instances that have not yet finished. For instances that experience computational errors or timeouts, the lockstep synchronization controller marks them as abnormal and triggers the intelligent fault-tolerant module to take over the data.

[0096] Through the lockstep synchronization control mechanism, all state data output from the parallel computing engine pool logically corresponds to the same complete physical cycle moment, ensuring strict consistency of the output timing of the entire system.

[0097] Example 3: Building upon Example 1, Example 3 addresses the issue that while a blocking hard synchronization mechanism can logically force global timing alignment between the simulation process and the physical clock, it introduces a significant drawback in engineering implementation: the length of the blocking wait time the master control unit must expend to await the simulation response within a fixed physical cycle directly determines the available time budget for high-fidelity simulation calculations. If this wait time is excessively long due to inherent delays in simulation data processing and transmission, it will severely compress the actual simulation calculation time window, potentially forcing the high-fidelity model to degrade or trigger timeout protection due to its inability to complete calculations within the cycle, thereby compromising the fidelity and continuity of the verification.

[0098] To address the aforementioned issues, this embodiment introduces an acceleration module. The core function of this module is to construct an accelerated processing pipeline consisting of three stages: a pre-calculation synchronous input optimization stage, a mid-calculation intelligent data compression stage, and a post-calculation zero-wait channel delivery stage, specifically addressing the data preparation and exchange stages necessary before and after simulation calculations. By optimizing this pipeline to the extreme, the time consumed in each stage is compressed and stabilized within an extremely short microsecond range, thereby shortening and stabilizing the blocking waiting time at the main control end to a minimum, deterministic value. This allows the high-fidelity simulation calculation itself to achieve a maximized and stable execution time window within a fixed cycle time budget, significantly reducing the risk of cycle timeouts due to data processing and transmission delays.

[0099] The pre-computation synchronous input optimization phase aims to eliminate the delay and asynchrony in the distribution of control commands and environmental data to each simulation instance, providing a clean and synchronized starting condition for the parallel computing cluster.

[0100] This submodule is coupled to the synchronization triggering center and receives synchronization control command frames encapsulated with a global cycle number and a high-precision timestamp, as well as global environment data. This submodule simultaneously writes these data frames into a predetermined memory area accessible to all computing nodes via multicast communication protocol or shared memory mapping technology, completing the data pre-setting operation. Multicast communication protocol enables efficient one-to-many data distribution, ensuring that all computing nodes receive the same data content almost simultaneously. Shared memory mapping technology allows multiple processes to directly access the same physical memory area, avoiding the overhead of data copying between processes.

[0101] To achieve strict synchronization at the start of computation, this submodule further collaborates with an external precision clock source. After data pre-setting, this submodule generates and sends a hardware synchronization pulse signal to all computing nodes. This hardware synchronization pulse signal has extremely high time accuracy; its rising or falling edge can be detected simultaneously by all computing nodes. This pulse signal triggers each simulation instance to simultaneously read the input data for the current cycle from the shared memory region and immediately begin computation, thereby controlling the synchronization error of the entire cluster's computation start point within microseconds. In this way, all parallel computing tasks have completely consistent and maximized available time slices, providing ideal starting conditions for subsequent high-fidelity simulation computations.

[0102] The intelligent data compression stage in the computation is executed during or immediately after the simulation computation process. Its core task is to perform real-time, intelligent compression at the source of data generation to minimize the amount of data to be transmitted and to stabilize the compression processing time. This stage is based on a dynamic differential compression mechanism.

[0103] The core idea of ​​dynamic differential compression is that for simulation output data generated in continuous cycles, the data changes between adjacent cycles are often small. Therefore, the amount of data transmitted can be significantly reduced by transmitting only the changed portion instead of all the data. This mechanism independently determines the data frame type at the current moment through preset rules and adopts different processing strategies for different types of data frames.

[0104] The dynamic differential compression mechanism first independently determines the data frame type at the current moment using preset rules. Data frame types are divided into two categories: keyframes and transition frames.

[0105] Keyframe insertion conditions include the following three cases: First, keyframes are forcibly inserted at fixed time periods. This fixed time period can be configured according to simulation accuracy requirements, for example, inserting a keyframe every ten periods to periodically reset accumulated errors and prevent errors from accumulating over time. Second, a keyframe is inserted immediately when the change in any variable exceeds a preset emergency threshold. The preset emergency threshold is the maximum allowable change for each variable. When the change in a variable exceeds this threshold, it indicates a significant change in the system's state, requiring the recording of all data to ensure accuracy. Third, the first frame at system startup is also a keyframe, as there is no historical data available for reference at this time.

[0106] All other frames that do not meet the above conditions are considered transition frames. The processing method for transition frames differs from that for keyframes, and its purpose is to minimize the amount of data transmitted while ensuring data accuracy.

[0107] For keyframes, the dynamic differential compression mechanism directly records and transmits the complete full values ​​of all variables. The full value refers to the original value of all simulation output variables at that moment, without any compression processing. Keyframes serve two purposes: firstly, they provide accurate reference data to the receiving end for initializing or resetting the data reconstruction process; secondly, they periodically reset accumulated errors to prevent error accumulation caused by continuous differential accumulation.

[0108] Keyframes contain a large amount of data, but due to their low insertion frequency, their impact on the overall data transmission volume is limited. By properly configuring the keyframe insertion period, a good balance can be achieved between data accuracy and transmission efficiency.

[0109] For transition frames, the dynamic differential compression mechanism independently calculates the difference between the current value and the previous reserved value for each variable. The previous reserved value refers to the value of the variable that was most recently recorded and transmitted. It may be the full value in the key frame or the reconstructed value corresponding to the differential value that was determined to be transmitted in the previous transition frame.

[0110] After the difference values ​​are calculated, the dynamic difference compression mechanism generates dynamic compression thresholds for each variable through a lightweight multi-output neural network model. This lightweight real-time decision model employs a multi-input multi-output feedforward neural network architecture. Its input layer consists of global working condition context features collected at the current moment, represented as vectors. Where N represents the dimension of the input features, and R represents the real number space. Global operating context features include parameters such as wind speed, turbulence intensity, control command rate of change, and system state; these parameters reflect the overall environmental conditions of the current simulation operation. The hidden layer is a two- to three-layer fully connected structure, employing the ReLU (Rectified Linear Unit) activation function to introduce nonlinear transformation capabilities. The output layer consists of N independent neurons, each corresponding to a dynamic compression threshold of a simulation output variable, which is then mapped to a preset physical threshold range for each variable after Sigmoid activation and linear scaling.

[0111] The loss function of this lightweight real-time decision-making model As shown below: ; in, The total loss function is represented by the reconstruction loss error. and compressed revenue It consists of two parts. This is a coefficient for compression gains, used to adjust the balance between reconstruction accuracy and compression rate.

[0112] Reconstruction loss error The calculation formula is as follows: ; Where N represents the total number of simulation output variables, The weight coefficient of the i-th variable is used to ensure that variables with higher precision requirements receive greater optimization priority during training. For example, load variables and control command variables have higher weight coefficients. This represents the average relative error of the i-th variable. This represents the original value of the i-th variable. This represents the reconstructed value of the i-th variable.

[0113] Compressed revenue The calculation formula is as follows: ; in, This represents the difference value of the i-th variable at the current time. This represents the absolute value of the difference. The dynamic compression threshold of the i-th variable is represented by the output of the aforementioned lightweight multi-output neural network model. This is an indicator function that takes the value of one when the condition is true, and zero otherwise. This is the attenuation coefficient, used to adjust the rate at which compression gains decay when the difference value approaches the threshold. It is a very small positive number to prevent the denominator from being zero. This compression benefit The compression rate of a frame directly reflects the proportion of discarded differential values ​​to the total number of variables.

[0114] After obtaining the dynamic compression thresholds for each variable, the dynamic differential compression mechanism independently determines the value of each variable: if the absolute value of the difference between a variable and its corresponding dynamic compression threshold is not greater than the threshold, the difference is considered non-critical information, discarded at the source, and not included in the transmission data packet; the receiving end assumes the variable value remains unchanged. If the absolute value of the difference between a variable and its corresponding dynamic compression threshold is greater than the threshold, the difference is encoded and included in the data packet for transmission; the receiving end recovers the variable value by accumulating the difference.

[0115] All variables are independently determined and reconstructed, and only the differential values ​​of each variable or the full value of the keyframe that are determined to need to be transmitted are packaged and sent together. This selective transmission mechanism significantly reduces the total amount of data to be transmitted while ensuring the accuracy required by the control algorithm, thereby significantly reducing the time and bandwidth resources required for data transmission.

[0116] The zero-wait channel delivery phase after computation is responsible for delivering the compressed data to the cluster control system instantly with the shortest path and zero protocol overhead, completely eliminating latency and jitter in the transmission process.

[0117] This submodule completely bypasses the operating system's traditional network protocol stack, such as the TCP / IP protocol stack. Traditional network protocol stacks require multiple layers of protocol encapsulation and parsing during data transmission, introducing millisecond-level latency and random jitter. This submodule establishes a shared memory region or memory-mapped file as a physical direct data channel between the simulation process's memory space and the cluster control system process's memory space. The shared memory region is a physical memory area that can be accessed simultaneously by multiple processes, allowing multiple processes to directly read and write data in this region without going through kernel buffers or network transmission.

[0118] The compressed data packets are written to a designated location on the shared channel via direct memory access or efficient memory copy operations. Direct memory access technology allows data to be transferred directly between peripherals and memory without CPU intervention, thus significantly reducing data transfer latency. Efficient memory copy operations utilize the CPU's SIMD (Single Instruction Multiple Data) instruction set or DMA (Direct Memory Access) engine to achieve high-speed copying of memory blocks.

[0119] Once the data is ready, this submodule does not use any network packets for notification. Instead, it signals the data by modifying an atomic variable in the shared memory area or triggering a user-mode interrupt event. An atomic variable is a special type of variable whose read and write operations are indivisible, ensuring data consistency during concurrent access by multiple processes. This atomic variable acts as a doorbell flag; a change in its value indicates that new data is ready. The user-mode interrupt event is a lightweight inter-process communication mechanism that can directly transmit signals in user mode, avoiding the overhead of kernel-mode switching.

[0120] The cluster control system is configured to poll the atomic variable or listen for user-mode interrupt events at extremely high frequencies, enabling it to detect data readiness within microseconds and directly read processed data packets from shared memory. This mechanism transforms the millisecond-level, jitter-prone communication latency inherent in traditional network interactions into extremely short-duration, jitter-free deterministic memory access operations, providing the final delivery guarantee for the entire accelerated processing pipeline.

[0121] Example 4: A dynamic control and interaction system based on high-frequency simulation data with isochronous scaling is applied to a hardware-in-the-loop simulation platform for a cluster control system. The hardware-in-the-loop simulation platform includes at least one physical PLC and multiple simulation instances. The physical PLC and simulation instances together constitute the unit carrier for the cluster control system experiment.

[0122] This system is used to implement the dynamic control interaction method based on isochronous scaling of high-frequency simulation data described in Examples 1-3, such as... Figure 2 As shown, it comprises four core modules: a synchronous control center, a parallel simulation cluster, an acceleration module, and an intelligent fault-tolerant module. These modules work collaboratively to achieve high-precision timing alignment between the simulation and physical systems, low-cost large-scale verification, efficient data interaction, and system-level reliable fault tolerance.

[0123] Example 5: A computer terminal includes a memory, a processor, and a computer program stored in the memory and executable on the processor. When the processor executes the computer program, it implements the dynamic control interaction method for high-frequency simulation data based on isochronous scaling as described in Example 1.

[0124] Example 6: A computer-readable medium having a computer program stored thereon, which, when executed by a processor, can implement the dynamic control interaction method for high-frequency simulation data based on isochronous scaling as described in Example 1.

[0125] Working Principle: This invention, through a synchronous control center, encapsulates the control command vector, global environment data, global cycle number, and high-precision timestamp into a broadcast frame at the start of each fixed control cycle locked by an external high-precision clock. This frame is then simultaneously distributed to all physical PLCs and all simulation instances via multicast or broadcast protocols. This achieves microsecond-level synchronous arrival of commands at the physical transmission layer, providing a completely consistent command start point and time reference for the entire system. Based on this, the synchronous control center starts a blocking wait timer after the broadcast frame is distributed. The timeout period of this blocking wait timer is set to be equal to the length of the fixed control cycle minus a preset protection margin. Within the current fixed control cycle, it waits for all controlled nodes to return confirmation signals indicating completion of the current cycle's calculation. When all controlled nodes return confirmation signals on time, the synchronous control center unblocks and enters the next fixed control cycle. When an abnormal node fails to return a confirmation signal, the intelligent fault-tolerant module is triggered to take over the data of that abnormal node, generating an equivalent status data packet and injecting it into the system data stream through a shared memory channel. This mandatory cycle control mechanism, which involves issuing commands, waiting, and collecting data for advancement, combined with a dual logic design that allows for timeout and fault tolerance, fundamentally solves the time drift and timing mismatch problems caused by the independent local clock driving the simulation process in traditional simulation technologies. Specifically, this mechanism forcibly incorporates the simulation process into the physical clock scheduling framework, ensuring precise alignment between the simulated wind turbine's status feedback, the command cycle of the cluster control system, and the response timing of the physical PLC. This allows for the reproduction of the complex dynamics and precise timing logic of multi-unit collaborative operation in a real wind farm within a laboratory environment, significantly improving the realism, reliability, and effectiveness of hardware-in-the-loop simulation verification.

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

[0127] This application is described with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of this application. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, special-purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, generate instructions for implementing the flowchart... Figure 1One or more processes and / or boxes Figure 1 A device that provides the functions specified in one or more boxes.

[0128] These computer program instructions may also be stored in a computer-readable storage medium that can direct a computer or other programmable data processing device to function in a particular manner, such that the instructions stored in the computer-readable storage medium produce an article of manufacture including instruction means, which are implemented in a process Figure 1 One or more processes and / or boxes Figure 1 The function specified in one or more boxes.

[0129] These computer program instructions may also be loaded onto a computer or other programmable data processing equipment to cause a series of operational steps to be performed on the computer or other programmable equipment to produce a computer-implemented process, thereby providing instructions that execute on the computer or other programmable equipment for implementing the process. Figure 1 One or more processes and / or boxes Figure 1 The steps of the function specified in one or more boxes.

[0130] The specific embodiments described above further illustrate the purpose, technical solution, and beneficial effects of the present invention. It should be understood that the above description is only a specific embodiment of the present invention and is not intended to limit the scope of protection of the present invention. Any modifications, equivalent substitutions, improvements, etc., made within the spirit and principles of the present invention should be included within the scope of protection of the present invention.

Claims

1. A dynamic control interaction method based on isochronous scaling of high-frequency simulation data, characterized in that, A hardware-in-the-loop simulation platform for cluster control systems, comprising at least one physical PLC and multiple simulation instances, includes the following steps: At the start of each fixed control cycle locked by an external high-precision clock, the synchronization control center receives control command vectors and global environment data from the cluster control system, and encapsulates the control command vectors, the global environment data, the global cycle number, and the high-precision timestamp into a broadcast frame, which is then simultaneously sent to all the physical PLCs and all the simulation instances via multicast or broadcast protocols. After the synchronous control center completes the broadcast frame transmission, it starts a blocking wait timer. The timeout of the blocking wait timer is set to be equal to the length of the fixed control cycle minus a preset protection margin, and waits for all controlled nodes to return a confirmation signal that the calculation of this cycle is completed within the current fixed control cycle. If the synchronization control center receives confirmation signals from all controlled nodes before the current fixed control cycle ends, the blockage is lifted and the next fixed control cycle begins. If there are abnormal nodes that have not returned confirmation signals before the current fixed control cycle ends, the intelligent fault-tolerant module is triggered to take over the data of the abnormal nodes, generate an equivalent status data packet, and inject it into the system data stream through the shared memory channel.

2. The dynamic control interaction method for high-frequency simulation data based on isochronous scaling according to claim 1, characterized in that, The method also includes: The parallel scheduling controller maintains a registry containing all active simulation instance identifiers and resource mappings, binds the broadcast frames with differentiated micro-environment data to generate personalized computing task packages, and simultaneously distributes them to the corresponding computing nodes in the parallel computing engine pool through a low-latency internal communication bus. The parallel computing engine pool uses operating system-level containerization technology and resource control group mechanism to pre-allocate and lock a specific number of CPU cores, memory blocks and I / O bandwidth for each container, thereby achieving resource isolation and quota control.

3. The dynamic control interaction method for high-frequency simulation data based on isochronous scaling according to claim 1, characterized in that, The method also includes: The acceleration module consists of a pre-computation synchronous input optimization stage, an in-computation intelligent data compression stage, and a post-computation zero-wait channel delivery stage, which compresses and stabilizes the time consumption of each stage within the microsecond range. In the pre-computation synchronous input optimization stage, data frames are simultaneously written to a predetermined memory area accessible to all computing nodes through multicast communication protocol or shared memory mapping technology, and hardware synchronization pulse signals are generated in conjunction with an external precision clock source to trigger all simulation instances to simultaneously read the input data of this cycle from the shared memory area and start the calculation immediately. The intelligent data compression stage in the calculation adopts a dynamic differential compression mechanism, which forcibly inserts key frames that record the full values ​​of all variables at fixed time periods, or immediately inserts key frames when the change of any variable exceeds a preset emergency threshold. When the key frame conditions are not met, the difference between the current value and the previous retained value of each variable is calculated independently and a judgment is made independently according to the preset dynamic compression threshold. If the absolute value of the difference is not greater than the threshold, it is discarded; otherwise, it is encoded and transmitted. The receiving end recovers the variable value by accumulating the difference value and resets the accumulated error periodically through key frames. The zero-wait channel delivery phase after computation bypasses the operating system network protocol stack and establishes a shared memory area between the memory space of the simulation process and the memory space of the cluster control system process as a direct data channel. The compressed data packets are written to the specified location of the shared channel through direct memory access or efficient memory copy operation, and the data ready notification signal is obtained by modifying atomic variables in the shared memory area or triggering user-mode interrupt events.

4. The dynamic control interaction method for high-frequency simulation data based on isochronous scaling according to claim 1, characterized in that, The method also includes: The intelligent fault-tolerant module continuously collects the computation progress, process status and time margin of each simulation instance through a high-precision monitor, and makes forward-looking predictions in the middle of the cycle based on a preset computation time consumption model and historical data to assess the risk level of each simulation instance completing the computation on time. The intelligent fault-tolerant module uses a hierarchical strategy decision-making and arbitrator to pre-set a multi-level fault-tolerant strategy library that includes interpolation strategy, last effective value preservation strategy and safe state injection strategy, and selects the corresponding fault-tolerant strategy based on the risk assessment results of the high-precision monitor. Specifically, when the interpolation strategy predicts that the computation of the abnormal node will be delayed but can be completed at the start of the next cycle, it uses historical valid state data from the most recent cycles to estimate the expected value for the current cycle through linear or quadratic extrapolation algorithms; when the last valid value preservation strategy detects that the computation has been severely interrupted or prematurely terminated, it directly outputs the valid state data verified in the previous cycle; when the safe state injection strategy detects continuous timeouts or system-level failures, it forces the key control variables of the abnormal node to be set to predefined absolute safe values, generates a logical isolation state identifier for the abnormal node, and notifies the cluster control system to suspend issuing control commands to the abnormal node. The intelligent fault-tolerant module sends a safety suspension signal to the problem simulation instance through the data takeover engine, and generates a wind turbine status data packet that meets the requirements of the selected strategy in real time. It is then seamlessly injected into the system data stream through the shared memory channel, so that the cluster control system cannot detect that the data packet originates from the intelligent fault-tolerant module in terms of interface, timing and format.

5. A dynamic control interactive system based on high-frequency simulation data using isochronous scaling, characterized in that, A hardware-in-the-loop simulation platform for cluster control systems, comprising at least one physical PLC and multiple simulation instances, the system including: The synchronization control center is configured as follows: At the start of each fixed control cycle locked by an external high-precision clock, control command vectors and global environment data are received from the cluster control system. The control command vectors, global environment data, global cycle number, and high-precision timestamp are encapsulated into a broadcast frame and simultaneously sent to all physical PLCs and all simulation instances via multicast or broadcast protocol. After the broadcast frame is sent, a blocking wait timer is started. The timeout of the blocking wait timer is set to be equal to the length of the fixed control cycle minus a preset protection margin. The timer waits for all controlled nodes to return a confirmation signal that the calculation of this cycle is completed within the current fixed control cycle. If acknowledgment signals from all controlled nodes are received before the current fixed control cycle ends, the blockage is lifted and the next fixed control cycle begins; if there are abnormal nodes that have not returned acknowledgment signals before the current fixed control cycle ends, the intelligent fault-tolerant module is triggered to take over the data of the abnormal nodes.

6. The high-frequency simulation data dynamic control interactive system based on isochronous scaling according to claim 5, characterized in that, The system also includes: Parallel simulation cluster, comprising a parallel scheduler controller and a parallel computing engine pool; The parallel scheduling controller is configured to maintain a registry containing all active simulation instance identifiers and resource mappings, bind the broadcast frames with differentiated micro-environment data to generate personalized computing task packages, and simultaneously distribute them to the corresponding computing nodes in the parallel computing engine pool via a low-latency internal communication bus. The parallel computing engine pool consists of multiple high-performance computing nodes, each of which is equipped with multiple lightweight isolated containers. Each container corresponds to a simulation instance and is preloaded with the same high-fidelity simulation kernel and parameter configuration file of the simulation instance. The parallel computing engine pool uses operating system-level containerization technology and resource control group mechanism to pre-allocate and lock a certain number of CPU cores, memory blocks and I / O bandwidth for each container to achieve resource isolation and quota control.

7. The high-frequency simulation data dynamic control interactive system based on isochronous scaling according to claim 5, characterized in that, The system also includes: The acceleration module is configured to form an accelerated processing pipeline through a pre-computation synchronous input optimization stage, an in-computation intelligent data compression stage, and a post-computation zero-wait channel delivery stage, compressing and stabilizing the time consumption of each stage within the microsecond range. In the pre-computation synchronous input optimization stage, data frames are simultaneously written to a predetermined memory area accessible to all computing nodes through multicast communication protocol or shared memory mapping technology, and hardware synchronization pulse signals are generated in conjunction with an external precision clock source to trigger all simulation instances to simultaneously read the input data of this cycle from the shared memory area and start the calculation immediately. The intelligent data compression stage in the calculation adopts a dynamic differential compression mechanism, which forcibly inserts key frames that record the full values ​​of all variables at fixed time periods, or immediately inserts key frames when the change of any variable exceeds a preset emergency threshold. When the key frame conditions are not met, the difference between the current value and the previous retained value of each variable is calculated independently and a judgment is made independently according to the preset dynamic compression threshold. If the absolute value of the difference is not greater than the threshold, it is discarded; otherwise, it is encoded and transmitted. The receiving end recovers the variable value by accumulating the difference value and resets the accumulated error periodically through key frames. The zero-wait channel delivery phase after computation bypasses the operating system network protocol stack and establishes a shared memory area between the memory space of the simulation process and the memory space of the cluster control system process as a direct data channel. The compressed data packets are written to the specified location of the shared channel through direct memory access or efficient memory copy operation, and the data ready notification signal is obtained by modifying atomic variables in the shared memory area or triggering user-mode interrupt events.

8. The high-frequency simulation data dynamic control interactive system based on isochronous scaling according to claim 5, characterized in that, The system also includes: The intelligent fault-tolerant module is configured to continuously collect the computation progress, process status and time margin of each simulation instance through a high-precision monitor, and make forward-looking predictions in the middle of the cycle based on a preset computation time consumption model and historical data to assess the risk level of each simulation instance completing the computation on time. The intelligent fault-tolerant module is also configured to select the appropriate fault-tolerant strategy based on the risk assessment results of the high-precision monitor by using a hierarchical strategy decision-making mechanism and an arbitrator to pre-set a multi-level fault-tolerant strategy library that includes interpolation strategy, last effective value preservation strategy and safe state injection strategy. Specifically, when the interpolation strategy predicts that the computation of the abnormal node will be delayed but can be completed at the start of the next cycle, it uses historical valid state data from the most recent cycles to estimate the expected value for the current cycle through linear or quadratic extrapolation algorithms; when the last valid value preservation strategy detects that the computation has been severely interrupted or prematurely terminated, it directly outputs the valid state data verified in the previous cycle; when the safe state injection strategy detects continuous timeouts or system-level failures, it forces the key control variables of the abnormal node to be set to predefined absolute safe values, generates a logical isolation state identifier for the abnormal node, and notifies the cluster control system to suspend issuing control commands to the abnormal node. The intelligent fault-tolerant module is also configured to send a safety suspension signal to the problem simulation instance through the data takeover engine, and generate a wind turbine status data packet that meets the policy requirements in real time according to the selected policy. The data packet is then seamlessly injected into the system data stream through the shared memory channel, so that the cluster control system cannot detect that the data packet originates from the intelligent fault-tolerant module in terms of interface, timing and format.

9. A computer terminal, comprising a memory, a processor, and a computer program stored in the memory and executable on the processor, characterized in that, When the processor executes the computer program, it implements the high-frequency simulation data dynamic control interaction method based on isochronous scaling as described in any one of claims 1-4.

10. A computer-readable medium having a computer program stored thereon, characterized in that, The computer program, when executed by a processor, can implement the dynamic control and interaction method for high-frequency simulation data based on isochronous scaling as described in any one of claims 1-4.

Images