System event timing model construction and automatic simulation method based on mbse

Abstract

The application discloses a system event timing model construction and automatic simulation method based on MBSE, which comprises the following steps: providing a visual canvas to generate a timing event directed acyclic graph representing event dependency; configuring a dead zone attribute containing a dead zone time interval and a dead zone penalty function for the graph node; establishing a dead zone state machine engine, when single simulation, triggering state machine transition and calculating dynamic delay value according to whether the input event timing of the node falls into the dead zone time interval; based on the reverse mapping of the dead zone boundary, constructing a mixed probability density function to carry out non-uniform density timing sampling and batch simulation; constructing a dead zone effect contribution degree statistical model, outputting attribution analysis and utilizing a heuristic algorithm for iterative optimization. The application restores the hardware non-linear hysteresis with high fidelity, concentrates computing power on the boundary to improve the edge fault efficiency, and realizes white-box type root cause positioning and intelligent timing optimization.

Description

Technical Field

[0001] This invention relates to the field of computer simulation technology, and in particular to a method for constructing and automatically simulating system event timing models based on MBSE. Background Technology

[0002] With the development of industrial automation technology, distributed control systems (DCS) and programmable logic controllers (PLCs) are widely used in large-scale energy equipment. As core components of these systems, actuators such as servo valves and hydraulic actuators inevitably experience nonlinear dead-zone effects due to mechanical wear, static friction, and oil characteristics during long-term operation. This leads to control signal truncation, system response hysteresis, and increased steady-state error, severely impacting the control accuracy and operational stability of the equipment. Representative solutions exist for compensating for actuator dead-zone nonlinearity as follows: CN114706310A discloses a fixed-time stable control method for a single-link robot with an input dead zone. This scheme primarily addresses the control problem of a single-link robot with an input dead zone. It combines backstepping technology, neural network adaptive control, and fixed-time stability theory to design an adaptive event-triggered controller, thereby achieving fixed-time convergence of system errors and reducing communication resource consumption. However, this scheme does not consider the dynamic disturbances to the dead zone boundary caused by complex industrial conditions, and cannot adapt to dead zone drift. Furthermore, it lacks a smooth compensation mechanism for large industrial equipment, making it difficult to solve the control chattering problem, thus limiting its engineering applicability.

[0003] CN117207178A discloses a fixed-time compensation control method for a robotic arm system with input dead time. This scheme addresses the control problem of robotic arm systems with input dead time by using a radial basis function neural network to approximate the system nonlinearity and designing a fixed-time adaptive compensation controller with an event-triggered mechanism, thereby achieving rapid system stabilization and saving communication resources. However, this scheme uses static dead time modeling, fails to explore the temporal evolution law of dead time characteristics, cannot achieve advance prediction and feedforward compensation, and suffers from control hysteresis; furthermore, it does not consider the strongly coupled operating conditions of multiple actuators in industrial applications and lacks a full life-cycle compensation strategy, making it difficult to adapt to the needs of large-scale industrial control systems.

[0004] In summary, existing dead zone compensation technologies mostly use static models with fixed parameters, generally ignoring the dynamic disturbances of industrial operating conditions on dead zone characteristics. They lack online model correction and full life cycle adaptive optimization mechanisms, making it difficult to achieve high-precision dynamic compensation of dead zone under complex operating conditions and failing to meet the high-reliability control requirements of high-end industrial equipment. Summary of the Invention

[0005] The purpose of this section is to outline some aspects of embodiments of the present invention and to briefly describe some preferred embodiments. Simplifications or omissions may be made in this section, as well as in the abstract and title of this application, to avoid obscuring the purpose of these documents; however, such simplifications or omissions should not be construed as limiting the scope of the invention.

[0006] In view of the aforementioned existing problems, this invention is proposed. Therefore, this invention provides a method for constructing and automatically simulating system event timing models based on MBSE, to solve the problems mentioned in the background art.

[0007] To address the aforementioned technical problems, this invention provides the following technical solution: a method for constructing and automatically simulating system event timing models based on MBSE, comprising: Provides a visual canvas that responds to user drag and drop operations and generates a directed acyclic graph of time-series events, consisting of multiple nodes and directed edges, representing event dependencies. Configure an executor dead zone attribute for at least one node in the directed acyclic graph, the dead zone attribute including a preset dead zone time interval and a dead zone penalty function for calculating additional time overhead; A dead-zone state machine engine is established. When traversing the directed acyclic graph and performing a single simulation, the state machine engine is triggered to perform a corresponding state transition based on whether the timing of the input events of a node falls within its dead-zone time interval. Based on the boundary of the dead time interval, non-uniform density time-series sampling is performed, batch simulation verification is carried out, and time-series optimization results with dead-zone effect attribution analysis are output.

[0008] Compared with the prior art, the beneficial effects of the present invention are as follows: 1. This invention abandons the idealized assumption of simple linear time accumulation in traditional time series models and introduces a dead-zone time interval and a dead-zone state machine engine. By using a nonlinear penalty function based on the relative position of the input time series and the dead-zone boundary, the black-box time extrapolation is decoupled into a traceable physical state transition process, realistically twinning the nonlinear stagnation effect of complex equipment caused by the transient evolution of mechanical characteristics in digital space.

[0009] 2. To address the problem of significant computational waste in traditional uniform sampling, this invention employs a non-uniform density temporal sampling algorithm based on inverse mapping of dead zone boundaries. This algorithm forces the random number generator to sample at high frequency within the neighborhood of sensitive initial timing anchor points that are prone to causing timing jams, concentrating limited computing power on nonlinear critical operating points, thereby improving the capture rate of timing conflicts and cascading collapse edge scenarios.

[0010] 3. Furthermore, this invention overcomes the limitations of traditional simulators' black-box alarms that fail to reach limits or have unclear causes by statistically analyzing the contribution of the dead-zone effect. It can accurately mark graph nodes causing timing performance degradation on a visualization canvas. Simultaneously, this contribution is used as a feedback gradient to automatically iteratively adjust system parameters through a heuristic algorithm, proactively avoiding the dead-zone effect. Attached Figure Description

[0011] To more clearly illustrate the technical solutions of the embodiments of the present invention, the accompanying drawings used in the description of the embodiments will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort. Wherein: Figure 1 This is a flowchart illustrating the overall process of constructing and automatically simulating a system event timing model based on MBSE, according to an embodiment of the present invention. Detailed Implementation

[0012] To make the above-mentioned objects, features, and advantages of the present invention more apparent and understandable, specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, and not all of them. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative effort should fall within the protection scope of the present invention.

[0013] Many specific details are set forth in the following description in order to provide a full understanding of the invention. However, the invention may also be practiced in other ways different from those described herein, and those skilled in the art can make similar extensions without departing from the spirit of the invention. Therefore, the invention is not limited to the specific embodiments disclosed below.

[0014] Secondly, the term "one embodiment" or "embodiment" as used herein refers to a specific feature, structure, or characteristic that may be included in at least one implementation of the present invention. The phrase "in one embodiment" appearing in different places in this specification does not necessarily refer to the same embodiment, nor is it a single or selective embodiment that is mutually exclusive with other embodiments.

[0015] Furthermore, in the description of this invention, it should be noted that the terms "upper," "lower," "inner," and "outer," etc., indicate the orientation or positional relationship based on the orientation or positional relationship shown in the accompanying drawings. These terms are used solely for the convenience of describing the invention and for simplifying the description, and do not indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation. Therefore, they should not be construed as limitations on the invention. In addition, the terms "first," "second," or "third" are used for descriptive purposes only and should not be construed as indicating or implying relative importance.

[0016] Example 1

[0017] Reference Figure 1 This is the first embodiment of the present invention, which provides a method for constructing and automatically simulating system event timing models based on MBSE, including: S1 provides a visual canvas that responds to user drag-and-drop and connection operations, generating a directed acyclic graph of time-series events consisting of multiple nodes and directed edges, representing event dependencies.

[0018] Furthermore, the node entities are instantiated and mapped to physical semantics.

[0019] Specifically, the system front-end first provides an interactive visual canvas. Users drag and drop preset system components from the component library on the left into this canvas. The canvas responds to this operation in the background, instantiating each drag and drop as a graph node, denoted as . Each graph node, under MBSE semantics, strictly corresponds to and represents a specific system event or processing task (e.g., the event or task could be a valve opening command for a spacecraft escape tower, a mechanical extension action of an actuator, etc.). Then, in computer memory, the system constructs a set of graph nodes, denoted as […]. ,in To visualize the total number of graph nodes in the canvas, the system will allocate a basic data structure for each graph node during the instantiation phase. This data structure includes a globally unique identifier (ID) for the node, a nominal execution duration, and a reserved dead zone attribute pointer.

[0020] It should be noted that since simple text encoding is difficult to intuitively express the concurrent logic of complex equipment, the essence of this step is to abstract and encapsulate the discrete hardware actions with independent time consumption in the real physical world into an object-oriented entity data structure that can be scheduled by the computer system, thereby laying the digital twin foundation for system-level timing simulation.

[0021] Furthermore, the operation of constructing directed edges and binding them with temporal causal relationships is performed.

[0022] Specifically, after generating graph node entities, the system generates directed edges in response to user connection operations between graph nodes on the visualization canvas, denoted as . It should be explained that this directed edge not only represents the connection of the graph, but also the temporal sequence and causal triggering relationship between these graph nodes. Similar to the graph node set mentioned above, a set of directed edges is defined, denoted as . When a user drags a connection from the output port of a graph node to the input port of a graph node, the system records a directed edge. .

[0023] It should be noted that in complex systems (such as aero-engine control logic), the triggering of events often has strong dependencies (e.g., the main thruster ignition (represented as a directed edge) can only be executed after the pressure relief valve (represented as a graph node) has been fully opened). The construction of directed edges aims to establish a strict hard constraint boundary at the algorithm level, ensuring that in automatic simulation, the earliest triggerable time of a graph node must be later than or equal to the actual completion time of another graph node.

[0024] Furthermore, the graph topology is parsed, and acyclicity validation is performed.

[0025] Specifically, after configuring the nodes and connections, the algorithm module in the system backend merges the graph node set and edge set to dynamically generate a time-series event graph model representing the global task orchestration, denoted as . In this process, since timing simulation requires time to flow in only one direction, the model must be a directed acyclic graph (DAG).

[0026] In addition, to prevent users from making incorrect loop connections on the visualization canvas, which could cause the simulation engine to enter an infinite loop, the system calls the topology sorting algorithm at this stage to perform a static check on the acyclic validity of the time-series event graph model.

[0027] Specifically, the algorithm calculates the in-degree of each node in the graph, denoted as . The calculation formula is as follows: in, Represents graph nodes The in-degree value, i.e., how many preceding events must be completed before this node; An indicator function is defined if and only if the condition within the parentheses is true (i.e., the edge). Exists in the edge set If the condition is not found, the return value is 1; otherwise, it returns 0.

[0028] Furthermore, the system will include all in-degrees Nodes with no preceding dependencies (i.e., root nodes) are pushed into an execution queue, and these nodes and their emanating edges are virtually removed. The in-degree values ​​of the remaining nodes are then updated. This process is repeated until the final execution queue contains a total of nodes equal to the specified number. If the verification passes, it proves that the generated time-series event graph is an absolutely acyclic directed acyclic graph; otherwise, if there are nodes that have not been traversed, it indicates that there is a time-series paradox (i.e., A waits for B, and B waits for A). The system will throw a topology deadlock alarm to the user on the front end of the visualization canvas and highlight the conflicting edges.

[0029] It should be noted that by using graph theory algorithms as the underlying support, this invention can transform UI interaction results into mathematically solvable DAG topological sequences. This not only filters out human logical errors in the early stages of constructing the temporal event graph model, but also ensures that the dead-zone state machine can traverse unidirectionally and without backtracking along a defined time axis.

[0030] S2. Configure an executor dead zone attribute for at least one node in the directed acyclic graph. The dead zone attribute includes a preset dead zone time interval and a dead zone penalty function for calculating additional time overhead.

[0031] Furthermore, after the timing event graph model is constructed, actuator dead zone attribute parameters are injected into the graph nodes with physical nonlinear characteristics.

[0032] Specifically, in real physical systems (such as hydraulic servo valves or electric actuators in aerospace equipment), due to mechanical friction, backlash, hysteresis, or the sampling blind zone of the controller, if the actuator receives a trigger command at a time that happens to fall within a specific nonlinear sensitive window, the actuator may fail to operate or experience significant stagnation delay. To reproduce this physical phenomenon with high fidelity in a computer, the system selects at least one graph node representing such a physical device in the aforementioned directed acyclic graph and configures it with a preset dead time interval, denoted as . This interval is defined by its lower and upper bounds, namely: in, Represents graph nodes The corresponding start-trigger timing threshold for the actuator dead-time effect; This indicates the time threshold at which the dead zone effect ends.

[0033] It should be noted that traditional timing models often use a simple linear accumulation method of start time + duration = end time. This idealized assumption masks the timing black holes caused by hardware dead zones. In contrast, this invention introduces a dead-time interval to establish the trigger boundary of hardware-level timing distortion in a pure software graph model, providing a parameter basis for discovering hidden timing conflicts.

[0034] Furthermore, the timing of input events for each graph node is determined.

[0035] Specifically, in a directed acyclic graph (DAG), a current node can only be triggered after all its immediate predecessor nodes have completed their tasks. Therefore, the system needs to obtain the input event sequence (i.e., actual arrival time) of the graph nodes through graph traversal, denoted as […]. The calculation formula is as follows: in, It represents the set of all parent nodes (i.e., predecessor dependent nodes) that point to nodes in a directed acyclic graph. Indicates the actual output (completion) timing of the parent node; The function is used to filter out the latest arrival time among all parallel pre-tasks, and use this as the valid input timing for the current node.

[0036] Furthermore, based on the relative position of the input event timing and the dead time interval boundary, a dead time penalty function is constructed to calculate the dynamic delay value.

[0037] Specifically, when the timing of the input events of a graph node falls exactly within the dead time interval (i.e., When this happens, the additional time overhead incurred by the actuator due to getting stuck in a dead zone must be calculated. To address this, the system configures a continuous non-linear dead zone penalty function for this node, denoted as... This function is used to calculate the dynamic delay value. The expression for this function is as follows: in, This represents the dynamic time delay penalty value that a graph node ultimately receives; This represents the relative intrusion depth of the input timing sequence from the left boundary of the dead zone; This represents the remaining traversal distance from the right boundary of the dead zone of the input timing sequence; This is a normalization factor used to standardize the range of intervals; The dead zone decay factor specific to this physical component (which can be calibrated from real hardware ground test data) reflects the maximum downtime that the component may experience under the worst operating conditions.

[0038] It should be noted that the aforementioned dead-zone penalty function mathematically resembles a downward-opening parabola or bell-shaped curve. Its physical meaning is that when the input event timing is just at the edge of the dead zone (i.e., close to the start or end timing threshold of the actuator's dead-zone effect), the physical lag effect is weak, and the calculated delay penalty value is small. Conversely, as the input event timing delves deeper into the center of the dead zone, the product of relative positions reaches its maximum, indicating that the actuator has fallen into the worst response point of its mechanical characteristics, and the system will impose the maximum time penalty. Through this dynamic calculation based on relative position, the graphical model of this invention can flexibly and realistically reflect the nonlinear response hysteresis law of complex equipment at different timing entry points, thereby overcoming the simulation distortion problem caused by fixed delay values.

[0039] S3. Establish a dead-zone state machine engine. When traversing the directed acyclic graph and performing a single simulation, the state machine engine is triggered to perform the corresponding state transition based on whether the timing of the input events of a node falls within its dead-zone time interval.

[0040] Furthermore, a node-oriented dead-zone state machine is built at the bottom layer of the simulation engine, and the core state space of the state machine is defined.

[0041] Specifically, the timing response of a physical actuator during operation is not static but evolves with the transient conditions of the hardware. To accurately represent this dynamic process in digital space, the system attaches an independent dead-time state machine engine to each graph node in the directed acyclic graph that is configured with a dead-time attribute. The state space of this state machine is defined as a set, which contains at least the following three discrete operating states: Nominal execution status: This indicates that the actuator is in the ideal response range and there is no additional mechanical jamming.

[0042] Dead zone suppression state: This indicates that the actuator receives an instruction but is in a dead zone sensitive window period, causing physical motion to stop or hardware instruction to be suppressed.

[0043] Delay penalty state: This indicates that the actuator is overcoming dead zone effects (e.g., establishing sufficient hydraulic differential or crossing mechanical backlash) and incurring compensatory time consumption.

[0044] Furthermore, in the initial state, before each single simulation begins, the state machines of all graph nodes are reset by default and reside in the nominal execution state.

[0045] It should be noted that by establishing a state machine engine, this invention decouples the black-box time accumulation in traditional simulation into an observable and traceable physical state transition process, providing underlying data structure support for accurately locating the exact physical stage at which timing faults occur (e.g., distinguishing whether the action is inherently slow or stuck in a dead zone).

[0046] Furthermore, a single simulation traversal is performed by combining the graph topology sequence, and the trigger condition determination logic for state transitions is constructed.

[0047] Specifically, the simulation engine will strictly follow the topological sorting sequence of the directed acyclic graph generated in S1, traversing the graph nodes sequentially. When traversing to a certain graph node, the system will obtain the actual input event timing sequence of that node calculated in S2. Subsequently, the collision detection module built into the state machine engine will determine whether the actual input event timing sequence falls within the preset dead time interval. Based on this, this invention defines a Boolean trigger condition indication function. The determination formula is as follows: Furthermore, based on the judgment result, the state machine engine executes the corresponding state branch and time deduction.

[0048] Specifically, regarding branch one above: if This indicates that the input event timing did not fall within the dead time interval. At this time, the state machine of the graph node remains in the nominal execution state without transitioning. The actual total execution time of this graph node in this simulation... That is, its inherent nominal execution time. And directly calculate its output (completion) timing. : Specifically, regarding branch two above: if This indicates that the input event timing unfortunately hits the dead zone. At this point, the state machine engine will trigger a series of chained state transitions and penalty calculation operations: First, the state machine instantly transitions from the nominal execution state to the dead-time suppression state, physically and logically locking the default time progression of the node. Then, the state machine automatically transitions from the dead-time suppression state to the delay penalty state. Upon entering the delay penalty state, the system calls the dead-time penalty function configured in S2, passing it the current input event sequence to calculate a dynamic delay value. Next, the state machine adds this dynamic delay value to the nominal execution time of the current graph node, ultimately determining the actual total execution time of the graph node in this simulation. The formula is: Finally, the actual output timing of the graph nodes after dead-time penalty is calculated, resulting in: Furthermore, after the calculation of the current graph node is completed, the output timing is used as a timing signal and transmitted to the subsequent child nodes along the directed edges of the directed acyclic graph until all graph nodes are traversed, thus completing a single simulation.

[0049] It should be noted that in complex concurrent network systems, once a critical node falls into a dead zone and incurs a dynamic latency penalty, this penalty time will be cascaded down through the topological dependencies of directed edges, thereby altering the timing of input events for all its subsequent child nodes. This butterfly effect-like timing propagation mechanism can realistically simulate system-level task crashes caused by minute hardware delays in real-world equipment, thus demonstrating the advantages of the present invention's solution based on MBSE underlying logic for automatic timing deduction.

[0050] S4. Perform non-uniform density time-series sampling based on the boundary of the dead-time interval, execute batch simulation verification, and output time-series optimization results with dead-time effect attribution analysis.

[0051] Furthermore, a time-series sampling model based on non-uniform density at the dead-time interval boundary is constructed.

[0052] It should be noted that in traditional Monte Carlo timing simulations, input variables are typically sampled uniformly and randomly across the global time domain. However, since the nonlinear dead-zone effect of the physical actuator is often triggered only within a very narrow boundary neighborhood, uniform sampling results in a significant amount of computational power being consumed in the stable operating region where no temporal abrupt changes occur, leading to extremely low error-finding efficiency. To address this issue, this invention employs a non-uniform sampling algorithm based on inverse mapping of dead-zone boundaries.

[0053] Specifically, the system first estimates the nominal path time from the root node to the currently configured dead zone node by traversing the reverse topological path of the directed acyclic graph, denoted as . In this process, since there may be multiple parallel topological paths from the root node to the graph node in a directed acyclic graph, in order to ensure the accuracy of the reverse mapping, the system adopts the critical path method, accumulating the total time of the path with the longest nominal execution time among all reachable paths as the nominal path time. Subsequently, the dead time boundaries of the graph nodes (i.e., the start and end thresholds of the dead time effect) are reverse mapped onto the initial trigger time axis of the root node, and the sensitive initial timing anchor points that are prone to causing timing jams are calculated. and : Finally, based on the aforementioned time-series anchors, the system constructs a mixture probability density function in the input time domain of the root node, denoted as... Used to generate test samples: in, Indicates the initial triggering sequence of the root node Non-uniform sampling probability density; It represents a uniform distribution function in the global context, used to ensure that low-density input time-series test samples can be generated even in regions far from the boundary, maintaining the most basic global exploration capability; Indicates sensitive anchor points For mathematical expectation, with is a Gaussian normal distribution function with standard deviation; specifically, It is also expressed as the sampling radius of the boundary neighborhood (i.e., the width of the test dense area). These represent the respective normalized weighting coefficients; This represents the total number of nodes in a directed acyclic graph that have the dead zone attribute configured.

[0054] It should be noted that, through the aforementioned hybrid probability density function, the algorithm can force the random number generator to... and High-density input timing test samples are generated frequently near the dead zone boundary (i.e., the mapped dead zone boundary neighborhood), while only low-density samples are generated in the absolutely safe region far from the dead zone boundary. The purpose is to allow the simulation engine to concentrate extremely limited computing resources (computing power) on those nonlinear critical operating points that are most likely to cause the system to experience timing cascade collapse, just like precision guidance, thereby improving the capture rate of edge failure scenarios by several times.

[0055] Furthermore, batch simulation verification is performed.

[0056] Specifically, the algorithm extracts based on the aforementioned density function. A test set is formed by 3 different initial trigger timing test samples, denoted as . Then, the system automatically uses the samples in the test set as the initial trigger sequence of the root node in the directed acyclic graph, calls the state machine engine in S3, and performs a complete graph traversal simulation for each initial trigger sequence. During this process, the system records the end-to-end global total time of each simulation task (i.e., the output sequence of the last leaf node in the directed acyclic graph).

[0057] Furthermore, the time-series optimization results with dead-zone effect attribution analysis are output and labeled on a visualization canvas.

[0058] Specifically, the difficulty in troubleshooting timing issues in complex systems lies in the fact that results exceed limits without a clear cause. When the end-to-end global total time of a simulation exceeds the system's designed safety threshold, a timing limit violation is determined to have occurred, and the index of that simulation is updated. Included in the failure set In addition, to accurately pinpoint which underlying physical component's dead-zone bottleneck caused the final task delay, the system constructed a statistical model for the contribution of the dead-zone effect. For graph nodes, the global contribution formula for causing temporal performance degradation is as follows: in, This represents the average percentage contribution of a graph node to the decrease or exceedance of the end-to-end timing delay margin across all failed batch simulations. Represents the total number of timing outages (the cardinality of the set elements); Indicates the first In this simulation, the dynamic delay value of the graph node is generated due to the triggering of the dead-zone state machine (transition to the delay penalty state); Indicates the first In this simulation, the sum of dead zone delay penalties generated by all nodes globally.

[0059] Furthermore, after calculating the contribution matrix, the nodes are sorted from largest to smallest contribution. The system front end receives this attribution analysis data and performs visual annotation on the visualization canvas provided by S1 on the graph node that has the highest contribution to the deterioration of time series performance (e.g., contribution greater than 30%). (e.g., render a red breathing alarm halo around it and display its contribution percentage and average dead zone penalty time in a floating display).

[0060] It should be noted that, through the combination of the above processing and front-end interaction, this invention transforms traditional black-box failure alarms into white-box root cause localization. Engineers can intuitively identify, with a WYSIWYG view on the visualization canvas, which valve or actuator has an unreasonable mechanical dead zone parameter setting, thus becoming a timing bottleneck in the entire concurrent task chain.

[0061] Furthermore, iterative timing performance optimization is performed.

[0062] Specifically, based on the results of the above attribution analysis, if a graph node is determined to be the core bottleneck causing the timing collapse (e.g., its contribution is greater than a preset safety trigger threshold), the system's built-in heuristic optimization algorithm will use this contribution as the feedback gradient to automatically perform iterative parameter adjustments. In this embodiment, the adjustment strategy mainly includes two types: The first method is software timing compensation (active avoidance strategy): The algorithm modifies the nominal execution time of the immediate predecessor nodes of the bottleneck graph node, which is equivalent to injecting active waiting delays into the control software. This shifts the actual input event timing of the graph node backward, thus crossing its dead-zone sensitive window period. in, and These are the nominal durations of the front-end map nodes before and after the adjustment, respectively. The preset iterative learning rate parameter (in this embodiment, the value is 0.1~0.5); This represents the average actual input timing of the node in the failure set.

[0063] The second approach is hardware tolerance tightening (physical upgrade strategy): If the software timing compensation exceeds the maximum allowable time for the global task, the algorithm attempts to tighten the dead zone decay coefficient of the graph nodes, which is equivalent to guiding real-world hardware selection and upgrades (e.g., using a higher-precision servo valve). Its update formula is: in, This is the updated dead zone attenuation coefficient; The penalty is the decrease step size coefficient.

[0064] Furthermore, the system automatically applies the updated parameters in the background and re-triggers the S3 and S4 simulation processes for the next round of verification. Each iteration is based on the above formula, continuously updating the parameters until the cardinality of the failure set decreases to near zero (i.e., meeting the requirement that the total end-to-end global time does not exceed the safety threshold of the system design), at which point the iteration stops, and the system outputs the optimal MBSE parameter baseline configuration scheme that is timing-completely converged and safe to the user.

[0065] It should be noted that the above embodiments are only used to illustrate the technical solutions of the present invention and are not intended to limit it. Although the present invention has been described in detail with reference to preferred embodiments, those skilled in the art should understand that modifications or equivalent substitutions can be made to the technical solutions of the present invention without departing from the spirit and scope of the technical solutions of the present invention, and all such modifications or substitutions should be covered within the scope of the claims of the present invention.

Claims

1. A method for constructing and automatically simulating system event timing models based on MBSE, characterized in that, include: Provides a visual canvas that responds to user drag and drop operations and generates a directed acyclic graph of time-series events, consisting of multiple nodes and directed edges, representing event dependencies. Configure an executor dead zone attribute for at least one node in the directed acyclic graph, the dead zone attribute including a preset dead zone time interval and a dead zone penalty function for calculating additional time overhead; A dead-zone state machine engine is established. When traversing the directed acyclic graph and performing a single simulation, the state machine engine is triggered to perform a corresponding state transition based on whether the timing of the input events of a node falls within its dead-zone time interval. Based on the boundary of the dead time interval, non-uniform density time-series sampling is performed, batch simulation verification is carried out, and time-series optimization results with dead-zone effect attribution analysis are output.

2. The method for constructing and automatically simulating system event timing models based on MBSE as described in claim 1, characterized in that, The node represents a system event or processing task, and the directed edge represents the temporal sequence and causal triggering relationship between the nodes.

3. The method for constructing and automatically simulating system event timing models based on MBSE as described in claim 1, characterized in that, The dead-zone penalty function is obtained by calculating a dynamic delay value based on the relative position of the input event timing and the boundary of the dead-zone time interval.

4. The method for constructing and automatically simulating system event timing models based on MBSE as described in claim 1, characterized in that, The dead-zone state machine engine includes at least: A nominal execution state, a dead-time suppression state, and a delay penalty state; The triggering condition for the state transition is: when the timing of the input event of a node falls within its dead time interval, the state machine transitions from the nominal execution state to the dead time suppression state.

5. The method for constructing and automatically simulating system event timing models based on MBSE as described in claim 4, characterized in that, After transitioning from the dead-time suppression state to the delay penalty state, the dead-time state machine engine performs the following operations: The dead zone penalty function of the node is called to calculate a dynamic delay value, and the dynamic delay value is added to the nominal execution time of the node to determine the actual total execution time of the node in this simulation.

6. The method for constructing and automatically simulating system event timing models based on MBSE as described in claim 1, characterized in that, Non-uniform density temporal sampling based on the boundaries of the dead time interval includes: High-density input timing test samples are generated within the boundary neighborhood of the dead time interval; Low-density input timing test samples are generated in regions far from the boundary.

7. The method for constructing and automatically simulating system event timing models based on MBSE as described in claim 6, characterized in that, Perform batch simulation verification, including: The non-uniform density timing test samples are used as the initial trigger timings of the root node in the directed acyclic graph, and a complete simulation traversal is performed for each initial trigger timing.

8. The method for constructing and automatically simulating system event timing models based on MBSE as described in claim 1, characterized in that, Output the time series optimization results with dead-zone effect attribution analysis, including: Statistically identify the contribution of which node dead-zone attributes trigger the decrease or exceedance of end-to-end timing delay margin in batch simulations.

9. The method for constructing and automatically simulating system event timing models based on MBSE as described in claim 8, characterized in that, Also includes: The results of the dead zone effect attribution analysis are used to visually annotate the nodes that contribute the most to the deterioration of timing performance on a visualization canvas.

10. The method for constructing and automatically simulating system event timing models based on MBSE as described in claim 1, characterized in that, The method further includes: Based on the results of the batch simulation verification, the parameters of the dead time interval or dead time penalty function of the node are automatically adjusted, and the simulation verification is re-executed to perform iterative timing performance optimization.

Images